En las placas Arduino que controlan el puerto USB desde el propio microcontrolador como Leonardo o Micro hay que esperar a que el puerto serie se inicialice para evitar que se pierdan datos. Esto habitualmente se hace en la función Setup tras Serial.begin() con:

while(!Serial){ }

El problema de hacer esto es que se queda esperando a que el puerto USB este conectado y si no se conecta el programa no avanza. ¿Y si queremos tener un programa que funcione correctamente aunque no este conectado a un puerto USB?. Hay dos maneras de solucionar esto. La más simple reemplazar un delay() que espere el tiempo suficiente para que se haya iniciado (entre 500 y 1000 milisegundos suele ser una buena elección). La otra opción es, dentro del bucle, poner un tiempo limite y cuando pase «romper» el bucle con la instrucción break:

const long breakTime = 1000;//un segundo
unsigned long startTime = millis();

void setup(){
  Serial.begin(9600);
  while(!Serial){ 
	if (millis() - startTime >= breakTime) {
	  break; //sale del bucle
	}
  }
}

En las placas como Arduino UNO que el soporte USB es externo al microcontrolador Serial siempre es valido y nunca entra en el bucle.

Este texto mejorado y ampliado forma parte de mi libro sobre como mejorar tus programas en Arduino. Puedes echarle un vistazo aquí.

Para simular un ratón con una placa Arduino Leonardo contamos con la librería Mouse.h. Al igual que vimos con el teclado hay que usar las funciones Mouse.begin() y Mouse.end() para indicar que se empieza y se termina la simulación de ratón.

Se distingue entre la acción de pulsar un botón del ratón y la de presionar y luego soltar. Para simular la pulsación de un botón se puede usar la función Mouse.click(button). Mientras que para presionar se usa Mouse.press(button) y para liberar Mouse.release(button) (no existe un releaseAll para el ratón). La variable button hace referencia a una de las siguientes constantes definidas en la libreria Mouse.h :

• MOUSE_LEFT
• MOUSE_RIGHT
• MOUSE_MIDDLE

Para simular el movimiento del ratón podemos usar la función Mouse.move(xVal, yVal, wheel) siendo los dos primeros parámetros la cantidad de movimiento (no, la posición) en el eje X y en el Y de la pantalla. El tercero indica el desplazamiento de la rueda central del ratón. Estos desplazamientos pueden ser positivos o negativos en un rango de -128 y 127 (izquierda-derecha, arriba-abajo). Su valor es un poco confuso ya que se refiere a «lo que se ha movido el ratón en ese eje» y afecta al cursor desde su posición actual. No es fácil trasladar ese valor a pixeles ya que también depende, entre otras cosas, de como el ordenador al que este conectado interprete esos valores. Una de las pegas de esta forma de trabajar es que el movimiento del ratón es relativo a las coordenadas actuales del cursor en la pantalla por lo que es difícil situar el ratón en un punto exacto de la misma. El truco para hacerlo con cierta precisión es llevar el ratón a una esquina de la pantalla y desde ahí tratar de moverlo al punto deseado. Vemoa sun ejemplo muy básico de esta idea:

import "Mouse.h"

void setup() {
  Mouse.begin();
}

void loop() {

  //Mover a la esquina superior izquierda
  for(int i = 0; i < 20; i++){
	Mouse.move(-128, -128, 0);
  }

  //Mover a un punto determinado
  for(int i = 0; i < 10; i++){
	Mouse.move(50, 20, 0);
  }
  
  Mouse.click(MOUSE_LEFT);

  delay(5000);
}

Este texto mejorado y ampliado forma parte de mi libro sobre como mejorar tus programas en Arduino. Puedes echarle un vistazo aquí.

Las placas Arduino basados en los microcontroladores 32u4 o SAMD (Leonardo, Esplora, Zero, Due y MKR) pueden simular ser un teclado conectado al puerto USB. Para ello es necesario usar la librería Keyboard.h. Lo primero para simular un teclado es llamar a la función Keyboard.begin() y para finalizar la simulación Keyboard.end().

Antes de comenzar con el resto de las funciones hay que hacer una aclaración. No es lo mismo pulsar que presionar, presionar es solo el gesto de bajar la tecla sin liberarla mientras que pulsar consiste en presionar y liberar la tecla.

Para simular la pulsación de una tecla podemos usar Keyboard.write(char) a la que se pasa como parámetro el código ASCII del carácter. El código del carácter se puede pasar de varias formas:

//Simular la pulsación de la tecla A
Keyboard.write('A');        //Character
Keyboard.write(65);         //Decimal          
Keyboard.write(0x41);       //Hexadecimal       
Keyboard.write(0b01000001); //Binario

Al permitir enviarle el código de la tecla en diversos formatos podremos usarlo para simular teclas que no impriman un carácter como pueden ser la teclas con flechas de dirección. Para ello la librería incluye un listado de constantes que representan el valor de estas teclas.

Keyboard.write(KEY_UP_ARROW);    //Flecha arriba
Keyboard.write(KEY_DOWN_ARROW);  //Flecha abajo          
Keyboard.write(KEY_RIGHT_ARROW); //Flecha derecha      
Keyboard.write(KEY_LEFT_ARROW;   //Flecha Izquierda

Si queremos simular la pulsación de varios caracteres alfanuméricos podemos usar la funciones Keyboard.print(string) y Keyboard.println(string) que reciben como parámetro un String y simulan la pulsación de todos sus caracteres, println ademas añade un salto de linea al final.

Para simular una tecla presionada se puede usar Keyboard.press(char) se pueden pulsar varias teclas a la vez. Incluso combinar funciones, por ejemplo el siguiente código seria como teclear «hola» con la tecla «Mayús» pulsada.

Keyboard.press(KEY_RIGHT_SHIFT);
Keyboard.print("hola"); //HOLA
Keyboard.release(KEY_RIGHT_SHIFT);

Para liberar una tecla tenemos dos funciones: Keyboard.release(char) que libera la tecla que le pases como parámetro y Keyboard.releaseAll() que libera todas las teclas que estén presionadas.

Veamos el ejemplo completo:

#include <Keyboard.h>

void setup() {
  Keyboard.begin();
}

void loop(){
  Keyboard.press(KEY_RIGHT_SHIFT);
  Keyboard.print("hola"); //HOLA
  Keyboard.release(KEY_RIGHT_SHIFT);
}

Listado de constantes definidas en Keyboard.h

• KEY_LEFT_CTRL
• KEY_LEFT_SHIFT
• KEY_LEFT_ALT
• KEY_LEFT_GUI
• KEY_RIGHT_CTRL
• KEY_RIGHT_SHIFT
• KEY_RIGHT_ALT
• KEY_RIGHT_GUI
• KEY_UP_ARROW
• KEY_DOWN_ARROW
• KEY_LEFT_ARROW
• KEY_RIGHT_ARROW
• KEY_BACKSPACE
• KEY_TAB
• KEY_RETURN
• KEY_ESC
• KEY_INSERT
• KEY_DELETE
• KEY_PAGE_UP
• KEY_PAGE_DOWN
• KEY_HOME
• KEY_END
• KEY_CAPS_LOCK
• KEY_F1
• KEY_F2
• KEY_F3
• KEY_F4
• KEY_F5
• KEY_F6
• KEY_F7
• KEY_F8
• KEY_F9
• KEY_F10
• KEY_F11
• KEY_F12
• KEY_F13
• KEY_F14
• KEY_F15
• KEY_F16
• KEY_F17
• KEY_F18
• KEY_F19
• KEY_F20
• KEY_F21
• KEY_F22
• KEY_F23
• KEY_F24

Este texto mejorado y ampliado forma parte de mi libro sobre como mejorar tus programas en Arduino. Puedes echarle un vistazo aquí.

Se puede usar el watchdog de la placa para que en lugar de reiniciar el programa ejecute una función que nosotros le definamos. Para cambiar el modo hay que modificar el registro WDTCSR que almacena la configuración del watchdog. Este registro ocupa un byte donde cada bit tiene el siguiente significado:

Veamos como configurar WDTCSR correctamente. El funcionamiento es algo extraño, primero hay que habilitar al escritura de los registros poniendo los bits WDCE y WDE a 1:

WDTCSR = (1 << WDCE) | (1 << WDE);

Luego inmediatamente hay que poner WDIE a 1, WDE a 0 y los bits WDP3, WDP2, WDP1, WDP0 con el valor de tiempo que deseemos mirando la tabla. Por ejemplo supongamos que queremos poner 2 segundos de tiempo de espera, miramos la tabla (0111) y colocamos a 1 los bits que correspondan:

WDTCSR = (1<<WDIE) | (1<<WDP2) | (1<<WDP1) | (1<<WDP0)

Si fuera 8 segundos (1001):

WDTCSR = (1<<WDIE) | (1<<WDP3) | (1<<WDP0);

Cada constante contiene el número de bit al que representa por ejemplo WDP3 es 5 al hacer 1<<WDP3 estamos poniendo a 1 el bit 5 y hacemos la operación | (or) para unir todos esos bits en un solo byte. Todo esto hay que hacerlo deshabilitando todas las interrupciones.

noInterrupts();
WDTCSR = (1 << WDCE) | (1 << WDE);
WDTCSR = (1<<WDIE) | (1<<WDP2) | (1<<WDP1) | (1<<WDP0);
interrupts();

La función que se lanzará se define usando la macro ISR:

ISR (WDT_vect){ 
//aqui va el codigo de tu ISR para el watchdog
}

Veamos un ejemplo:

#include <avr/wdt.h>
 
int count = 0;

void setup() {
  noInterrupts();
  WDTCSR = (1 << WDCE) | (1 << WDE);
  WDTCSR = (1<<WDIE) | (1<<WDP2) | (1<<WDP1) | (1<<WDP0);
  interrupts();
  Serial.begin(9600);
}
 
void loop() {
  Serial.println(count);
  delay(400);
}
 
ISR(WDT_vect) { // WDT interrupt vector
  count++;  
}

Este texto mejorado y ampliado forma parte de mi libro sobre como mejorar tus programas en Arduino. Puedes echarle un vistazo aquí.

Puedes ver la explicación en vídeo:

Puede ser que sea lleguemos a un punto en que por seguridad sea necesario parar la ejecución del programa o que simplemente deseemos «apagar» la placa. Para ello se puede llamar a las funciones abort() o exit(0). Que es prácticamente lo mismo ya que abort lo único que hace es llamar a exit(1). Esto tiene sentido en aplicaciones de ordenador donde exit(0) indica la finalización del programa correctamente mientras que cualquier parámetro distinto de 0 indica que ocurrió un error. En Arduino ese valor que se pasa es ignorado, aunque tenemos que añadirlo si no queremos errores de compilación.

Puesta en forma de código la función exit seria similar a esta:

void exit(int ignored){
  cli(); //desactiva las interrupciones
  while(1); //bucle infinito
}

Básicamente suspende la interrupciones y luego entra en un bucle infinito. Si por algún motivo queremos hacer nuestra propia función de stop es fácil imitarla:

void stop(){
  noInterrupts();
  while(1);
}

En caso de que se use el watchdog es necesario deshabilitarlo o reiniciará la placa.

void stop(){
  wdt_disable(); //solo si esta activado el watchdog
  noInterrupts();
  while(1);
}

Las funciones anteriores son recomendables para casos en que la parada se produce por un error grave y donde menos acciones se realicen mejor. Sin embargo si queremos «apagar» la placa podemos dormirla profundamente, no llegara al consumo cero pero si al mínimo.

#include <avr/sleep.h>

void stop(){
  set_sleep_mode( SLEEP_MODE_PWR_DOWN );
  sleep_enable();
  noInterrupts(); //nunca será despertada
  sleep_cpu();
}

Por supuesto en todos estos casos basta con dejar la placa sin alimentación para poder volver a usarla.

Este texto mejorado y ampliado forma parte de mi libro sobre como mejorar tus programas en Arduino. Puedes echarle un vistazo aquí.

Puedes ver la versión en vídeo en mi canal:

Muchas placas de Arduino tienen un pin digital conectado a un led de la propia placa de tal forma que se puede controlar ese pin desde el código. En la placa el led suele ir etiquetado con una «L». En Arduino UNO es el pin digital 13. Es una forma cómoda de tener un led de señalización sin tener que montar nada. No es necesario saber que pin es, para ello se puede usar la constante LED_BUILTIN que hace referencia a ese pin.

Para poder usarlo lo primero es estar seguro que no se usa ese pin para otra cosa. Es necesario configurarlo como OUTPUT. Basta con poner el pin a HIGH para encenderlo y a LOW para apagarlo.

Aunque es algo muy rudimentario se puede usar para indicar estados del software o errores. Y puede ser útil cuando no podemos tener el ordenador con el monitor serie conectado todo el tiempo al Arduino.

Su uso puede ser tan simple como encenderlo o llegar a cosas más complicadas como usar parpadeos para indicar distintos errores.

En este ejemplo la función blink hace parpadear el led las veces que se le pasa como parámetro

void setup(){
   pinMode(LED_BUILTIN, OUTPUT);
}

void loop(){
  blink(1);
  delay(2000);
  blink(2);
  delay(2000);
  blink(3);
  delay(2000);
}

void blink(byte n){
  for(; n > 0; n--){
    digitalWrite(LED_BUILTIN, HIGH);//Encender led
    delay(500);
    digitalWrite(LED_BUILTIN, LOW);//Apagar led
    delay(500);
  } 
}

Este texto mejorado y ampliado forma parte de mi libro sobre como mejorar tus programas en Arduino. Puedes echarle un vistazo aquí.

También puedes ver la versión de en vídeo:

Cuando quieres comparar distintos datos en distintos rangos es habitual el tener que normalizarlos entre 0 y 1, es decir, convertir una variable de un rango de valores [in_min, in_max] a otro que va de 0 a 1. Para ello podemos usar la función map.

map(x, in_min, in_max, 0.0, 1.0);

En esta otra entrada de blog hay más información sobre la función map y como optimizarla, vamos a usar esos trucos para crear funciones de normalización más optimas.

Lo primero es que como los valores sobre los que se «mapea» son siempre los mismos 0 y 1 podemos crear nuestra propia función a partir del código de la función map.

long map(long x, long in_min, long in_max, long out_min, long out_max) {
    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

Se reemplaza out_min por 0 y out_max por 1 y se simplifican los cálculos:

long map(long x, long in_min, long in_max, long out_min, long out_max) {
    return (x - in_min) * (1 - 0) / (in_max - in_min) + 0;
}

Obteniendo:

long normalize(long x, long in_min, long in_max) {
    return (x - in_min) / (in_max - in_min);
}

Vamos a crear también funciones para los float y los double:

float floatNormalize(float x, float in_min, float in_max) {
    return (x - in_min) / (in_max - in_min);
}

double doubleNormalize(double x, double in_min, double in_max) {
    return (x - in_min) / (in_max - in_min);
}

Genial, pero aun podemos hacer otra mejora, la función anterior es genérica, si vamos a aplicar la normalización siempre a valores en el mismo rango podemos crear una nueva función donde remplacemos in_min e in_max por los valores de este rango. Por ejemplo en un rango de 0 a 1023:

//in: 0..1023
//in_min = 0
//in_max = 1023

long customNormalize(long x){
    return (x - 0) / (1023 - 0);
}

Simplificando:

long customNormalize(long x){
    return x / 1023;
}

Hemos reducido el coste de la normalización a una solo división, en el peor de los casos (cuando el in_min no sea 0) será una resta y una división.