Arduino UNO Paso a Paso

Con esta Placa y un pequeño programa

llamados Sketch,( de un software
Arduino llamado IDE), que lo escribimos
en nuestra computadora y
posteriormente lo grabamos
(compilamos) en la memoria de la Placa
arduino, mediante un cable USB
conectado a nuestra PC. Este programa
le indicará los pasos que deberá ejecutar
el microprocesador para gestionará la
información obtenida de una variedad de
sensores en las entradas (la luz en un
sensor, el pulsado de un botón, o un mensaje de twitter) y lo convertirá en una respuesta a la
salida (encendido de un motor, encender un led, control de actuadores motorizados, enviar mails).
Con la simple conexión de sensores a las entradas, podremos realizar infinidad de desarrollo
automatizados, domótica, robótica, adquisición de datos, sistemas de control, diseños artísticos,
etc.

Cualquiera con un mínimo conocimiento de electrónica (ley de ohm, uso de multímetro, etc),
puede iniciarse a trabajar con arduino.

El software de Arduino (IDE), se ejecuta bajo cualquiera de los siguientes sistemas operativos
Windows, Mac OSX y GNU/Linux.

Descripción Placa:
Microprocesador: ATmega328p.

Voltaje recomendado de entrada: 7-12V

Límites de voltaje entrada=6-20V

Los pines pueden funcionar como entradas o salidas y se les indica mediante el programa que
función tendrá cada pin.

 Digital IO (LEDs, switches)

 Analog IO (resistive sensor data)
 Serial IO (Sensors, GPS, etc) Programable desde la computadora
Arudino UNO, el microcontrolador es desmontable y reemplazable en caso
de que sufra algún daño por corto circuito o por sobre voltaje.
Programación Arduino

Sketchs (programitas):
Sketches IDE propia: https://www.arduino.cc/en/Main/Software

Pantalla de inicio
Funciones principales:

setup()

Configuraci´on inicial: selección de pines, sensores, formatos, velocidades, etc.

loop()

Rutina principal, que se ejecuta constantemente

setup() es la parte encargada de recoger la configuración y loop() es la que contiene el programa que se
ejecuta cíclicamente (de ahí el término loop –bucle-). Ambas funciones son necesarias para que el
programa trabaje.

La función de configuración (setup) debe contener la inicialización de los elementos y esta función sólo
se ejecuta una vez justo después de hacer el reset y no se vuelve a ejecutar hasta que no haya otro reset.
Es la primera función a ejecutar en el programa y se utiliza para configurar, inicializar variables,
comenzar a usar librerías, etc…

La función bucle (loop) contiene el código que se ejecutará continuamente (lectura de entradas,
activación de salidas, etc). Esta función es el núcleo de todos los programas de Arduino y se usa para el
control activo de la placa. La función loop se ejecuta justo después de setup.

Los componentes principales de un sketch de Arduino son:

 Variables, son un espacio en memoria donde se almacenan datos y estos datos pueden variar.
 Funciones, son un trozo de código que puede ser usado/llamado desde cualquier parte del
sketch. A la función se le puede llamar directamente o pasarle unos parámetros, en función de
cómo esté definida.
 setup() y loop(), son dos funciones especiales que es obligatorio declarar en cualquier sketch.
 Comentarios, fundamentales para documentar el proyecto

Se puede resumir un sketch de Arduino en los siguientes diagramas de flujo:

Diagrama de flujo del sketch blink:
Por ejemplo para un robot que esquiva obstáculos, el diagrama sería:
Y en un caso más complejo, este puede ser el diagrama de flujo de un sistema de control de acceso
mediante lectura de tarjetas RFID:
Nuestro primer Sketch (programita):
prender y apagar un led por un segundo
Modo del Pin :

pinMode(pin, mode)

// mode: OUTPUT, INPUT or INPUT PULLUP

Interrupciones :

attachInterrupt(digitalPinToInterrupt(pin), ISR, mode)

// mode: LOW, CHANGE, RISING, FALLING

Primer programa/sketch de Arduino
Este es el esquema a usar, pero el led marcado como L está también conectado al pin 13 (en el caso del
Arduino UNO) y no es necesario poner un led adicional.:
Pasos a seguir:

 Abrir la aplicación Arduino

 Abrir el ejemplo blink
  Seleccionar la placa y el puerto adecuado

 Cargar el programa pulsando el botón “subir”. El programa se compilará y luego se verá

parpadeando los leds Tx y Rx de Arduino, indicando que se está cargando el fichero binario
(.hex) en la flash del Arduino. Cuando aparezca el mensaje “subido” habremos acabado.
 Unos segundos después veremos el LED parpadeando.

Una explicación completa del proyecto y enlaces a las funciones usadas está
en: http://arduino.cc/en/Tutorial/Blink

Constantes definidas en el IDE Arduino: https://www.arduino.cc/en/Reference/Constants

Demos un paso más y modifiquemos el sketch para que parpadee más rápido y más lento. Modificar el
valor de delay y volver a compilar y subir a Arduino.
Vamos a ampliarlo y modificar el programa para que cada vez que encienda y apague saque por el
puerto serie la cadena “encendido”, “apagado” cuando corresponda. Luego guardarlo en nuestro entorno
de trabajo.

Será necesario usar la librería Serial: http://arduino.cc/en/Reference/Serial

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/blob/master/Ejercicio01-Blink/Ejercicio01-
Blink.ino

El IDE trae muchos ejemplos que podemos ver y

probar: https://www.arduino.cc/en/Tutorial/BuiltInExamples

------------------------------------------------------------------------------------------

Cuando compilamos y cargamos el programa en Arduino esto es lo que ocurre:

Variables

Una variable puede ser declarada al inicio del programa antes de la parte de configuración setup(), a
nivel local dentro de las funciones, y, a veces, dentro de un bloque, como para los bucles del tipo if..
for.., etc. En función del lugar de declaración de la variable así se determinará el ámbito de aplicación, o
la capacidad de ciertas partes de un programa para hacer uso de ella.

Una variable global es aquella que puede ser vista y utilizada por cualquier función y estamento de un
programa. Esta variable se declara al comienzo del programa, antes de setup().

Recordad que al declarar una variable global, está un espacio en memoria permanente en la zona de
static data y el abuso de variables globales supone un uso ineficiente de la memoria.

Una variable local es aquella que se define dentro de una función o como parte de un bucle. Sólo es
visible y sólo puede utilizarse dentro de la función en la que se declaró. Por lo tanto, es posible tener dos
o más variables del mismo nombre en diferentes partes del mismo programa que pueden contener
valores diferentes, pero no es una práctica aconsejable porque complica la lectura de código.

En el reference de Arduino hay una muy buena explicación del ámbito de las
variables: http://arduino.cc/en/Reference/Scope

El modificador de variable static, es utilizado para crear variables que solo son visibles dentro de una
función, sin embargo, al contrario que las variables locales que se crean y destruyen cada vez que se
llama a la función, las variables estáticas mantienen sus valores entre las llamadas a las funciones.

Los tipos de variables en Arduino son:

Además de usar este tipo de datos que son los que aparecen en el reference de Arduino
(https://www.arduino.cc/en/Reference/HomePage), es posible usar cualquier tipo de variable de C++
estándar con las limitaciones propias de cada micorcontrolador.

Tipos de variables estándar en C++:

 https://en.wikipedia.org/wiki/C_data_types
 http://www.cplusplus.com/doc/tutorial/variables/
 https://msdn.microsoft.com/en-us/library/cc953fe1.aspx

Más información sobre los tipos de variable Arduino

en: https://aprendiendoarduino.wordpress.com/2016/06/29/tipos-de-datos-2/
Arrays

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 asignados valores a cada posición antes de ser utilizado.

Para manejar arrays en C++ dispones de las funciones

estándar: http://www.cplusplus.com/reference/array/array/

string (char array)

Un string es un array de chars. Cuando se trabaja con grandes cantidades de texto, es conveniente usar
un array de strings. Puesto que los strings son en si mismo arrays de chars.

Reference de Arduino para string: https://www.arduino.cc/en/Reference/String

Para manejara strings (char array) disponemos de las funciones de string.h que define diversas funciones
para manipular strings y arrays http://www.cplusplus.com/reference/cstring/

También es posible usar la clase string de C++: http://www.cplusplus.com/reference/string/string/

Más información para aclarar la diferencia entre string y la clase

string: https://www.tutorialspoint.com/cplusplus/cpp_strings.htm

String (Objeto)

Se trata de una clase que permite usar y manipular cadenas de texto de una forma más sencilla que los
strings. Puedes concatenar, añadir, buscar, etc… usando los métodos/funciones que ofrece esta clase.

Toda la información de la clase String en el reference de

Arduino https://www.arduino.cc/en/Reference/StringObject
Los Strings tienen un uso intensivo de memoria, pero son muy útiles y se van a utilizar mucho en el
apartado de comunicación, por ese motivo es importante aprender a manejar los Strings.

Tener en cuenta que al no ser un tipo de dato propiamente dicho sino una clase, tienes unas funciones
asociadas (métodos), operadores y unas propiedades. Es una abstracción del dato y para aprender a
usarlo hay que leerse la documentación correspondiente.

Operadores

El core de Arduino ofrece una serie de operadores según su reference:

 Aritméticos:
 Asignación: http://arduino.cc/en/Reference/Assignment
 +, -, *, /: http://arduino.cc/en/Reference/Arithmetic
 Módulo: http://arduino.cc/en/Reference/Modulo
 Compuestos:
 ++, –: http://arduino.cc/en/Reference/Increment
 += , -= , *= , /= : http://arduino.cc/en/Reference/IncrementCompound
 Comparación:
 ==, !=, <, >, <=, >=: http://arduino.cc/en/Reference/If
 Booleanos: http://arduino.cc/en/Reference/Boolean

Pero además es posible usar los operadores estnándar de C /C++ y más

información: http://es.wikipedia.org/wiki/Anexo:Operadores_de_C_y_C%2B%2B

Estructuras de control

Las estructuras de control en Arduino según el reference son:

 Estructuras de decisión
 if: http://arduino.cc/en/Reference/If
 else: http://arduino.cc/en/Reference/Else
 switch case: http://arduino.cc/en/Reference/SwitchCase
 Estructuras de repetición
 for: http://arduino.cc/en/Reference/For
 while: http://arduino.cc/en/Reference/While
 do .. while: http://arduino.cc/en/Reference/DoWhile

Funciones definidas por usuario

Una función es un bloque de código que tiene un nombre y un conjunto de instrucciones que son
ejecutadas cuando se llama a la función. Son funciones setup() y loop() de las que ya se ha hablado.

Las funciones de usuario pueden ser escritas para realizar tareas repetitivas y para reducir el tamaño de
un programa. Segmentar el código en funciones permite crear piezas de código que hacen una
determinada tarea y volver al área del código desde la que han sido llamadas.
Más información sobre las funciones en C++: http://www.cplusplus.com/doc/tutorial/functions/

Ejemplo paso a paso para los que empiezan con Arduino

Vamos a simular un sistema de alarma de forma que leo por una entrada y cuando
detecto 0 voltios, ejecuto una acción sobre una salida indicando que tengo una alarma,
por ejemplo una sirena, un SMS o enciendo una luz de emergencia.

La entrada será el pin digital 7 y la salida el led integrado en arduino accesible desde el pin
digital 13.

Pasos a realizar
Errores
Paso/Commit Tarea Detectados Código

1
Leer el pin digital 7 y si es 0 enciendo el led Se ve parpadear o Código
 Errores
Paso/Commit Tarea Detectados Código

integrado en el pin 13, sino lo apago reducir la Paso 1

luminosidad del led
cuando el pin está
al aire no conectado
a GND o 5V

Ahora si no hay
nada conectado está
apagado y poner el
pin 7 a masa se Código
2 Poner el pin 7 en modo INPUT_PULLUP enciende el led Paso 2

Manda alarma
Simulando la lectura de un relé, sacar por continuamente no al
puerto serie ALARMAcuando ponga GND detectar un cambio Código
3 el pin 7 en el estado Paso 3

Añadir una variable con el estado de alarma

y compararlo el estado anterior para
madar ALARMA o RECUPERACION Código
4 ALARMA Se observan rebotes Paso 4

Código
5 Añadir un delay de 100ms al final del loop ¡¡FUNCIONA!! Paso 5

Conclusión
Cuando quiero detectar cambios de estado debo guardar en una variable el estado y
comparar con el estado actual y cuando hay un cambio ejecuto la acción correspondiente.

No es necesario hacer digitalWrite en cada loop, es mejor hacerlo cuando se detecte el

cambio de estado que lo dispara

Código
Sensores: