Además de leer colores, gestos y luz ambiental, el sensor APDS9960es capaz de leer la proximidad de un objecto al mismo.

El primer paso es incluir la librería

#include <Arduino_APDS9960.h>

Inicializar el sensor a través de la instrucción APDS.bgin() que devolverá true si todo va bien o false si hay algún error durante la inicialización.

  if (!APDS.begin()) {
    Serial.println("Error al inicializar el sensor");
  }

Para saber si hay alguna lectura disponible se pude usar la función APDS.proximityAvailable()

  if (APDS.proximityAvailable()) {

  }

Para obtener el valor se usa APDS.readProximity()

int proximity = APDS.readProximity();

La lectura devuelve un int cuyo valor puede ser positivo entre 0 y 255 (aunque en mis pruebas no he logrado que pase de 252) que indica la distancia (a menor valor más cerca) o -1 que indica una lectura errónea del sensor. La lectura no viene en ninguna unidad de medida y habrá que convertirla realizando pruebas en una situación ambiental similar a la que se vaya a usar. De todas formas este valor hay que tomarlo más como una referencia que como un valor exacto. Por ejemplo los valores que pasan e 250 pueden interpretarse como («no hay nada cerca»), el valor 0 no indica «sobre el sensor» se alcanza con el objeto a unos 3 o 4 centímetros del mismo.

Veamos todo el código junto:

#include <Arduino_APDS9960.h>

void setup() {
  Serial.begin(9600);
  while (!Serial);

  if (!APDS.begin()) {
    Serial.println("Error al inicializar el sensor");
  }
}

void loop() {
  // comprobar si hay una lectura disponible
  if (APDS.proximityAvailable()) {
    int proximity = APDS.readProximity();
    Serial.println(proximity);
  }
  delay(500);  
}

Arduino Nano 33 BLE Sense incluye un sensor de gestos. Su funcionamiento es muy sencillo, tiene cuatro detectores infrarrojos con un led emisor. Cada uno está colocado en una de la esquinas del sensor. Cuando pasas la mano por encima de cada uno de los detectores se reflejan los infrarrojos en la piel y detectan el gesto. Viendo en qué orden los sensores detectan la mano sabe en qué dirección ocurre el gesto.

Este sistema tiene varios problemas:

• Distancia de funcionamiento, el gesto tiene que realizarse cerca del sensor.
• En según qué entornos puede dar lecturas falsas.
• Puede tener problemas para detectar gestos con las manos sucias o con guantes.

Hablamos de manos pero realmente lee cualquier elemento que refleje suficiente luz infrarroja.

El sensor lee cuatro tipos gestos: arriba, abajo, izquierda, derecha.

Cada gesto tiene asociada una constante: GESTURE_UP, GESTURE_DOWN, GESTURE_LEFT, GESTURE_RIGHT.

También existe una constate para indicar que no se ha entendido el gesto: GESTURE_NONE.

Tal y como está colocado el sensor para leer correctamente los gestos el conector USB debe de quedar en la parte «inferior».

Lo primero es incluir la librería del sensor, que creara un objeto APDS:

#include <Arduino_APDS9960.h>

Después hay que ver iniciar el sensor con APDS.begin()

  if (!APDS.begin()) {
    Serial.println("Error al iniciar el sensor");
  }

Una vez el sensor está listo podemos comprobar si ha leído algún gesto con la instrucción APDS.gestureAvailable() que devolverá true cuando hay captado algún gesto. El gesto correspondiente lo podemos obtener con APDS.readGesture().

Veamos un código, adaptado de los ejemplos, para leer gestos:

#include <Arduino_APDS9960.h>

void setup() {
  Serial.begin(9600);
  while (!Serial);

  if (!APDS.begin()) {
    Serial.println("Error al iniciar el sensor");
  }
}

void loop() {
  //comprobar si se ha detectado algún gesto
  if (APDS.gestureAvailable()) {
    int gesture = APDS.readGesture();
    switch (gesture) {
      case GESTURE_UP:
        Serial.println("UP - arriba");
        break;

      case GESTURE_DOWN:
        Serial.println("DOWN - abajo");
        break;

      case GESTURE_LEFT:
        Serial.println("LEFT - izquierda");
        break;

      case GESTURE_RIGHT:
        Serial.println("RIGHT - derecha");
        break;

      default:        
        break;
    }
  }
}

Podemos ajustar la sensibilidad del sensor a los gestos con la instrucción APDS.setGestureSensitivity(sensitivity) siendo sensitivity un valor entre 0 y 100. Por defecto su valor es de 80. A más alto sea su valor más sensibilidad tendrá a los gestos, lo que significa que captará los mejor los gestos pero a cambio será más probable que lea gestos «erroneos».

Arduni Nano 33 BLE Sense incluye un sensor (HTS221) para medir la temperatura y la humedad. Su uso es muy sencillo.

Los sensores tienen las siguientes características:

 Para ver más información del sensor se puede recurrir a su datasheet.

Para leer los datos lo primero es incluir la librería necesaria para leer los datos del sensor. 

#include <Arduino_HTS221.h>

La librería está disponible desde el gestor de librerías del IDE de Arduino, tan solo hay que buscarla por el nombre «Arduino_HTS221» e instalarla.

Una vez instalada su uso es muy sencillo:

• Se usa HTS.begin() para inicializar la lectura de datos. Devuelve true si todo ha ido bien y false si ha ocurrido algún error.
• Para leer la temperatura se usa HTS.readTemperature() que devuelve un float con la temperatura en grados Celsius.
• Para leer la humedad se usa HTS.readHumidity() que devuelve un float con la humedad en porcentaje.
• Si se desea finalizar el uso del sensor y liberar recursos se llama a HTS.end()

¡Ya esta!. No hay más que hacer.

Veamos uno de los ejemplos que viene con la librería:

#include <Arduino_HTS221.h>

void setup() {
  Serial.begin(9600);
  while (!Serial);

  if (!HTS.begin()) {
    Serial.println("Failed to initialize sensor!");
    while (1);
  }
}

void loop() {
  // read all the sensor values
  float temperature = HTS.readTemperature();
  float humidity    = HTS.readHumidity();

  // print each of the sensor values
  Serial.print("Temperature = ");
  Serial.print(temperature);
  Serial.println(" °C");

  Serial.print("Humidity    = ");
  Serial.print(humidity);
  Serial.println(" %");

  // print an empty line
  Serial.println();

  // wait 1 second to print again
  delay(1000);
}

Por último, si en lugar de necesitar la temperatura en grados Celsius la necesitas en grados Farenheit, se puede hacer con la siguiente instruccion:

HTS.readTemperature(FAHRENHEIT );

En dispositivos con poca memoria RAM, como es el caso de Arduino, cuando se asigna memoria de forma dinámica puede surgir el problema de la fragmentación. Se produce cuando la memoria libre esta fragmentada en trozos tan pequeños que no se puede reservar suficiente memoria contigua libre aunque la suma total de memoria libre es mayor que la que se trata de reservar.

Veamos un ejemplo de como se produce esta fragmentación, para ello empezaremos reservando un bloque de 1000 bytes de memoria (memory1) para limitar la memoria disponible. Luego reservamos un bloque de memoria de 300 bytes (memory2) otro de un byte (memory3) y otro de 300 (memory4) de nuevo. La función de ese bloque de un único byte es evitar que al liberar los otros dos bloques estos puedan unirse en un mismo bloque. Liberamos los dos bloques de 300 bytes por lo que ahora debería haber libre un mínimo de 600 bytes libres, sin embargo si tratamos de reservar 500 bytes (memory5) y no puedo (el puntero tiene valor 0). Hay memoria libre suficiente pero esta divida en bloques más pequeños del que necesito. Con solo un byte estratégicamente colocado hemos causado un problema de fragmentación. Los bloques más pequeños (memory6) pueden reservar memoria sin problemas.

byte* memory1;
byte* memory2;
byte* memory3;
byte* memory4;
byte* memory5;
byte* memory6;

void setup() {  
  Serial.begin(9600);
  while (!Serial) {
    ; // esperamos a que el puerto este inicializado 
  }

  memory1 = (byte*) calloc (1000, sizeof(byte)); //reservamos 1000
  memory2 = (byte*) calloc (300, sizeof(byte)); //reservamos 300
  memory3 = (byte*) calloc (1, sizeof(byte)); //reservamos 1
  memory4 = (byte*) calloc (300, sizeof(byte)); //reservamos 300
  free(memory2); // liberamos 300
  free(memory4); //liberamos 300 
  memory5 = (byte*) calloc (500, sizeof(byte)); //reservamos 500
  memory6 = (byte*) calloc (300, sizeof(byte)); //reservarmos 300

  Serial.println((long)memory1);
  Serial.println((long)memory2);
  Serial.println((long)memory3);
  Serial.println((long)memory4);
  Serial.println((long)memory5);
  Serial.println((long)memory6);
}
 
void loop() {

}

Veamos un ejemplo de salida:

466
1468
1770
1774
0
1468

Se puede ver que memory5 no puede reservar memoria mientras que a memory6 se le asigna el primer bloque libre que coincide con el memory2 que acaba de ser liberado.

Este ejemplo esta pensado para una placa Arduino UNO en caso de usarlo en otra placa habrá que ajustar el tamaño del primer bloque.

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

Puedes ver el ejemplo en el siguiente vídeo:

SerialEvent es una función que se llama automáticamente cuando hay datos esperando a ser leídos en el puerto serie. Se invoca tras cada iteración de la función loop, por lo que cualquier delay o bloqueo en la función loop retrasa su invocación. Es una forma sencilla de integrar la gestión de los datos por puerto serie nuestro código.

void setup() {
  Serial.begin(9600);
}

void loop() {

}

void serialEvent() {
  //mientras tenga datos que leer
  while (Serial.available()) {
	//leer datos
  }	
}

Para las placas que tienen más de un puerto serie existe una función serialEvent distinta para cada uno:

• Serial – serialEvent
• Serial1- serialEvent1
• Serial2 – serialEvent2
• Serial3 – serialEvent3

Esta función no esta disponible para todos los puerto serie de todas las placas, por ejemplo no esta disponible para las placas basadas en microcontroladores SAMD, para Arduino Due o las placas Leonardo, Micro, o Yún que no funciona serialEvent (serialEvent1 si que funciona).

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

Hay veces que tenemos un valor expresado en una escala y queremos pasarla a otra. Por ejemplo uno de los casos más habituales es el calcular un porcentaje. Que pasamos un número expresado en una escala a otra que va de 0 a 100. En Arduino para pasar un valor de un rango o escala [in_min, in_max] a otro [out_min, out_max] podemos usar la función map.

long map(long x, long in_min, long in_max, long out_min, long out_max)

La función map toma 5 parámetros:

• x: Valor a transformar
• in_min: Valor más bajo de la escala origen
• in_max: Valor más alto de la escala origen
• out_min: Valor más bajo de la escala destino
• out_max: Valor más alto de la escala destino.

La función tiene la siguiente implementación interna:

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; 
}

Os habréis dado cuenta de que trabajo con long ¿Qué pasa si queremos otro tipo de datos?. Muy fácil, nos hacemos nosotros mismos la función:

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


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

Optimizar la función map

Ya que nos hemos puesto a crear nuestras funciones veamos como podemos optimizar los cálculos, si siempre tenemos que usar la función map con los mismos rango de números podemos crear nuestra versión personalizarla para que se ejecute más rápido. Es tan sencillo como sustituir los valores min y max de cada rango y simplificar. Veamoslo con un ejemplo, vamos a crearnos nuestro propio map que transforme de la escala de 0 a 1023 a otra escala de 0 a 255.

in: 0..1023
out: 0..255
int_min = 0
int_max = 1023
out_min = 0
out_max = 255

Reemplazamos:

long customMap(long x) { 
    return ((x - 0) * (255 - 0) / (1023 - 0)) + 0; 
}

Simplificamos donde podamos:

long customMap(long x) { 
    return (x * 255) / 1023; 
}

Ahora tenemos nuestra función personalizada que realiza solo dos operaciones. Como no es necesario pesarle los rangos usa solo un parámetro.