Clasificación por vecinos más cercanos. KNN y NN en Arduino.

KNN significa K Nearest Neighbourd o en castellano «los k vecinos más cercanos». Es un algoritmo de clasificación (indica aque clase pertenece uque parte de unos datos de ejemplo ya clasificados contra los que compara con los nuevos datos.

Supongamos que tenemos un montón de ejemplo clasificados. Estos ejemplos están repartidos en un espacio de N dimensiones o, dicho de forma más cercana a los programadores, cada caso es un vector de N elementos. Cuando nos dan un punto nuevo, que no está en los ejemplos, podemos ver de que clase son los K vecinos más cercanos y concluir que el nuevo punto, posiblemente, es de la clase mayoritaria.

Este algoritmo requiere calcular la distancia a cada vecino, ordenarlos según esta distancia y elegir los k primeros.

Implementación

Podemos usar la librería Arduino_KNN.h. No ha sido pensada de propio para Arduino UNO, sin embargo funciona sin problemas con él. Su uso es muy sencillo basta con proporcionar cada uno de los ejemplos y la clase a la que corresponde.

El primer paso es incluir la librería:

#include <Arduino_KNN.h>

Luego creamos una instancia a de la clase KNNClassifier indicando cual es la dimensión de nuestros datos:

KNNClassifier myKNN(2);

Para añadir ejemplos se usa la función addExample(), pasando en el primer parámetro el vector que representa al vecino y en el segundo la clase (que debe de ser un entero).

myKNN.addExample(example1, 1);

Finalmente, cuando todos los ejemplos están añadidos se puede clasifica un elemento con la función classify(); Que toma como primer parámetro el elemento a clasificar y como segundo el número de vecinos K a comparar:

int myKNN.classify(input, k);

Veamos un ejemplo adaptado de los de la librería :

#include <Arduino_KNN.h>

KNNClassifier myKNN(2);

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

  Serial.println("Añadiendo ejemplos: ");
  Serial.println();

  // add examples to KNN
  float example1[] = { 7.0, 7.0 }; // clase 1
  float example2[] = { 5.0, 5.0 }; // clase 2
  float example3[] = { 9.0, 9.0 }; // clase 3
  float example4[] = { 6.0, 6.0 }; // clase 2

  myKNN.addExample(example1, 1); // clase 1
  myKNN.addExample(example2, 2); // clase 2
  myKNN.addExample(example3, 3); // clase 3
  myKNN.addExample(example4, 2); // clase 2

  Serial.println("Clasificar entrada:");

  float input[] = { 5.5, 5.5 };

  int classification = myKNN.classify(input, 3); // K = 3

  Serial.print("Clasificacion = ");
  Serial.println(classification);
}

void loop() {

}

Confianza

Hay una medida que puede servir de guía de lo segura que es cada estimación, la confianza. Su valor esta entre 0 y 1, siendo 1 el máximo de confianza. Se calcula tomando todos los vecinos que entran dentro de «los K vecinos más cercanos» se cuentan aquellos cuya clase es mayoritaria y se divide por K. Por ejemplo si tenemos K igual a 5 y hay 3 vecinos de la misma clase C1, la confianza de la clasificación será de 3/5 = 0,6 . Si todos los vecinos fueran de la clase C1 la confianza seria de 5/5 = 1. La clasificación en ambos casos puede ser la misma, la clase C1, pero la confianza no.

Para saber la confianza de una clasificación en la librería Arduino_KNN.h podemos llamar a la función confidence() justo después de realizar la clasificación.

float myKNN.confidence();

NN El vecino más cercano

Tiene una estrategia aún mas simple. Buscas el ejemplo más cercano y le asignas la misma clase. Se la conoce como NN Nearest Neighbourd (el vecino más cercano). Aunque no es la forma más optima de implementarlo se puede como el algoritmo KNN usado K = 1.

 int classification = myKNN.classify(input, 1);

Crear un detector de metales con un magnetómetro o brújula digital.

Vamos a usar un magnetómetro o brújula digital como detector de metales. Para ello vamos a convertir un problema en una ventaja. Cualquier metal magnético cerca del magnetómetro mete ruido en las lecturas, mucho ruido tanto que puede imposibilitar leer los resultados. Usaremos ese ruido para detectar que estamos cerca de un metal magnético o un imán.

En mi caso usaré el magnetómetro del Arduino Nano 33 BLE Sense (ya vimos como leerlo) aunque la ideas sirve cualquier otro magnetómetro, habrá que adaptar el código y los valores empleados.

Realmente es muy sencillo crear un detector de metales. Basta con detectar el ruido y es un ruido tan grande que deja ridículas las lecturas del campo magnético terrestre. Para ello mediremos la intensidad del campo magnético. Lo hacemos elevando al cuadrado el valor de cada eje de magnetómetro, sumándolas y calculando su raíz cuadrada. El del Arduino Nano Sense tiene tres ejes por lo que el calculo lo haremos con el siguiente código.

 IMU.readMagneticField(x, y, z);
 float field = sqrt((x*x) + (y*y) + (z*z))

Ese valor lo podemos comparar con distintos umbrales calculados a base de prueba y error para saber lo cerca que estamos de un metal. En este caso usaremos cuatro niveles, cada uno asociado a un color del LED RGB. Desde «no se detecta nada» a «estas encima de un metal». Lo colores de menos a más son: blanco, verde, amarillo, rojo.

Para evitar verse influido por las condiciones del entorno (por ejemplo que haya metal cerca que hace que siempre se active nuestro detector) puede ser necesario calcular un «offset inicial» cuando se activa el microcontrolador. Este offset es una lectura inicial (la situaremos en la función setup) que se usará para ajustar el valor del campo en el resto de las lecturas. Para decidir si se realiza esta lectura o no se se realiza a través de una constante CALCULATE_OFFSET

if(CALCULATE_OFFSET){
  while(!IMU.magneticFieldAvailable()){    
  }
  IMU.readMagneticField(x, y, z);
  offset = sqrt((x*x) + (y*y) + (z*z));
}

Para corregir el valor del campo respecto de este offset basta con restarlo:

float field = sqrt((x*x) + (y*y) + (z*z))-offset; 

Vamos a juntar todo esto en un ejemplo:

#include <Arduino_LSM9DS1.h>

const bool CALCULATE_OFFSET = true;
float offset = 50; //valor por defecto
float x, y, z;

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

  if (!IMU.begin()) {
    Serial.println("Error al inicializar IMU!");
    while (1);
  }
  if(CALCULATE_OFFSET){
    while(!IMU.magneticFieldAvailable()){    
    }
    IMU.readMagneticField(x, y, z);
    offset = sqrt((x*x) + (y*y) + (z*z));
  }

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

}

float oldX, oldY, oldZ;

void loop() {

  float difX, difY, difZ;

  if (IMU.magneticFieldAvailable()) {
    IMU.readMagneticField(x, y, z);
    float field = sqrt((x*x) + (y*y) + (z*z))-offset; 
    if(field > 450){
      Serial.print(field);
      Serial.println(" metal");
      //rojo
      digitalWrite(LEDR, LOW);
      digitalWrite(LEDG, HIGH);
      digitalWrite(LEDB, HIGH);
    } else if(field > 150){
      Serial.print(field);
      Serial.println(" metal");
      //amarillo
      digitalWrite(LEDR, LOW);
      digitalWrite(LEDG, LOW);
      digitalWrite(LEDB, HIGH);
    } else if(field > 20){
      Serial.print(field);
      Serial.println(" metal");
      //verde
      digitalWrite(LEDR, HIGH);
      digitalWrite(LEDG, LOW);
      digitalWrite(LEDB, HIGH);
    } else {
      Serial.println(field);
      digitalWrite(LEDR, HIGH);
      digitalWrite(LEDG, HIGH);
      digitalWrite(LEDB, HIGH);
    }    
  }
}

Un ultimo detalle, si usas una placa de Arduino como detector de metales, cuida con los pines. Si entran en contacto con el metal pueden producirse un cortocircuito.

Leer el magnetómetro o brújula digital con Arduino Nano 33 BLE Sense (sensor LSM9DS1)

El modulo LSM9DS1 del Arduino Nano 33 BLE sense incluye un magnetómetro o brújula digital de 3 ejes. X , Y y Z. Su función principal es detectar el campo magnético terrestre en cada uno de los ejes de la placa. El eje X va a lo ancho de la placa, el Z a lo largo y el Y es perpendicular.

El primer paso es incluir la librería

#include <Arduino_LSM9DS1.h>

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

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

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

  if (IMU.magneticFieldAvailable()) {

  }

Para obtener el valor se usa IMU.readMagneticField(x, y, z); Siendo x, y, z tres variables de tipo float donde devolverá los valores del campo magnético en el eje correspondiente:

IMU.readMagneticField(x, y, z);

El campo magnético de mide en microteslas

Veamos todo el código de ejemplo:

#include <Arduino_LSM9DS1.h>

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

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

float x,y,z;

void loop() {
  // comprobar si hay una lectura disponible
  if (IMU.magneticFieldAvailable()) {    
    IMU.readMagneticField(x, y, z);
    Serial.print("x: ");
    Serial.print(x);
    Serial.print(" y: ");
    Serial.print(x);
    Serial.print(" z: ");
    Serial.println(z);
  }
  delay(500);  
}

Sensor de proximidad con Arduino Nano 33 BLE Sense (sensor APDS9960)

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

Relato: La invención del árbol

Érase una vez, un mundo y tiempo diferentes. En una Tierra afectada por la contaminación y amenazada por el efecto invernadero, un empresario anunció que había creado un proceso industrial por el que se podía convertir el C02 de la atmósfera en un nuevo material con múltiples usos: construcción, elaboración de utensilios, decoración, mobiliario y mil ideas más. Las plantas de procesado de este nuevo material eran autorreplicantes y alimentadas con energía solar.

La gente aplaudió su genialidad. Los científicos, empresarios y economistas de todo el mundo le concedieron reconocimientos y premios. Los gobiernos propusieron invertir millones en esa nueva industria, nadie protestó, era algo para el bien de todos, iba a hacer del mundo un lugar mejor.

Cuando se comenzó a instalar las plantas de producción todos querían ser los primeros en tener algún objeto de ese nuevo material y presumir de ello. La primera pieza, un trozo de material en bruto, llegó a subastarse por cientos de miles de dólares.

El departamento de marketing había pensado nombres comerciales, a las fábricas las llamó “árbolⓇ” y al material que producían “maderaⓇ”.

Cada vez que la gente veía un árbolⓇ se maravillaban de lo que hacía. Los políticos pagaban enormes sumas de dinero por el privilegio de tener árboles en sus ciudades y poder presumir de ello. Eran el orgullo de sus ciudadanos que se afanaban en cuidarlos y se hacían fotos con ellos. El número de árboles que tenía una ciudad llegó a ser un indicador de su nivel económico y su calidad de vida.

Los había de todas formas y tamaños, con diferentes tipos de hojas y maderas. Con tantos modelos que era fácil encontrar alguno de tu gusto y que se adaptara a casi cualquier condición climática.

Pero, el ingenio humano nunca está satisfecho, en secreto los laboratorios preparaban una versión 2.0. Una idea loca para una nueva versión, además de producir madera también daba alimentos. El departamento de marketing ya tenía pensado un nombre «frutaⓇ». La gente iba a alucinar con eso.

Controlar el LED RGB de Arduino Nano 33 BLE Sense

Arduino Nano 33 BLE Sense incorpora un led RGB que permite mostrar distintos colores. Cada canal RGB (rojo, verde y azul) se controla de forma independiente. Su encendido y apagado va asociado al estado de un pin digital:

  • Rojo – Pin 22
  • Verde – Pin 23
  • Azul – Pin 24

Combinando los tres distintos colores se pueden conseguir 8 combinaciones: rojo, verde, azul, amarillo, rosa, celeste, blanco y apagado.

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

Leer gestos con Arduino Nano 33 BLE Sense (sensor APDS9960)

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».

Leer colores con Arduino Nano 33 BLE Sense (sensor APDS9960)

Arduino Nano 33 BLE Sense incorpora el sensor APDS9960 que permite leer el color de lo que «tiene delante». Para ellos devuelve el color en formato RGB, esto es que devuelve tres valores con los componentes rojo (red), verde (green) y azul (blue) del color. Aunque el valor de estos tres componentes se devuelva en una variable integer de 16 bits realmente solo se usan 12 bits (0…4095). En realidad el mayor valor que he logrado leer del sensor es 4097 que para eso necesita usar 13 bits pero se puede considerar el 4095 como máximo para simplificar.

Para tener más información del sensor se puede consultar su datasheet aquí.

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 tres variables de tipo int donde se almacenaran los valores leídos int r, g, b;
  • Para leer el color se usa APDS.readColor(r, g, b); a la que es necesario pasar los tres integer declarados antes.

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

#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;
  
  // lee el color
  APDS.readColor(r, g, b);

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

  delay(2000);
}

Un detalle importante a tener en cuenta es que el formato RGB que devuelve el sensor tiene 12 bits por componente (color de 36 bits). El color RGB más habitual tiene 8 bits por componente (color de 24 bits) por lo que es probable que la mayoría de los algoritmos y librerías que se encuentren usen ese formato y sea necesario adaptar los valores.

Comparar temperaturas de los sensores en Arduino Nano 33 BLE Sense

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.

Leer temperatura y presión atmosférica con Arduino Nano 33 BLE Sense (sensor LPS22HB)

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.

SensorRango de medidaError
Temperatura-40 ºC hasta 85 ºC± 1.5 °C entre los 0 ºC y 65 °C
Presión260 hPa hasta 1260 hPa± 0,1hPa entre el 800 hPa y 1100 hPa

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