ARDUINO.
Ejemplos prácticos básicos Arduino
Ejemplo 1
Blink LED (Parpadeo de un LED)
Este es el primer ejemplo típico que se suele desarrollar con la placa Arduino. En
él crearemos un primer programa en el que haremos parpadear el LED que lleva
integrado la placa conectado al pin 13. Este esta disponible en la mayoría de
Arduinos y sirve como punto de partida para la programación de Arduino. El
código del sketch es posible encontrarlo en el propio IDE de Arduino:
/*
Blink
Enciende y apaga un LED por un segundo repetidamente.
La mayoría de los Arduinos poseen un LED en su placa, en concreto en el
Arduino UNO se encuentra en el pin 13.
También es posible utilizar la constante LED_BUILTIN que identifica el pin en
el que se encuentra el led en
cualquier placa
Si está usando otra placa, por favor, consulte la documentación en
[Link]
*/
/*La función SETUP se ejecuta una única vez tras encenderse la placa. En ella
normalmente se realizan tareas de inicialización
de variables y preparativos para el resto de ejecución del programa*/
void setup() {
// Esta función establece el pin 13 en modo salida.
pinMode(13, OUTPUT);
}
// La función LOOP se ejecutará continuamente después de haberse ejecutado la
función SETUP
void loop() {
digitalWrite(13, HIGH); // Enciende el LED (HIGH is es el nivel de
voltaje)
delay(1000); // espera 1 segundo
digitalWrite(13, LOW); // Apaga el LED poniendo el nivel de voltaje a
LOW
delay(1000); // espera 1 segundo
}
Una vez comprendido el código del sketch deberemos compilarlo (1) y subirlo
(2) a la placa Arduino mediante el cable USB.
Comprobamos que la placa se encuentra conectada a un puerto COM y que la
placa seleccionada es la que tenemos conectada.
Posteriormente se debe hacer click en el botón de verificar (1) para compilar el
código y posteriormente en el botón de subir (2) que compilará y subirá el
programa a la placa.
Ejemplo 2
Lectura de un sensor
En este ejemplo veremos cómo leer un dato de un sensor y mostrarlo por
pantalla en la consola serie del IDE de Arduino. Una de los usos básicos de
Arduino es que actúe como sensor y retransmita la información recibida del
entorno a un tercero, en este caso, la consola serie del IDE.
Concretamente, en este ejemplo veremos cómo realizar lecturas de un sensor
LDR (del inglés, Light-Dependent Resistor) es un sensor de luz de tipo resistivo
(fotorresistencia). Es un tipo de resistencia especial que cambia su valor según la
cantidad de luz que incide sobre ella. Ver sección 7.
Para que sea más sencillo y evitar el uso de resistencias utilizaremos un módulo
de Arduino LDR como el siguiente que se puede encontrar aquí.
Posee dos salidas: una digital D0 y una analógica A0. Este módulo posee
además un regulador que puede ser ajustado para marcar una cantidad
especifica de intensidad de luz. Esta cantidad de luz determinará la salida del
pin D0: HIGH si la intesidad sobrepasa el valor fijado por el regulador y LOW en
caso contrario. La salida analógica corresponderá a
Componentes y software necesarios:
1. Requisitos previamente mencionados
2. Módulo LDR Arduino
3. Cables
4. Protoboard (Si no se dispone de cables jumper hembra-macho) Ver aquí.
En primer lugar debemos conectar el módulo al Arduino como se indica en la
imagen:
Ahora utilizaremos el siguiente sketch para leer tanto la entrada del módulo
digital como la analógica. Además imprimiremos los valores por el puerto serie
para que sea posible verlos por la consola de IDE.
Veamos el código:
/*
Aquí se definen algunas constantes para ser utilizadas a lo largo del código.
En este caso los pines analógico y digital utilizados para las entradas del
programa
*/
#define ANALOG_SENSOR_PIN A0
#define DIGITAL_SENSOR_PIN 7
int digitalValue; /* Variable para el ultimo valor leído de la entrada
digital */
int lightAnalogValue; /* Variable para el último valor analógico leído */
void setup()
{
// Inicializamos el puerto serie del arduino (en este caso el USB al PC) a
9600 baudios. La consola deberá configurarse a esta velocidad también
[Link](9600);
[Link]("Lectura de Sensores Ejemplo 2"); //Imprimimos un mensaje de
bienvenida del programa
//Ponemos el pin digital en modo entrada
pinMode(DIGITAL_SENSOR_PIN, INPUT);
void loop(){
digitalValue = digitalRead(DIGITAL_SENSOR_PIN);
//Escribimos el valor de la señal
[Link]("Valor digital:"+String(digitalValue)); //El valor digital lo
pasamos a cadena para poder concatenarlo
lightAnalogValue = analogRead(ANALOG_SENSOR_PIN); //Leemos el voltaje del
sensor
[Link]("Valor analógico de (0 a 1023)");
[Link](lightAnalogValue,DEC); // Escribimos en el puerto serie
delay(500); //Esperamos
Una vez analizado el código detenidamente y comprendiendo que hace cada
parte procederemos a compilarlo y subirlo al Arduino. Una vez subido,
deberemos abrir la consola serie para ver los valores que esta tomando tanto el
pin analógico como el digital.
Si todo ha ido como se esperaba y está conectado correctamente, será posible
ver valores del 0 al 1023 en la entrada analógica y 1 y 0 en la digital
dependiendo si la intensidad de luz es mayor a la del valor fijado por el
regulador, también se encenderá un LED que tiene incorporado el módulo LDR.
Con esto ya somos capaces de leer un dato de un sensor ya sea digital 0/1 o
analógico. En este último caso dependiendo del sensor que se utilice se deberá
hacer la correspondiente conversión al valor que especifique la documentación
del módulo.
Ejemplo 3
Control de un actuador
En el ejemplo anterior hemos visto brevemente una parte fundamental que es
cómo utilizar el Arduino como para leer datos de un sensor, pero es igual de
importante poder actuar ante los valores recibidos por los sensores. En este
ejemplo utilizaremos el código anterior para activar y desactivar un relé.
Un relé es un interruptor que podemos activar mediante una señal eléctrica. En
su versión más simple es un pequeño electro-imán que cuando lo excitamos
mueve la posición de un contacto eléctrico de conectado a desconectado o
viceversa.
En este caso utilizaremos un módulo relé para Arduino como el siguiente:
La conexión con el relé se realizará conectando VCC y GND a sus
correspondientes pines de la protoboard o Arduino y la patilla de Signal a un
pin digital:
A continuación añadiremos al código del ejemplo anterior una parte que
accionará o no el relé en función de la intensidad de luz recibida por el el sensor
LDR.
/*
Aquí se definen algunas constantes para ser utilizadas a lo largo del código.
En este caso los pines analógico y digital utilizados para las entradas del
programa
*/
#define ANALOG_SENSOR_PIN A0
#define DIGITAL_SENSOR_PIN 7
#define DIGITAL_RELAY_PIN 2 //Añadimos este pin
int digitalValue; /* Variable para el ultimo valor leído de la entrada
digital */
int lightAnalogValue; /* Variable para el último valor analógico leído */
void setup()
{
// Inicializamos el puerto serie del arduino (en este caso el USB al PC) a
9600 baudios. La consola deberá configurarse a esta velocidad también
[Link](9600);
[Link]("Lectura de Sensores Ejemplo 2"); //Imprimimos un mensaje
de bienvenida del programa
pinMode(DIGITAL_SENSOR_PIN, INPUT);
pinMode(DIGITAL_RELAY_PIN, OUTPUT); //Configuramos en modo salida el pin
del relé
}
void loop(){
digitalValue = digitalRead(DIGITAL_SENSOR_PIN);
//Escribimos el valor de la señal
[Link]("Valor digital:"+ String(digitalValue));
lightAnalogValue = analogRead(ANALOG_SENSOR_PIN); //Leemos el voltaje del
sensor
[Link]("Valor analógico de (0 to 1023)");
[Link](lightAnalogValue,DEC); // Escribimos en el puerto serie
//Añadimos este código para encender o apagar el relé en función de la
luminosidad
if(digitalValue == LOW){
[Link]("Relay OFF");
digitalWrite(DIGITAL_RELAY_PIN,LOW);
}else{
[Link]("Relay ON");
digitalWrite(DIGITAL_RELAY_PIN,HIGH);
}
delay(100); //Esperamos
Si se ha cargado correctamente este código y el cableado esta realizado de
manera correcta debería accionarse el relé en el caso de que cambie el pin
digital del sensor LDR.
MUY IMPORTANTE: SE DEBE TENER MUCHO CUIDADO AL MANIPULAR
RELÉS PUESTO QUE TRABAJAN CON TENSIONES MUY ELEVADAS QUE
PUEDEN CAUSAR GRAVES LESIONES O LA MUERTE
Ejemplo 4
Comunicación con el exterior I (Serie)
En los ejemplos anteriores hemos visto como leer valores de un sensor y actuar
sobre un relé en función de las medidas. Ahora veremos como comunicar el
Arduino con otros dispositivos para poder tanto llevar esa información a otros
dispositivos como actuar ante mensajes recibidos de otros dispositivos. En este
caso veremos leer un mensaje enviado por la consola Serie de Arduino y
encender un LED si es el valor correcto. Del mismo modo haremos esto con una
conexión Bluetooth y enviaremos mensajes mediante una aplicación Android
creada con la aplicación APP Inventor.
Envío de datos a través de la consola por el puerto serie
Como hemos visto anteriormente, es posible establecer una comunicación con
el Arduino mediante el puerto Serie del USB que se conecta al PC. Esta conexión
nos permitirá enviar y recibir información y así poder comunicar el Arduino con
otros dispositivos (en este caso un PC).
Utilizaremos el siguiente sketch para enviar una cadena desde la consola al
Arduino y desde esté se enviará una respuesta en función de la cadena
mandada. En este caso mandaremos la cadena "hola" y el Arduino contestará
por serie ¡Saludos!.
Veamos detenidamente el código del sketch:
/*
* En este ejemplo leeremos comandos enviados desde la consola
* del IDE de Arduino y responderemos en función del mensaje recibido.
*
*
*/
#define SIZE_BUFFER 200 //Tamaño del buffer
String inputString = ""; // cadena que utilizaremos de buffer para
los mensajes recibidos
boolean stringComplete = false; // variable que utilizaremos para saber si
la cadena está completa. Comunmente se le suele llamar bandera o flag en
inglés
void setup() {
// Inicializamos el puerto serie del Arduino a 9600 baudios y esperamos a
que esté conectado
[Link](9600);
while (!Serial) {
; // bucle esperando por la conexion USB
}
// Reservamos 200 bytes de memoria para la cadena que utilizaremos de
buffer
[Link](SIZE_BUFFER);
// Mensaje de bienvenida
[Link]("##### Ejemplo 4 Transmitiendo datos ####");
void loop() {
// Leemos del puerto serie hasta que se llene el buffer o haya un salto de
linea
// Seteamos la bandera a false
stringComplete = false;
// Mientras haya datos disponibles leemos caracter a caracter del puerto
serie
while ([Link]() && !stringComplete) {
// Leemos un nuevo caracter:
char inChar = (char)[Link]();
// lo concatenamos a inputString:
inputString += inChar;
// comprobamos si es un salto de linea o se ha llenado el buffer, si es
así seteamos la bandera a true
if (inChar == '\n' || [Link]() == SIZE_BUFFER) {
stringComplete = true;
}
}
/*
* Si se trata de una cadena válida actuamos en consecuencia y vaciamos el
buffer
*/
if(stringComplete){
//Eliminamos el salto de linea si lo hubiese
[Link]("\n", "");
if([Link]("Hola")){
[Link]("¡Saludos!");
}else{
[Link]("No entiendo tu mensaje: "+inputString);
}
// Limpiamos el buffer
inputString = "";
}
delay(500);
}
Este sketch es un poco más complejo que los anteriores por lo que lo
detallaremos un poco más:
1. Se definen las variables que actuarán de bandera y de buffer (para almacenar la
información recibida del puerto serie)
2. En la función setup se configura el puerto Serie y se espera por su conexión.
3. En el loop se lee del puerto serie mientras haya datos disponibles para leer y el
ultimo dato recibido no sea un salto de linea o se haya llenado el buffer.
4. Tratamos el mensaje recibido quitando el salto de línea si lo hubiese y
comprobamos el contenido del mensaje. Dependiendo de este se envía por
puerto serie la respuesta.
Este sería el resultado:
Este ejemplo nos ilustra como podemos recibir y enviar información al exterior,
en este caso, utilizando el puerto serie.
Ejemplo 5
Comunicación con el exterior II (Bluetooth)
En este caso vamos a realizar la misma operación que en el anterior pero la
información intercambiada será utilizando Bluetooth BLE (Bluetooth Low Energy)
por lo que necesitaremos un smartphone Android o IOS y un módulo Bluetooth
BLE que conectar a nuestro Arduino. En este caso utilizaremos el Bluetooth HM-
10 que es posible encontrarlo aquí.
A continuación las conexiones pertinentes del módulo HM-10 al Arduino. Hay
que tener en cuenta que las patillas series TX y RX deben ir cruzadas.
Como podemos ver en la Wiki de HM-10 se trata de un módulo Bluetooth BLE
que posee abstrae y empaqueta una conexión Bluetooth Low Energy en una
conexión serie. En la configuración "de fábrica" del firmware el módulo se
comporta como un periférico BLE que expone un servicio BLE de conectividad
(UUID: 0000ffe0-0000-1000-8000-00805f9b34fb) que permite la comuniciación
entre el módulo y cualquier otro dispositivo central que se conecte a él. Para
ello utiliza una característica (UUID: 0000ffe1-0000-1000-8000-00805f9b34fb)
que almacena una lista de bytes (sin formato) con la siguiente lógica de
funcionamiento:
Cuando el dispositivo central quiere enviar algún dato al módulo, hace un
WRITE en la característica con el contenido del dato.
Cuando el módulo quiere enviar un dato al dispositivo central conectado, envía
una NOTIFICATION al dispositivo central.
El módulo HM-10 implementa una conexión serie en los pines 1 (TXD en la
placa breakout) y 2 (RXD) que está conectada a nivel lógico con la conexión BLE.
Todo lo que le entra por el pin RXD lo envía vía notificaciones al dispositivo
central y todo lo que escribe el dispositivo central se saca vía el pin TXD. De esta
forma aunque los dos dispositivos (módulo HM-10 y dispositivo central) se
están comunicando a través de BLE, de cara al micro que controla el módulo
se trata de una simple conexión serie. En el caso de Arduino, está conexión
se gestiona como cualquier otra conexión serie utilizando las librerías
Serial o SoftwareSerial según los pines de Arduino a los que se conecten
los pines TXD y RXD del módulo.
Esto último que podemos encontrar en la wiki del módulo es muy importante
porque hará que tratemos al módulo bluetooth como si de un puerto serie se
tratase.
Veamos ahora que modificaciones debemos realizar en nuestro
anterior sketch para poner a funcionar el módulo:
/*
* En este ejemplo leeremos comandos enviados desde una aplicación Android o
IOS mediante bluetooth
* y responderemos en función del mensaje recibido.
*
*
*/
#include <SoftwareSerial.h> //Incluimos los archivos de cabecera de la
biblioteca SoftwareSerial para configurar un puerto serie
#define SIZE_BUFFER 200 //Tamaño del buffer
String inputString = ""; // cadena que utilizaremos de buffer para
los mensajes recibidos
boolean stringComplete = false; // variable que utilizaremos para saber si
la cadena está completa. Comunmente se le suele llamar bandera o flag en
inglés
SoftwareSerial bluetooth(2, 4); // RX, TX
// Conexión HM10 Arduino Uno
// Pin 1/TXD <----> Pin 2 RX
// Pin 2/RXD <----> Pin 4 TX
void setup() {
// Inicializamos el puerto serie del Arduino a 9600 baudios y esperamos a
que esté conectado
// En este caso lo utilizaremos como debugger, es decir, todo las
comunicaciones serán retrasmitidas también por este puerto para que sean
visible en la consola.
// Esto permitirá detectar si todo está funcionando correctamente.
[Link](9600);
while (!Serial) {
; // bucle esperando por la conexion USB
}
// Configuramos el baud rate a 9600. El HM-10 debería venir por defecto con
9600. De no ser así deberá modificarse este valor o bien el del módulo
mediante comandos AT (ver la wiki)
[Link](9600);
// Reservamos 200 bytes de memoria para la cadena que utilizaremos de
buffer
[Link](SIZE_BUFFER);
// Mensaje de bienvenida
[Link]("##### Ejemplo 5 Transmitiendo datos por Bluetooth ####");
void loop() {
// Leemos del puerto serie hasta que se llene el buffer o haya un salto de
linea
// Seteamos la bandera a false
stringComplete = false;
// Mientras haya datos disponibles leemos caracter a caracter del puerto
serie
// Hemos sustituido el objeto Serial por el creado con anterioridad
bluetooth
while ([Link]() && !stringComplete) {
// Leemos un nuevo caracter:
char inChar = (char)[Link]();
// lo concatenamos a inputString:
inputString += inChar;
// comprobamos si es un salto de linea o se ha llenado el buffer, si es
asi seteamos la bandera a true
if (inChar == '\n' || [Link]() == SIZE_BUFFER) {
stringComplete = true;
}
}
/*
* Si se trata de una cadena válida actuamos en consecuencia y vaciamos el
buffer
*/
if(stringComplete){
//Eliminamos el salto de linea si lo hubiese
[Link]("\n", "");
if([Link]("Hola")){
[Link]("Recibido por bluetooth:" + inputString);
[Link]("Saludos");
//Enviamos sin salto de linea esta vez. Un detalle inportante a tener
en cuenta es que los mensajes en BLE tiene un tamaño 20. Se se envían
mensajes más grandes estos se fraccionarán
[Link]("Saludos");
}else{
[Link]("No entiendo tu mensaje: "+inputString);
[Link]("No entiendo");
}
// Limpiamos el buffer
inputString = "";
}
delay(500);
Una vez cargado el programa en el Arduino y si está todo conectado
correctamente debería verse el mensaje de bienvenida del programa en la
consola.
Para poder enviar y recibir datos por Bluetooth BLE utilizaremos la
aplicación nRF Connect for mobile Android o nRF Connect for mobile iOS
Las siguientes capturas hacen referencia a la aplicación de Android pero el
proceso en iOS es similar. En primer lugar escaneamos dispositivos y debería
aparecer una lista en la que uno de ellos suele tener un nombre HM-10 o un
nombre similar al chip que lleva, en este caso. A continuación se puede ver una
captura de la aplicación con el listado de dispositivos escaneados. Será
necesario que nuestro dispositivo posea Bluetooth 4 BLE.
Si entramos en el dispositivo (en este caso CC41-A) veremos los servicios del
dispositivo y dentro del servicio ffe0 encontraremos la característica ffe1 en la
que podremos suscribirnos por notificaciones de cambio de la característica
(recibir datos), hacer una lectura del valor que tiene actualmente la característica
o escribir un valor en la característica (esto mandará por serie lo que escribamos
al Arduino).
Si utilizamos el comando escribir (flecha hacia arriba), podremos enviar un
mensaje al Arduino. En este caso se nos mostrará la siguiente ventana,
seleccionaremos TEXT y enviaremos la palabra Hola.
Veremos que se ha impreso en la consola pero el Arduino no nos ha
contestado, esto es debido a que utilizamos como carácter de fin de trama un
salto de linea por lo que para terminar el mensaje podríamos enviar
(seleccionado en lugar de TEXT UINT8) el número 10 que es la correspondencia
en ASCII del salto de línea. Otra opción que queda propuesta al lector es
modificar el código y utilizar un carácter de fin de trama distinto como por
ejemplo una @ o un *.
Resultado de la consola:
Resultado en el móvil:
Con esta práctica hemos visto como es posible comunicar un Arduino median
Bluetooth BLE. Este tipo de comunicación es muy útil si se está a cortas
distancias y se quiere ahorrar batería en la comunicación.
