Arduino Nano 33 BLE Sense incorpora un LED RGB que permite mostrar distintos colores. Un LED RGB se compone de tres LED cada uno de un color: rojo (Red), verde (Green) y azul (Blue). Cada color se controla de forma independiente cambiando el estado de un pin digital, cada pin tiene asociada una constante:

Combinando los tres distintos colores se pueden conseguir 8 combinaciones: rojo, verde, azul, amarillo, rosa, celeste y blanco y apagado. Para evitar volverse loco hay que tener en cuenta que los LED funcionan con lógica inversa, el estado LOW los enciende y el estado HIGH los apaga. En la siguiente tabla podemos ver como conseguir cada color:

El primer paso es configurar el pin de cada LED como escritura. Cada pin tiene asociada una constante: LEDR, LEDG, LEDB.

  pinMode(LEDR, OUTPUT);
  pinMode(LEDG, OUTPUT);
  pinMode(LEDB, OUTPUT);

Una vez hecho eso podemos controlar el estado de cada color con digitalWrite.

Una cosa a tener en cuenta, y que puede volverte loco, es que los leds funcionan con lógica inversa: el estado LOW los enciende y el estado HIGH los apaga.

Veamos todo esto en un ejemplo que cambia el color del LED cada dos segundos:

void setup() {
  // activar todos los pins del led RGB
  pinMode(LEDR, OUTPUT);
  pinMode(LEDG, OUTPUT);
  pinMode(LEDB, OUTPUT);
}

void loop() {
  //blanco
  digitalWrite(LEDR, LOW);
  digitalWrite(LEDG, LOW);
  digitalWrite(LEDB, LOW);
  delay(2000);
  //rojo
  digitalWrite(LEDR, LOW);
  digitalWrite(LEDG, HIGH);
  digitalWrite(LEDB, HIGH);
  delay(2000);
  //verde
  digitalWrite(LEDR, HIGH);
  digitalWrite(LEDG, LOW);
  digitalWrite(LEDB, HIGH);
  delay(2000);
  //azul
  digitalWrite(LEDR, HIGH);
  digitalWrite(LEDG, HIGH);
  digitalWrite(LEDB, LOW);
  delay(2000);
  //amarillo
  digitalWrite(LEDR, LOW);
  digitalWrite(LEDG, LOW);
  digitalWrite(LEDB, HIGH);
  delay(2000);
  //rosa
  digitalWrite(LEDR, LOW);
  digitalWrite(LEDG, HIGH);
  digitalWrite(LEDB, LOW);
  delay(2000);
  //celeste
  digitalWrite(LEDR, HIGH);
  digitalWrite(LEDG, LOW);
  digitalWrite(LEDB, LOW);
  delay(2000);  
  //apagado 
  digitalWrite(LEDR, HIGH);
  digitalWrite(LEDG, HIGH);
  digitalWrite(LEDB, HIGH);
  delay(2000);  
}

Regular el brillo del LED para conseguir más colores

Aunque lo habitual es usar los LED como si fueran una salida digital se puede usar como si fuera una salida analógica PWM. Con esto podemos conseguir regular la luminosidad de los distintos LED. En este caso la lógica es inversa, 0 es el mayor valor de luminosidad y 255 el menor. Podemos ajustar cada uno de los tres colores de forma diferente. Regulando la intensidad de cada uno de los tres canales podemos conseguir otros colores. En teoría más de 16 millones (256*256*256) aunque en realidad el LED del Arduino permite muchos menos colores distinguibles. Uno de los problemas que tiene el LED “desnudo” es que cuando hay mucha diferencia de brillo entre sus colores se puede perder el efecto de “color unificado”

En el siguiente ejemplo vamos como usar anologWrite en lugar de digitalWrite para obtener el color naranja.

//naranja
analogWrite(LEDR, 0); //maximo
analogWrite(LEDR, 128); //medio
analogWrite(LEDR, 255); //minimo

Otro ejemplo, el siguiente código recorre toda la gama de colores:

void setup() {
  pinMode(LEDR, OUTPUT);
  pinMode(LEDG, OUTPUT);
  pinMode(LEDB, OUTPUT);
}

void loop() {
  for(byte r = 0; r < 255; r+=5){
    for(byte g = 0; g < 255; g+=5){
      for(byte b = 0; b < 255; b+=5){
        analogWrite(LEDR, r);
        analogWrite(LEDG, g);
        analogWrite(LEDB, b); 
        delay(5);    
      }
    }
  }
}

Puedes ver como funciona un LED RGB en el siguiente vídeo de mi canal de Youtube:

Arduino Nano 33 BLE Sense tiene dos sensores que permiten leer la temperatura en grados centigrados: HTS221 y LPS22HB.

Leer los dos puede ser una manera de verificar los datos. Dentro del rango de temperatura normales para el ser humano deberían de dar resultados muy parecidos.

Es necesario incluir las librerías para ambos sensores e inicializarlos con begin().

Para poder leer la temperatura del sensor LPS22HB es necesario leer primero la presión.

Si queremos podemos aproximar la temperatura final con una media de ambas temperaturas.

Juntemos todo esto en un ejemplo:

#include <Arduino_LPS22HB.h>
#include <Arduino_HTS221.h>
void setup() {
  Serial.begin(9600);
  while (!Serial);
  if (!BARO.begin() || !HTS.begin()) {
    Serial.println("Failed to initialize sensor!");
    while (1);
  }
}
void loop() {
  float temperature1 = HTS.readTemperature();
  BARO.readPressure();
  float temperature2 = BARO.readTemperature();
  float mean = (temperature1+temperature2)/2;
  Serial.print("Temperature1 = ");
  Serial.print(temperature1);
  Serial.println(" C");
  Serial.print("Temperature2 = ");
  BARO.readPressure();
  Serial.print(temperature2);
  Serial.println(" C");
  Serial.print("Mean = ");
  Serial.print(mean);
  Serial.println(" C");
  Serial.println();
  delay(1000);
}

Veamos la salida de ejecutar el código:

Temperature1 = 26.47 C 
Temperature2 = 26.41 C 
Mean = 26.44 C 

Temperature1 = 26.52 C 
Temperature2 = 26.41 C 
Mean = 26.47 C 

Temperature1 = 26.52 C 
Temperature2 = 26.42 C 
Mean = 26.47 C 

Temperature1 = 26.45 C 
Temperature2 = 26.42 C 
Mean = 26.43 C 

Temperature1 = 26.50 C 
Temperature2 = 26.42 C 
Mean = 26.46 C

Se puede ver que la temperatura no varía demasiado entre ambos sensores.

Arduino Nano 33 BLE Sense incluye un barómetro que mide la presión atmosférica, el sensor LPS22HB. Este tipo de sensores son una superficie que al ser deformada por la presión atmosférica altera su resistencia, midiendo la misma se puede saber la deformación de la superficie y por lo tanto la presión a la que se ve sometida.

El mismo sensor incluye un termómetro para medir la temperatura.

El datasheet del sensor esta disponible aquí.

Lo primero para leer ese sensor es incluir la librería Arduino_LPS22HB.h, la cual se puede descargar desde el gestor de librerías del IDE de Arduino.

#include <Arduino_LPS22HB.h>

Al incluirla se puede acceder al objeto BARO, su uso es simple:

• Se usa BARO.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 puede usar BARO.readTemperature() que devuelve un float con la temperatura en grados Celsius.
• Para leer la presión se usa BARO.readPressure() que devuelve un float con la presión en kilopascales
• Si se desea finalizar el uso del sensor y liberar recursos se llama a BARO.end()

Veamos todo esto junto con uno de los ejemplos de la librería:

#include <Arduino_LPS22HB.h>

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

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

void loop() {
  // read the sensor value
  float pressure = BARO.readPressure();

  // print the sensor value
  Serial.print("Pressure = ");
  Serial.print(pressure);
  Serial.println(" kPa");

  float temperature = BARO.readTemperature();

  // print the sensor value
  Serial.print("Temperature = ");
  Serial.print(temperature);
  Serial.println(" C");

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

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

Podemos leer la presión en tres unidades distintas, para ello se le puede pasar una de las tres constantes como parámetro a la funcion readPressure() :

BARO.readPressure(PSI);
BARO.readPressure(MILLIBAR);
BARO.readPressure(KILOPASCAL);

Ya hemos visto que Arduino Nano 33 BLE Sense cuenta con un sensor que permite detectar colores, pero no solo eso, al mismo tiempo que lee los colores permite medir la cantidad de luz ambiental.

Lo primero es incluir la librería correspondiente. Se encuentra en el gestor de librerías de Arduino por lo que solo hay que buscarlo para instalarlo:

#include <Arduino_APDS9960.h>

Al incluirla se puede acceder al objeto APDS:

• Se usa APDS.begin(); para inicializar la lectura de datos. Devuelve true si todo ha ido bien y false si ha ocurrido algún error.
• Es necesario declarar cuatro variables de tipo int donde se almacenaran los valores leídos int r, g, b, a;
• Para leer el color se usa APDS.readColor(r, g, b, a); a la que es necesario pasar los cuatro integer declarados antes. El que nos interesa es el a que contiene el valor de la iluminación ambiental.

Veamos como queda el código inspirado en uno de los ejemplos:

/*
  APDS-9960 - Color Sensor

  This example reads color data from the on-board APDS-9960 sensor of the
  Nano 33 BLE Sense and prints the color RGB (red, green, blue) values
  to the Serial Monitor once a second.

  The circuit:
  - Arduino Nano 33 BLE Sense

  This example code is in the public domain.
*/

#include <Arduino_APDS9960.h>

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

  //comprueba si elsensor se ha iniciado correctamente
  if (!APDS.begin()) {
    Serial.println("Error initializing APDS-9960 sensor.");
  }
}

void loop() {
  // comprueba si hay un color disponible
  while (! APDS.colorAvailable()) {
    delay(5);
  }
  int r, g, b, a;
  
  // lee el color
  APDS.readColor(r, g, b, a);

  Serial.print("r = ");
  Serial.println(r);
  Serial.print("g = ");
  Serial.println(g);
  Serial.print("b = ");
  Serial.println(b);
  Serial.print("a = ");
  Serial.println(a);
  Serial.println();

  delay(2000);
}

Al igual que con los colores el máximo valor que he logrado que devuelva para la luz ambiental es 4097 y el mínimo es 0.