Usados generalmente dentro del condicional If y sobre el For y While

MODULO DE MECANICA == (igual a)

SENSOR DE VELOCIDAD LINEAL  != (diferente de)  < (menor que)  > (mayor que)
ANGULAR  <= (menor o igual)  >= (mayor o igual)
ACELERACIÓN
DISTANCIA (DISTANCIA) Operadores matemáticos
FUERZA Se aplican al manejo de variables, condicionales y ciclos
If (a == b)

TERMODINAMICA = (asignar)

TEMPERATURA  % (módulo)  + (suma)  - (resta)  * (multiplicación)

PRESION  / (división)
CAUDAL
Estructuras de control
Son instrucciones que nos permiten tomar decisiones y hacer diversas
ELECTRICIDAD Y MAGNETISMO repeticiones de acuerdo a unos parámetros, dentro de las más
importantes podemos destacar:
VOLTAJE If
CORRIENTE  Switch/case
CAMPO MAGNETICO  For
CAMPO ELECTRICO
 While
Condicionales
HUMEDAD If (Si)
RADIACION if (entrada < 500)
ANEMÓMETRO {
// acción A
} else
{
// acción B
}
Switch/case (Casos)
switch (var) {
case 1:
// acción A
break;
case 2:
// acción B
break;
Estructuras default:
Son dos funciones principales que debe tener todo programa en // acción C
Arduino: }
setup(){
} Ciclos
Código de configuración inicial, solo se ejecuta una vez. Ideales para repetir lo que se encuentre dentro de ellos
For (por)
loop(){ for( int a=0; a>10; a++ )
} {
Esta función se ejecuta luego del setup(), se mantiene ejecutándose // acción a repetir
hasta que se desenergice o desconecte el Arduino. }

Variables While (mientras)

Booleano while ( var < 200) {
true ó false // acción a repetir
Boolean encendido=true; var++;
Entero }
Valor entero
int conta=5;
Carácter Funciones
Almacena un ASCII Una función es un conjunto de líneas de código que realizan una
char letra=’a’; tarea específica y puede retornar un valor. Las funciones pueden
Operadores booleanos tomar pará-metros que modifiquen su funcionamiento. Las funciones
Usados generalmente dentro del condicional If son utilizadas para descomponer gran-des problemas en tareas
 && (y) simples y para imple-mentar operaciones que son comúnmente
utilizadas durante un programa y de esta manera reducir la cantidad
 || (o) de código.
Cuando una función es invocada se le pasa el control a la misma, una
 ! (negación)
vez que ésta finalizó con su tarea el control es devuelto al punto
If (a || b)
desde el cual la función fue llamada.

Operadores de comparación Funciones digitales

Orientas a revisar el estado y la configuración de las entradas y +Operadores bit a bit
salidas digitales - & (bit a bit AND)
- | (bit a bit OR)
pinMode() - ^ (bit a bit XOR)
- ~ (bit a bit NOT)
Permite configurar un pin - << (a la izquierda BitShift)
pinMode(pin,modo) - >> (a la derecha BitShift)
+Operadores compuestos
pinMode (13,OUTPUT); - + + (incremento)
pinMode (a,INPUT); - -- (decremento)
- + = (compuesto adición)
- - = (compuesto substracción)
digitalWrite() - * = (compuesto multiplicación)
- / = (compuesto división)
Escribir un pin digital con 1 ó 0
-& = (compuesto bit a bit AND)
digitalWrite(pin,estado) - | = (compuesto bit a bit OR)

digitalWrite (13,HIGH); VARIABLES

digitalWrite (13,LOW);
+Constantes
digitalRead() - HIGH | LOW
Leer un pin digital (0 ó 1) - INPUT | OUTPUT
digitalRead(pin) - true | false
- Constantes enteras
int a = digitalRead (13); - Constantes flotante
+Tipos de datos
- void
Funciones análogas - boolean
- char
- byte
Ideales para la lectura y escritura de valores análogos - int
- word
analogRead() - long
Leer un valor análogo 0 a 1023 - unsigned long
analogRead(pin) - float
- double
int a = analogRead (A0); - string - arreglo char
- String - objeto
analogWrite() —> PWM - array
Escribir un valor análogo 0 a 255
analogWrite(pin,valor de PWM) +Utilidades
analogWrite (9, 134); - sizeof()
+Conversión
guía rápida programación - char()
- byte()
- setup() - int()
- loop() - word()
+Estructuras de control - long()
- if - float()
- if...else
- for
- switch case
- while +Digital I/O
- do... while - pinMode()
- break - digitalWrite()
- continue - digitalRead()
- return +Analogo I/O
- goto - analogReference()
+Sintaxis - analogRead()
- ; (punto y coma) - analogWrite() - PWM
- { } (llaves) +Avanzadas I/O
- / / (comentario de una sola línea) - tone()
- / * * / (comentario de varias líneas) - noTone()
- # define - shiftOut()
- # include - shiftIn()
+Operadores matemáticos -pulseIn()
- = (operador de asignación) +Tiempo
- + (suma) - millis()
- - (resta) - micros()
- * (multiplicación) - delay()
- / (división) - delayMicroseconds()
- % (módulo) +Matemáticas
- min()
+Operadores de comparación - max()
- abs()
- == (igual que)
- constrain()
- ! = (diferente de)
- map()
- < (menor que)
- pow()
- > (mayor que)
- sqrt()
- <= (menor o igual a)
- >= (mayor o igual a) +Trigonométricas
+Operadores booleanos - sin()
- cos()
- && (y)
- tan()
- || (o)
- ! (no)
+Acceso con apuntadores
- * eliminar la referencia del opera-dor +Números aleatorios
- & operador de referencia
- randomSeed() // Fin del programa
- random()
+Bits y Bytes #################################################
- lowByte()
- highByte()
- bitRead()
- bitWrite()
- bitSet()
- bitClear()
- bit()
+Interrupciones externas
- attachInterrupt()
- detachInterrupt()
+Interrupciones
- interrupts()
- noInterrupts()
+Comunicación
- Serial
- begin()
- end()
- available()
- read()
- peek()
- flush()
- print()
- println()
- write()

- EEPROM - leer y escribir

- Ethernet - conectarse a Internet
- Cristal líquido - control de LCD
- SD - lectura y escritura de tarjetas SD
- Servo - control de servomotores
- SPI - comunicación por el bus SPI
- Paso a paso - control de motores
- Wire - enviar y recibir datos TWI/I2C
… y muchas más visita

Enciende un LED por un segundo y lo apaga por el

mismo tiempo
*/
//------------------------------------
//Función principal
//------------------------------------
void setup() // Se ejecuta cada vez que el Arduino
se inicia
{
pinMode(13,OUTPUT); // Inicializa el pin 13 como una
salida
} //------------------------------------
//------------------------------------ //Declara puertos de entradas y salidas
//Función cíclica //------------------------------------
//------------------------------------ int pulsador=2; //Pin donde se encuentra el pulsador,
void loop() // Esta función se mantiene ejecutando entrada
{ // cuando este energizado el Arduino int led=13; //Pin donde se encuentra el LED, salida
digitalWrite(13,HIGH); // Enciende el LED //------------------------------------
delay(1000); // Temporiza un segundo (1s = 1000ms) //Funcion principal
digitalWrite(13,LOW); // Apaga el LED //------------------------------------
delay(1000); // Temporiza un segundo (1s = 1000ms) void setup() // Se ejecuta cada vez que el Arduino
} se inicia
{  Opción de Consola serial, ver 6F (paso 3)
pinMode(pulsador, INPUT); //Configurar el pulsador como
una entrada
pinMode(led,OUTPUT); //Configurar el LED como una salida
}
//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
//Condicional para saber estado del pulsador
if (digitalRead(pulsador)==HIGH)
{
//Pulsador oprimido
digitalWrite(led,HIGH); //Enciende el LED
}
else
{
//Pulsador NO oprimido
digitalWrite(led,LOW); //Apaga el LED
}
}
//Fin programa

EJERCICIO 01 La multinacional francesa Flante experta en ma-quinaria

industrial te ha contratado para que auto-matices una máquina cortadora de
papel. La condi-ción principal es que el operario de la máquina cuando vaya a
realizar el corte siempre mantenga las dos manos ocupadas, esta es una regla
de segu-ridad industrial para evitar accidentes. El operario debe oprimir los
dos pulsa-dores uno con cada mano y la cuchilla cortadora debe bajar y hacer
el corte. El siguiente montaje simula el control de la máquina, los dos
pulsadores (S1 y S2) y el LED rojo simula la cuchilla cortadora.

EJERCICIO 02
Tu padre quiere que realices un sistema de iluminación LED para las escaleras
de la casa. La condición es que si estás arriba y pulsas a S1 o si estás abajo y
pulsas S2 el LED Rojo se enciende y al dejar de pulsar se apaga. Como guía
de montaje toma la ima-gen anterior.

Lectura serial de una entrada digital

¿Qué aprendo?
 Manejar una entrada digital
Ver datos por la pantalla del computador
Consola serial
Lectura serial de una entrada digital
Leer una entrada digital y escribir por consola serial --------------------------------------
Conocimientos previos Leer una entrada digital y mostrar por la pantalla del
computador (consola serial) el estado del pulsador
 Señal digital cuando es oprimido
 Función digitalRead() y Se-rial.println() Cosas de Mecatrónica y Tienda de Robótica
*/
//------------------------------------
//Declara puertos de entradas y salidas
//------------------------------------
int boton=2; //Pin donde se encuentra el pulsador, entrada
//------------------------------------
//Funcion principal
//------------------------------------
void setup() // Se ejecuta cada vez que el Arduino se
inicia
{
//Configuración
pinMode(boton,INPUT); //Configurar el boton como una
entrada
Serial.begin(9600); //Inicia comunicación serial
}
//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
//Guardar en una variable entera el valor del boton 0 ó 1
int estado = digitalRead(boton);
//Condicional para saber estado del pulsador
if (estado==1)
{
// Pulsado
Serial.println("Pulsado"); //Imprime en la consola serial
} // "Pulsado"
else
{
// No esta pulsado
Serial.println("NO Pulsado"); //Imprime en la consola
serial
} // "NO Pulsado"
delay(100); //Retardo para la visualización de datos en la
consola
}
//Fin programa

TIPS

1– La codificación binaria es muy importante para transmitir datos

entre dispositivos, son las largas cadenas de 0 y 1, por ejemplo
00011101010101 esto podría ser un mensaje que contiene
información referente a una clave personal para acceder a un EJERCICIO 4
edificio. Los números en base 10 se pueden representar como valores
binarios: luces navideñas moder-nas son las siguientes: mien-tras se mantenga pulsado
2– Para recordar S1 una variable entera inicializa-da en 0 se comienza a incre-mentar de 20 en
- Para leer una señal digital usa: digitalRead(numeroPin);
- Para escribir una señal digital usa: digitalWrite(numeroPin, valor); 20, al soltar S1 la variable para de incre-mentarse, cuando se pulse S2 el valor
- Una salida o entrada digital siempre es HIGH o LOW de la variable se debe cargar a un ―Hola Mundo‖ del LED, esto quiere decir
que el LED va estar intermitente en intervalos de tiempo iguales al valor de la
variable. Por consola serial debes ir mostrando el valor de la variable. Para
que puedas volver la variable a 0 y puedas hacer otra rutina de intermitencia,
Ejercicio 03 Una empresa de gaseosas tiene un sistema con dos coloca la condición de que S1 y S2 se opriman al tiempo, con ello la variable
sensores, uno de ellos indica si la botella se ha llena-do con el líquido
entera debe volver a 0.
y el otro sensor indica si la botella ya tiene la tapa. Para este caso
simularemos los dos sensores por medio de dos pulsadores (S1 y S2).
La rutina se describe de esta manera: si la botella se llena de manera adecuada
(se debe activar S1 y mostrar por consola ―Gaseosa llena‖) luego de ello si
Lectura serial de una entrada
tiene la tapa colocada (se debe activar S2 y mostrar por consola ―Gaseosa
tapada‖), al finalizar el proceso se debe encender un LED que indica que el
análoga
proceso terminó bien y además se debe mostrar un mensaje por la consola ¿Qué aprendo?
―Gaseosa bien empacada‖. Recuerda que primero se debe activar S1 y luego  Manejar una entrada análoga
S2 para que le proceso sea válido. Ver datos por la pantalla del computador
Múltiples estados de un poten-ciómetro
Leer una entrada análoga
Conocimientos previos
 Señal análoga
 Función analogRead() y Serial.println()
 Opción de Consola serial, ver 6F (paso 3)
 int valor= analogRead(A0);
//Imprime en la consola serial el valor de la variable
Serial.println(valor);
//Retardo para la visualización de datos en la consola
delay(100);
}
//Fin programa

TIPS

Te invitamos a que conozcas algunos tipos de potenciómetros

2– Para recordar
- Para leer una señal análoga usa: analogRead(numeroPin);
- Para escribir una señal análoga de PWM usa: analogWrite(numeroPin, valor);
- Una entrada análoga va de 0 o 1023
- Una salida análoga de PWM va de 0 o 255

.EJERCICIO 5

Este reto es sencillo, pero te va a dar una idea de cómo hacer

grandes cosas escribiendo unas pocas líneas de código. Como bien lo
sabes, la lectura de una señal análoga te da un valor de 0 a 1023 (si
tienes alguna duda solo revisa el código de la página anterior).
El desafío de este ejercicio consiste en mostrar por la consola serial un
número entre 0 y 10, este número debe cambiar cuando muevas el
potenciómetro. El montaje de este ejercicio usa el mismo Esquema de
conexiones que el expuesto en la página 75. Suge-rencia… Revisa la función
map()

.EJERCICIO 5
en un número secreto de 0 a 1023 y guárdalo en una variable entera,
haz un programa para que tu amigo deba mo-ver el potenciómetro, si
el número que el va generando (mostrar por consola serial el valor de
la lectura del potenció-metro) al girar el potenciómetro está 10
números por arriba o 10 números por abajo al número que tu
pensaste y confirma con el pulsador S1 que ese es el número, el
progra-ma debe mostrar por consola ―Adivinaste el número‖ de lo
contrario ―Intenta de nuevo‖.
Este caso podría ser un ejemplo para que lo apliques a una Caja de seguridad,
para que guardes mucho dinero ;)

Lectura serial de entrada análoga

--------------------------------------
Leer una entrada análoga y mostrar por la pantalla del
computador (consola serial) el valor luego de girar
el potenciómetro
Cosas de Mecatrónica y Tienda de Robótica
*/
//------------------------------------
//Funcion principal
//------------------------------------
void setup() // Se ejecuta cada vez que el Arduino se
inicia
{
Serial.begin(9600); //Inicia comunicación serial
}
//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
//Guardar en una variable entera el valor del potenciómetro
0 a 1024
 {
Escritura serial digitalWrite(led,HIGH); // Enciende el LED
prendido=true; // Actualiza el estado del LED
¿Qué aprendo? }
 Entrada por consola (teclado) // Si es la letra 'a' y además el LED está encendido
else if ( (leer=='a') && (prendido==true) )
Variables booleanas {
Estado de un LED digitalWrite(led,LOW); // Apaga el LED
Escritura serial digital prendido=false; // Actualiza el estado del LED
}
Conocimientos previos }
 Señal digital //Fin programa
 Función digitalWrite() y Serial.read()
 Configuración de una comu-nicación serial EJERCICIOS
 Polaridad de un LED Avisos luminosos S.A. te ha contratado para que realices un programa que tiene
la característica de recibir datos, porque la idea es que el aviso de luces se
ubique en el piso 130 del Edificio Bulli y tu lo puedas controlar desde el piso 1,
así que por cada letra que le escribas por teclado a la Consola serial el
programa debe hacer determinada rutina con tres LEDs, si le escribes:
-Letra A: Prende los tres LED
-Letra B: Prende el LED1 por un segundo y lo apaga, luego prende el LED2 por
un segun-do y lo apaga y finalmente prende el LED3 por un segundo y lo apaga,
y vuelve a comenzar. Esta rutina genera una sensación de movimiento
-Letra C: Apaga los tres LED

--------------------------------------
Escritura serial
--------------------------------------
Consiste en escribir por la pantalla del computador
EJERCICIO
(consola serial) Tu abuelito tiene un cultivo de grandes y verdes lechugas, este cultivo tiene 3
una letra predeterminada, la primera vez que se escriba aspersores de agua y tu abuelito quiere prender estos aspersores desde su
está computador solo escribien-do unos valores por teclado, los aspersores tienen
un LED se enciende, si se vuelve a escribir por segunda vez un estado digital (Valor 0 es apagado y valor 1 es prendido). Debes reali-zar un
el LED se apaga. programa que lea una cadena de tres valores, para este ejercicio los aspersores
Cosas de Mecatrónica y Tienda de Robótica los vamos a simular con tres LED 1, 2 y 3 por ejemplo:
*/ Si tu abuelito escribe 000 : Todos los aspersores de agua deben estar apagados
//-------------------------------------------------- Si tu abuelito escribe 101 : El aspersor 1 y 3 se prenden pero el dos debe estar
//Declara puertos de entradas y salidas y variables apagado
//-------------------------------------------------- Si tu abuelito escribe 001 : El aspersor 1 y 2 se apagan pero el tres debe estar prendido
int led = 13; //Pin donde se encuentra el LED, salida
char leer; //Variable donde se almacena la letra
boolean prendido=false; //Estado LED la primera vez,
apagado
Encender un LED por PWM
¿Qué aprendo?
//------------------------------------
//Funcion principal  Encender un LED de manera proporcional
//------------------------------------ Apropiar el concepto de PWM
void setup() // Se ejecuta cada vez que el Arduino se
inicia Escribir una salida análoga
{ If/else con operadores lógicos
Serial.begin(9600); //Inicia comunicación serial
Conocimientos previos
pinMode(led, OUTPUT); //Configurar el LED como una salida
}  PWM
//------------------------------------  Función analogWrite()
//Funcion ciclicla
//------------------------------------  Polaridad de un LED
void loop() // Esta funcion se mantiene ejecutando  Incrementar y manipular variables
{ // cuando este energizado el Arduino
//Guardar en una variable el valor de la consola serial
leer=Serial.read();
// Si es la letra 'a' y además el LED está apagado
if ( (leer=='a') && (prendido==false) )
//Declara puertos de entradas y salidas y variables
//--------------------------------------------------
int brillo = 0; //Variable de brillo inicia en 0
int variacion = 5; //Variable de incremento configurada de
5 en 5
int led = 9; //Pin donde se encuentra el LED, salida
//------------------------------------
//Funcion principal
//------------------------------------
void setup () // Se ejecuta cada vez que el Arduino se
inicia
{
pinMode(led, OUTPUT); //Configurar el LED como una salida
}
//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop () // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
// Escritura analoga (PWM) en el LED escribo el valor de
brillo
analogWrite(led, brillo);
// Incremento la variable brillo de 5 en 5
brillo = brillo + variacion;
// Nota: PWM ----> 0 - 255
// Si el brillo es 0 o 255
if (brillo == 0 || brillo == 255)
variacion = -variacion; //La variación se vuelve negativa
delay (30); //Tiempo de incremento en el brillo
}
//Fin programa

1– Estos elementos reciben señales de PWM y sirven para: