Programación en Arduino.

Ing. Iván Iglesias Navarro.

Tipos de Datos.

• Byte: almacena un valor numérico de 8 bits sin decimales. Tienen un rango entre 0 y 255.
byte Variable = 180; // declara 'Variable' como tipo byte

Int: Enteros son un tipo de datos primarios que almacenan valores numéricos de 16 bits sin decimales
comprendidos en el rango 32,767 to -32,768.

int unaVariable = 1500; // declara 'unaVariable' como una variable de tipo entero

Nota: Las variables de tipo entero “int” pueden sobrepasar su valor máximo o mínimo como consecuencia de una
operación. Por ejemplo, si x = 32767 y una posterior declaración agrega 1 a x, x = x + 1 entonces el valor se x pasará
a ser -32.768. (algo así como que el valor da la vuelta).
Tipos de Datos.
Long: El formato de variable numérica de tipo extendido “long” se refiere a números enteros (tipo 32 bits) sin
decimales que se encuentran dentro del rango -2147483648 a 2147483647.

long Variable = 90000; // declara 'Variable' como tipo long

Float: El formato de dato del tipo “punto flotante” “float” se aplica a los números con decimales. Los números de
punto flotante tienen una mayor resolución que los de 32 bits con un rango comprendido 3.4028235E +38 a +38-
3.4028235E.

float Variable = 3.14; // declara 'Variable' como tipo flotante

Nota: Los números de punto flotante no son exactos, y pueden producir resultados extraños en las comparaciones.
Los cálculos matemáticos de punto flotante son también mucho más lentos que los del tipo de números enteros, por
lo que debe evitarse su uso si es posible.
 Tipos de Datos.
Array: Un array es un conjunto de valores a los que se accede con un número índice. Cualquier valor puede ser
recogido haciendo uso del nombre de la matriz y el número del índice. El primer valor de la matriz es el que está
indicado con el índice 0, es decir el primer valor del conjunto es el de la posición 0. Un array tiene que ser
declarado y opcionalmente se le deben asignar valores a cada posición antes de ser utilizado

int miArray[] = {valor0, valor1, valor2...}

Igualmente, es posible declarar una matriz indicando el tipo de datos y el tamaño y posteriormente, asignar
valores a una posición especifica:

int miArray[5]; // declara un array de enteros de 6 posiciones

miArray[3] = 10; // asigna el valor 10 a la posición 4

Para leer de un array basta con escribir el nombre y la posición a leer:

x = miArray[3]; // x ahora es igual a 10 que está en la posición 3 del array

Ejemplo:
Las matrices se utilizan a menudo para estructuras de tipo bucle, en los que la variable de incremento del contador del
bucle se utiliza como índice o puntero del array.
El siguiente ejemplo usa una matriz para el parpadeo de un LED.

int pinSalida = 9; // Salida LED en el PIN 10

byte parpadeo[] = {180, 30, 255, 200, 10, 90, 150, 60, 5, 150 }; // array de 8 valores diferentes
void setup()
{
pinMode(pinSalida, OUTPUT); //configura la salida PIN 9
}

void loop() // bucle del programa

{
for(int i=0; i<10; i++) // crea un bucle tipo for utilizando la variable i de 0 a 9 (10 iteraciones)
{
analogWrite(ledPin, parpadeo[i]); //escribe en la salida PIN 9 el valor al que apunta i dentro del array
parpadeo[]

delay(300); // espera 300ms

}
}
 Operaciones aritméticas
y = y + 3; //suma
x = x - 7; //resta
j = j * 6; //multiplicación
r = r / 5; //división.

Nota: Las operaciones se efectúan teniendo en cuanta el tipo de datos que hemos definido para los operandos (int,
dbl, float, etc..), por lo que, por ejemplo, si definimos 9 y 4 como enteros “int”, 9 / 4 devuelve de resultado 2 en
lugar de 2,25 ya que el 9 y 4 se valores de tipo entero “int” (enteros) y no se reconocen los decimales con este tipo
de datos.
 Aclaraciones importantes:
Las operaciones aritméticas pueden sufrir un desbordamiento si el resultado es más grande que lo que puede ser
almacenada en el tipo de datos. Recordemos el alcance de los tipos de datos numéricos que ya hemos explicado
anteriormente.
Tipo de datos Tamaño
int 32,767 a -32,768
float 3.4028235E+38 a -3.4028235E+38
Byte 0 y 255
long -2147483648 a 2147483647

Si los operandos son de diferentes tipos, para el cálculo se utilizará el tipo más grande de los operandos en juego.
Por ejemplo, si uno de los números (operandos) es del tipo float y otra de tipo integer, para el cálculo se utilizará el
método de float es decir el método de coma flotante.

Elija el tamaño de las variables de tal manera que sea lo suficientemente grande como para que los resultados sean
lo precisos que usted desea. Para las operaciones que requieran decimales utilice variables tipo float, pero sea
consciente de que las operaciones con este tipo de variables son más lentas a la hora de realizarse el computo.

Nota: Utilice el operador (int) numFloat para convertir un tipo de variable a otro sobre la marcha.
Por ejemplo, i = (int) 3,6 establecerá i igual a 3.
Asignaciones compuestas:
Las asignaciones compuestas combinan una operación aritmética con una variable asignada. Estas asignaciones
compuestas pueden ser:

x ++ // igual que x = x + 1, o incrementar x en + 1

x -- // igual que x = x - 1, o decrementar x en -1
x += y // igual que x = x + y, o incrementar x en +y
x -= y // igual que x = x - y, o decrementar x en -y
x *= y // igual que x = x * y, o multiplicar x por y
x /= y // igual que x = x / y, o dividir x por y

Nota: Por ejemplo, x * = 5 hace que x se convierta en el Quíntuple del antiguo valor x y por lo tanto x es reasignada
al nuevo valor .
 Operadores de comparación:
Las comparaciones de una variable o constante con otra se utilizan con frecuencia en las estructuras
condicionales del tipo if.. para testear si una condición es verdadera. En los ejemplos que siguen en las próximas
páginas se verá su utilización práctica usando los siguientes tipo de condicionales:
x == y // x es igual a y
x != y // x no es igual a y
x < y // x es menor que y
x > y // x es mayor que y
x <= y // x es menor o igual que y
x >= y // x es mayor o igual que y
 Operadores Lógicos.
Los operadores lógicos son usualmente una forma de comparar dos expresiones y devolver un VERDADERO o
FALSO dependiendo del operador. Existen tres operadores lógicos, AND (&&), OR (||) y NOT (!), que a menudo
se utilizan en estamentos de tipo if..:

Logical AND:
if (x > 10 && x < 20) // cierto sólo si las dos expresiones son ciertas

Logical OR:
if (x > 0 || y > 1) // cierto si una cualquiera de las expresiones es cierta

Logical NOT:
if (!x > 0) // cierto solo si la expresión es falsa
 Constantes:
El lenguaje de programación de Arduino tiene unos valores predeterminados, que son llamados constantes. Se utilizan
para hacer los programas más fáciles de leer.
Las constantes se clasifican en grupos:

true/false

Estas son constantes booleanas que definen los niveles HIGH (alto) y LOW (bajo) cuando estos se refieren al estado de
las salidas digitales. FALSE se asocia con 0 (cero), mientras que TRUE se asocia con 1, pero TRUE también puede ser
cualquier otra cosa excepto cero. Por lo tanto, en sentido booleano, -1, 2 y -200 son todos también se define como
TRUE. (esto es importante tenerlo en cuenta).

if (b = = TRUE);
{
ejecutar las instrucciones;
}
HIGH/LOW
Estas constantes definen los niveles de salida altos o bajos y se utilizan para la lectura o la escritura digital para las
patillas. ALTO se define como en la lógica de nivel 1, ON, ó 5 voltios, mientras que BAJO es lógica nivel 0, OFF, o 0
voltios.

digitalWrite(13, HIGH); // activa la salida 13 con un nivel alto (5v.)

OUTPUT/INPUT

Estas constantes son utilizadas para definir, al comienzo del programa, el modo de funcionamiento de los pines
mediante la instrucción pinMode de tal manera que el pin puede ser una entrada INPUT o una salida OUTPUT.

pinMode(13, OUTPUT); // designamos que el PIN 13 es una salida

 Estructuras de programación:
if (si):
if es una estructura que se utiliza para probar si una determinada condición se ha alcanzado, como por ejemplo
averiguar si un valor analógico está por encima de un cierto número, y ejecutar una serie de declaraciones
(operaciones) que se escriben dentro de llaves, si es verdad. Si es falso (la condición no se cumple) el programa
salta y no ejecuta las operaciones que están dentro de las llaves, El formato para if es el siguiente:
if (Condición)
{
Instrucciones;
}

Nota: Tenga en cuenta el uso especial del símbolo '=', poner dentro de if (x = 10), podría parecer que es valido
pero sin embargo no lo es ya que esa expresión asigna el valor 10 a la variable x, por eso dentro de la estructura
if se utilizaría X==10 que en este caso lo que hace el programa es comprobar si el valor de x es 10.. Ambas cosas
son distintas por lo tanto dentro de las estructuras if, cuando se pregunte por un valor se debe poner el signo
doble de igual “==”
if… else (si….. sino ..)
if… else viene a ser una estructura que se ejecuta en respuesta a la idea “si no se cumple lo primero hagamos los
sgundo”.
Por ejemplo, si se desea probar una entrada digital, y hacer una cosa si la entrada fue alto o hacer otra cosa si la
entrada es baja, usted escribiría que de esta manera:

if (inputPin == HIGH) // si el valor de la entrada inputPin es alto

{
instruccionesA; //ejecuta si se cumple la condición
}
else
{
instruccionesB; //ejecuta si no se cumple la condición
}
Else puede ir precedido de otra condición de manera que se pueden establecer varias estructuras condicionales de tipo
unas dentro de las otras (anidamiento) de forma que sean mutuamente excluyentes pudiéndose ejecutar a la vez. Es
incluso posible tener un número ilimitado de estos condicionales. Recuerde sin embargo qué sólo un conjunto de
declaraciones se llevará a cabo dependiendo de la condición probada:

if (inputPin < 500)

{
instruccionesA; // ejecuta las operaciones A
}
else if (inputPin >= 1000)
{
instruccionesB; // ejecuta las operacione B
}
else
{
instruccionesC; // ejecuta las operaciones C
}

Nota: Una instrucción de tipo if prueba simplemente si la condición dentro del paréntesis es verdadera o falsa. Esta
declaración puede ser cualquier declaración válida. En el anterior ejemplo, si cambiamos y ponemos (inputPin ==
HIGH). En este caso, la instrucción if sólo chequearía si la entrada especificado esta en nivel alto (HIGH), o +5v.
 Bucles (ciclos):

¿Cuál es la diferencia entre un cliclo For, While y Do While en

programación estructurada C++?
 for
La declaración for se usa para repetir un bloque de sentencias encerradas entre llaves un número determinado de
veces. Cada vez que se ejecutan las instrucciones del bucle se vuelve a testear la condición. La declaración for tiene
tres partes separadas por (;)
Vemos el ejemplo de su sintaxis:

for (inicialización; condición; expresión)

{
ejecutaInstrucciones;
}

La inicialización de una variable local se produce una sola vez y la condición se testea cada vez que se termina la
ejecución de las instrucciones dentro del bucle. Si la condición sigue cumpliéndose, las instrucciones del bucle se
vuelven a ejecutar. Cuando la condición no se cumple, el bucle termina.
Ejemplo:
El siguiente ejemplo inicia el entero i en el 0, y la condición es probar que el valor es inferior a 20 y si es cierto i se
incrementa en 1 y se vuelven a ejecutar las instrucciones que hay dentro de las llaves:

for (int i=0; i<20; i++) // declara i, comprueba que es menor que 20, incrementa i en 1
{
digitalWrite (13, HIGH); // envía un 1 al pin 13
delay(250); // espera ¼ seg.
digitalWrite (13, LOW); // envía un 0 al pin 13
delay(250); // espera ¼ de seg.
}

Nota: El bucle en el lenguaje C es mucho más flexible que otros bucles encontrados en algunos otros lenguajes de
programación, incluyendo BASIC. Cualquiera de los tres elementos de cabecera puede omitirse, aunque el punto y
coma es obligatorio. También las declaraciones de inicialización, condición y expresión puede ser cualquier estamento
válido en lenguaje C sin relación con las variables declaradas. Estos tipos de estados son raros pero permiten disponer
soluciones a algunos problemas de programación raras.
 While.
Un bucle del tipo while es un bucle de ejecución continua mientras se cumpla la expresión colocada entre
paréntesis en la cabecera del bucle. La variable de prueba tendrá que cambiar para salir del bucle. La situación
podrá cambiar a expensas de una expresión dentro el código del bucle o también por el cambio de un valor en
una entrada de un sensor
while (condición)
{
instrucciones;
}

Ejemplo.

While (Variable < 200) // testea si es menor que 200

{
instrucciones; // ejecuta las instrucciones entre llaves
Variable++; // incrementa la variable en 1
}
 Do while
El bucle do while funciona de la misma manera que el bucle while, con la salvedad de que la condición se prueba al
final del bucle, por lo que el bucle siempre se ejecutará al menos una vez.

do
{
Instrucciones;
} while (condición);

El siguiente ejemplo asigna el valor leído leeSensor() a la variable 'x', espera 50 milisegundos, y luego continua
mientras que el valor de la 'x' sea inferior a 100:
do
{
x = leeSensor();
delay(50);
} while (x < 100);
pinMode(pin, mode)
Esta instrucción es utilizada en la parte de configuración setup () y sirve para configurar el modo de trabajo de un PIN
pudiendo ser INPUT (entrada) u OUTPUT (salida).

pinMode(pin, OUTPUT); // configura ‘pin’ como salida

Arduino, tiene sus terminales por defecto, configurados como entradas.

Entonces, no es necesario definirlos en el caso de que los pines vayan a trabajar como entradas.
Importante:
Configurados como entrada quedan, bajo el punto de vista eléctrico, como entradas en estado de alta impedancia.

Estos pines tienen a nivel interno una resistencia de 20 KΩ a las que se puede acceder mediante software. A estas
resistencias se accede de la siguiente manera:

OJO en este caso no se trata de convertir un

pinMode(pin, INPUT); // configura el ‘pin’ como entrada pin en salida, es simplemente un método
digitalWrite(pin, HIGH); // activa las resistencias internas para activar las resistencias interiores.
 IMPORTANTE:

Los pines configurados como OUTPUT (salida) se dice que están en un estado de baja impedancia y pueden
proporcionar 40 mA (miliamperios) de corriente a otros dispositivos y circuitos.

Esta corriente es suficiente para alimentar un diodo LED (no olvidando poner una resistencia en serie), pero no es
lo suficiente grande como para alimentar cargas de mayor consumo como relés, solenoides, o motores.

Un cortocircuito en las patillas Arduino provocará una corriente elevada que puede dañar o destruir el chip
Atmega. A menudo es una buena idea conectar en la OUTUPT (salida) una resistencia externa de 470 o de 1000 Ω.
digitalRead(pin)
Lee el valor de un pin (definido como digital) dando un resultado HIGH (alto) o LOW (bajo).

El pin se puede especificar ya sea como una variable o una constante (0-13).

valor = digitalRead(Pin); // hace que 'valor sea igual al estado leído en ´Pin´

digitalWrite(pin, value)
Envía al ´pin´ definido previamente como OUTPUT el valor HIGH o LOW (poniendo en 1 o 0 la salida). El pin se
puede especificar ya sea como una variable o como una constante (0-13).

digitalWrite(pin, HIGH); // deposita en el 'pin' un valor HIGH (alto o 1)

Ejemplo:
leer el estado de un pulsador conectado a una entrada digital y lo escribe en el ´pin´ de salida LED:

int led = 13; // asigna a LED el valor 13

int boton = 7; // asigna a botón el valor 7
int valor = 0; // define el valor y le asigna el valor 0

void setup()
{
pinMode(led, OUTPUT); // configura el led (pin13) como salida
pinMode(boton, INPUT); // configura botón (pin7) como entrada
}

void loop()
{
valor = digitalRead(boton); //lee el estado de la entrada botón
digitalWrite(led, valor); // envía a la salida ´led´el valor leído
}
 analogRead(pin) (lectura analógica)

Lee el valor de un determinado pin definido como entrada analógica con una resolución de 10 bits. Esta
instrucción sólo funciona en los pines (0-5). El rango de valor que podemos leer oscila de 0 a 1023.

valor = analogRead(pin); // asigna a valor lo que lee en la entrada ´pin’

Nota: Los pins analógicos (0-5) a diferencia de los pines digitales, no necesitan ser declarados como INPUT u
OUPUT ya que son siempre INPUT´s.
analogWrite(pin, value)
Esta instrucción sirve para escribir un pseudo-valor analógico utilizando el procedimiento de modulación por
ancho de pulso (PWM) a uno de los pin´s de Arduino marcados como “pin PWM”. El más reciente Arduino, que
implementa el chip ATmega168, permite habilitar como salidas analógicas tipo PWM los pines 3, 5, 6, 9, 10 y 11.
Los modelos de Arduino más antiguos que implementan el chip ATmega8, solo tiene habilitadas para esta
función los pines 9, 10 y 11. El valor que se puede enviar a estos pines de salida analógica puede darse en forma
de variable o constante, pero siempre con un margen de 0-255.

analogWrite(pin, valor); // escribe 'valor' en el 'pin' definido como analógico

Si enviamos el valor 0 genera una salida de 0 voltios en el pin especificado; un valor de 255 genera una salida de 5
voltios de salida en el pin especificado. Para valores de entre 0 y 255, el pin saca tensiones entre 0 y 5 voltios - el
valor HIGH de salida equivale a 5v (5 voltios)
 IMPORTANTE:
Teniendo en cuenta el concepto de señal PWM , por ejemplo, un valor de 64 equivaldrá a mantener 0 voltios de tres
cuartas partes del tiempo y 5 voltios a una cuarta parte del tiempo; un valor de 128 equivaldrá a mantener la salida
en 0 la mitad del tiempo y 5 voltios la otra mitad del tiempo, y un valor de 192 equivaldrá a mantener en la salida 0
voltios una cuarta parte del tiempo y de 5 voltios de tres cuartas partes del tiempo restante.

Debido a que esta es una función de hardware, en el pin de salida analógica (PWN) se generará una onda constante
después de ejecutada la instrucción analogWrite hasta que se llegue a ejecutar otra instrucción analogWrite (o una
llamada a digitalRead o digitalWrite en el mismo pin).

Nota: Las salidas analógicas a diferencia de las digitales, no necesitan ser declaradas como INPUT u OUTPUT.
 Ejemplo:
El siguiente ejemplo lee un valor analógico de un pin de entrada analógica, convierte el valor dividiéndolo por 4,
y envía el nuevo valor convertido a una salida del tipo PWM o salida analógica:

int led = 10; // define el pin 10 como ´led´

int analog = 0; // define el pin 0 como ´analog´
int valor; // define la variable ´valor´
void setup(){} // no es necesario configurar entradas y salidas
void loop()
{
valor = analogRead(analog); // lee el pin 0 y lo asocia a la variable valor
valor /= 4; //divide valor entre 4 y lo reasigna a valor
analogWrite(led, valor); // escribe en el pin10 valor
}
delay(ms)

Detiene la ejecución del programa la cantidad de tiempo en ms que se indica en la propia instrucción.
De tal manera que 1000 equivale a 1seg.

delay(1000); // espera 1 segundo

Ejemplos:
1. Encendido y apagado de un led.
2. encendido y apagado utilizando for
3. Ejemplo con while.

Tarea:

Configurar un programa para:

Conectar 2 pulsadores (pin 7 y pin 8) (lecturas en HIGH de los pines 7 y 8)

Cuando se pulsa el 1 (HIGH en pin 7) se enciende un led en el pin 13.

Cuando se pulsa el 2 (HIGH en pin 8)se apaga el led del pin 13 y se enciende un led en el pin 12.