Guía: R y Arduino

Paquete arduinor

knitr::opts_chunk$set(echo = TRUE, fig.width=9, fig.height=4) 

Introducción

La información contenida en este documento acerca del paquete arduinor se obtuvo de la página de Git Hub de su creador, Hao Zhu y de su página web Hao Zhu R Developer; Data Scientist; Loves everything dynamic. (Según la misma página del creador, por el momento el paquete no funciona para el Sistema Operativo Windows. [2019])

“So, let’s get this package before we start. Again, if you only have a Windows machine, sorry about that. Let’s hope my libserialport project can go well.” Hao Zhu.

El paquete arduinor permite obetener lecturas de las placas Arduino a través del puerto serial de la computadora, además de facilitar una visualización mediante una app integrada con shiny. La librería implementa funciones del paquete Rcpp por lo tanto es una librería que también debe instalarse.

Esta guía es una guía básica en español sobre uso del paquete construido por Hao Zhun, replicando el ejemplo que él mismo propone en su página personal.

Otra opción para interactuar con Arduino desde R, es el paquete Rduino, el cual contiene funciones para controlar el comportamiento de los pines digitales y análogos de las placas Arduino.

Las pruebas que se hicieron para este documento se hicieron en una computadora con las versiones siguientes de software:

• R version 4.0.5 (2021-03-31)
• RStudio: Version 1.4.1106
• Platform: x86_64-pc-linux-gnu (64-bit)
• Running under: Linux Mint 20.1
• IDE Arduino: 1.8.13

Preparación de la placa Arduino

El código a continuación se implementó en una placa Arduino MEGA 2560 y en una placa Arduino UNO R3.

El código hace lectura de 4 sensores:

• ds18b20 (temperatura. °C)
• dht22 (humedad % - temperatura. °C)
• gy-30 (intensidad lumínica. lux)
• LM35 (temperatura. °C)

// ds18b20
#include <OneWire.h>                
#include <DallasTemperature.h>

// dht22
#include "DHT.h"

//gy-30
#include <Wire.h>
#include <BH1750.h>

// ds18b20
OneWire ourWire(2);
DallasTemperature sensors(&ourWire);

// LM35
int LM35 = A0;

// gy-30
BH1750 luxometro;

// dht22
#define DHTPIN 5
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  
  //ds18b20
  sensors.begin(); 
  
  //gy-30
  Wire.begin();
  luxometro.begin();
  //dht22
  dht.begin();
}

void loop() {
  delay(2000);

  //LM35
  int lectura = analogRead(LM35);
  float mv  = (5000 / 1024.0) * lectura; 
  float celcius = mv / 10;
  
  //ds18b20
  sensors.requestTemperatures();
  float temp= sensors.getTempCByIndex(0);
  Serial.print(temp);
  Serial.print(",");
  //gy-30
  float lux = luxometro.readLightLevel();
  //dht22
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  Serial.print(h);
  Serial.print(",");
  Serial.print(t);
  //gy-30
  Serial.print(",");
  Serial.print(lux);
  //LM35
  Serial.print(",");
  Serial.println(celcius);
 
}

NOTA: siéntase en la libertad de copiar, modificar, mejorar, criticar cualquier contenido propuesto en el documento; sugerencias y críticas también son bienvenidas.

Después de cargar el código a la placa, hacer unas lecturas con el puerto serial a través de la IDE de Arduino:

Los valores se han separado con una coma “,” en el orden en el cual se mencionaron anteriormente, pero ahora de izquierda a derecha.

Algo muy importante a tener en cuenta a la hora de hacer las lecturas con el puerto serie, es identificar el puerto con el cual se está trabajando, en Linux el nombre del puerto es algo como /dev/ttyACM# y en Mac el nombre del puerto es algo como /dev/cu.SLAB_USBtoUART.

En algunos casos se genera un error al identificar el puerto, en este caso en particular, el error se genera debido a los permisos de acceso del sistema operativo sobre el dispositivo.

Este inconveniente se puede resolver escribiendo en la terminal de Linux el siguiente código, que habilita la recepción de datos a través del puerto serie.

sudo chmod a+rw /dev/ttyACM#

Recuerde que # es el número que arroja la IDE de Arduino en la esquina inferior derecha.

NOTA: Esta solución NO es permanente ni es la mejor solución; cada vez que se desconecta la placa del puerto se pierde la configuración y, se debe habilitar una vez se conecte nuevamente la placa. Se recomienda buscar una solución que resuelva este inconveniente.

Paquete arduinor

Instalación

La instalación se hará desde RStudio.

devtools::install_github("r-arduino/arduinor")

Conexión Puerto Serie

Después de instalar el paquete, vamos a hacer uso de las funciones que trae, una primera función es la que nos permite crear la conexión con el puerto serie ar_init(). Recuerde hacer uso de la ayuda que brinda RStudio para obtener información acerca de las funciones ?ar_init.

Se creará un objeto llamado pserie que configura la conexión con el puerto serie identificando el puerto y la tasa de baudios.

# cargar la librería
library(arduinor)
# iniciar conexión el puerto serie
pserie <- ar_init(serialport = "/dev/ttyACM6", baud = 9600)

Acá es bien importante que la tasa de baudios coincida con la del código de Arduino, de lo contrario no se podrá sincronizar la tasa lectura.

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

Otra función útil es ar_flush_hard() la cual limpia las lecturas aleatoria iniciales.

ar_flush_hard(pserie)

Trasmitir en consola

La función ar_monitor() trasmite las lecturas del puerto serie capturadas del Arduino hacia la consola de RStudio, se detendrá cuando presione el botón STOP.

ar_monitor(pserie)

La función ar_read() lee el valor actual y lo transmite en la consola.

Capturar un cierto número de datos

Con la función ar_collect() es posible ajustar el tamaño de la muestra que desea capturar, por defecto toma 100 valores, pero se puede modificar con la opción size. Recuerde leer la información completa de la función para revisar las otras opciones que se pueden ajustar. En este caso se recolectaron 10 datos en el objeto llamado ndatos; la función se detiene cuando captura el dato número 10. También se puede detener el proceso con el botón STOP de la consola.

ndatos <- ar_collect(fd = pserie, size = 10)

> ndatos <- ar_collect(fd = pserie, size = 10)
Flushing Port...
[==============================>-------------------------------]  50%
Flushing Port...
Done

Visualizar los datos

La función ar_plotter() abre una aplicación con shiny que se ejecuta en la ventana Viewer de RStudio, que muestra los datos en un gráfico interactivo. La opción names = permite nombrar las variables que se desea acompañen al gráfico.

ar_plotter(fd = pserie, names = c("ds18b20","dHt22", "dhT22", "gy30", "LM35"))

> ar_plotter(fd = con, c("ds18b20","dHt22", "dhT22", "gy30", "LM35"))
Flushing Port...

Listening on http://127.0.0.3:5678

La app tiene botones interactivos para iniciar, reiniciar y detener la trasmisión de los datos, una casilla de selección si se desea que los datos se guarden en un archivo .csv, entre otras opciones propias de la visualización. Para detener la app, se presiona el boton STOP del visor (Viewer).

Hasta este punto se menciona el tema del paquete arduinor, lo que sigue es una forma de depurar los datos obtenidos con las funciones de la librería, para que posteriormente se pueda operar sobre ellos con el paquete tidyverse por ejemplo.

Depuración de datos desde .csv

En la parte inferior, se puede seleccionar la casilla “Save to file?” antes de iniciar la captura de datos, para que los datos capturados sean guardados en un archivo .csv a medida que se proyectan sobre el gráfico interactivo. El nombre del archivo csv también puede ser modificado en la casilla de texto que se encuentra al lado derecho de la opción de guardar archivo. (El archivo se guarda en el directorio de la sesión de trabajo de RStudio.)

Se presenta el conjunto de datos obtenidos con los sensores anteriormente mencionados.

library(tidyverse)

Varios de los paquetes incluidos en el tidyverse incluyen herramientas para la depuración de datos e incluso, para hacer gráficos.

• Lectura de los datos:

sensores <- read_csv(file = "arduino_20210505_085105.csv")

── Column specification ──────────────────────────────────────────────────
cols(
  ds18b20 = col_double(),
  dHt22 = col_double(),
  dhT22 = col_double(),
  gy30 = col_double(),
  LM35 = col_double()
)

sensores

Obtener el archivo .csv es una buena opción para obtener métricas o un resumen numérico directamente sobre este.

• Resumen numérico:

sensores %>% 
  summary

    ds18b20            dHt22          dhT22            gy30       
 Min.   :-127.00   Min.   :99.9   Min.   :26.30   Min.   :  8.33  
 1st Qu.:-127.00   1st Qu.:99.9   1st Qu.:26.50   1st Qu.: 65.00  
 Median :  27.00   Median :99.9   Median :26.70   Median : 77.50  
 Mean   : -25.25   Mean   :99.9   Mean   :26.68   Mean   : 74.38  
 3rd Qu.:  27.31   3rd Qu.:99.9   3rd Qu.:26.90   3rd Qu.: 83.33  
 Max.   :  35.38   Max.   :99.9   Max.   :27.10   Max.   :107.50  
      LM35      
 Min.   : 0.00  
 1st Qu.:45.41  
 Median :45.90  
 Mean   :41.75  
 3rd Qu.:45.90  
 Max.   :52.25  

• Obtener la mediana del sensor gy30

sensores %>% 
  pull(gy30) %>%
  median()

[1] 77.5

• Agregar una columna con el tiempo en segundos.

df_sensores <- sensores %>% 
  mutate(tiempo = c(seq(1:nrow(sensores))),
         tiempo = (2*tiempo)) %>% 
  relocate(tiempo, everything())

df_sensores

• Generar tabla con las métricas de las variables.

df_sensores %>% 
  filter(ds18b20 > 0) %>% 
   select("tiempo","ds18b20","dHt22", "dhT22", "gy30", "LM35") %>% 
  pivot_longer(cols = -tiempo, names_to = "sensor", values_to = "valor") %>% 
  group_by(sensor) %>% 
  summarise(media = round(mean(valor), digits = 2),
            mediana = median(valor),
            desv = round(sd(valor), digits = 2)
                         ) %>% 
  datatable(rownames = FALSE)

• Gráfico del sensor gy30

df_sensores %>% 
  ggplot(mapping = aes(x = tiempo, y = gy30)) +
  geom_line(color = "cadetblue")+
  labs(title = "Intensidad Lumínica", subtitle = "Sensor gy-30", y = "lux", x = "Tiempo [s]")+
  scale_x_continuous(breaks = seq(2,1702, 60))+
  scale_y_continuous(breaks = seq(9,110, 10))+
  theme_get()+
  theme(axis.text.x = element_text(angle = 45))

• Gráfico para el sensor ds18b20

Se filtran los valores mayores a cero grados.

df_sensores %>%
  filter(ds18b20 > 0) %>% 
  ggplot(mapping = aes(x = tiempo, y = ds18b20)) +
  geom_line(color = "firebrick2")+
  labs(title = "Temperatura del Suelo", subtitle = "Sensor ds18b20", y = "°C", x = "Tiempo [s]")+
  scale_x_continuous(breaks = seq(2,1702, 60))+
  scale_y_continuous(breaks = seq(0,40, 1))+
  theme_get()+
  theme(axis.text.x = element_text(angle = 45))

• Gráfico para el sensor dht22 (Humedad relativa ambiente)

Los valores obtenidos para esta variable se mantienen en un valor de \(99.9\) el cual es un valor erróneo, tal vez debido a una avería en el sensor, o un error en la configuración hecha en el código de Arduino.

df_sensores %>%
  ggplot(mapping = aes(x = tiempo, y = dHt22)) +
  geom_line(color = "firebrick2")+
  labs(title = "Temperatura Ambiente", subtitle = "Sensor dht22", y = "% Humedad", x = "Tiempo [s]")+
  theme_get()+
  theme(axis.text.x = element_text(angle = 45))

• Gráfico temperatura ambiente sensor dht22

Este sensor mide también la temperatura ambiente, se realiza el gráfico de esta variable.

df_sensores %>%
  filter(dhT22 > 0) %>% 
  ggplot(mapping = aes(x = tiempo, y = dhT22)) +
  geom_line(color = "forestgreen")+
  labs(title = "Temperatura Ambiente", subtitle = "Sensor dht22", y = "°C", x = "Tiempo [s]")+
  scale_x_continuous(breaks = seq(2,1702, 60))+
  scale_y_continuous(breaks = seq(0,35, 0.05))+
  theme_get()+
  theme(axis.text.x = element_text(angle = 45))

• Gráfico temperatura sensor LM35

df_sensores %>%
  ggplot(mapping = aes(x = tiempo, y = LM35)) +
  geom_line(color = "orange")+
  labs(title = "Temperatura Ambiente", subtitle = "Sensor LM35", y = "°C", x = "Tiempo [s]")+
  scale_x_continuous(breaks = seq(2,1702, 60))+
  scale_y_continuous(breaks = seq(0,60, 5))+
  theme_get()+
  theme(axis.text.x = element_text(angle = 45))

Depurar captura de datos

La función ar_collect() del paquete arduinor permite tomar una cierta cantidad de datos de los sensores, para este ejemplo se tomaron 100 datos..

dt100 <- ar_collect(fd = pserie, size = 100)

• Datos del objeto ndatos

EL objeto que se obtiene es un vector de longitud 100 y de clase character.

class(dt100)

• Dar dimensión al vector

Al darle una dimensión se obtiene un arreglo tipo “matrix” o “array”.

dim(x = dt100) <- c(length(dt100),1)
class(dt100)

[1] "matrix" "array" 

head(dt100)

     [,1]                             
[1,] "\n"                             
[2,] "31.25,99.90,30.90,30.00,31.25\n"
[3,] "\n"                             
[4,] "31.19,99.90,30.90,30.83,31.25\n"
[5,] "\n"                             
[6,] "31.25,99.90,30.90,30.83,31.25\n"

• Convertir a data frame.
• Separar los valores de cada variable en diferentes columnas.
• Convertir de caracter a numérico, las variables.
• Crear la variable tiempo.
• Eliminar las filas NA que se genera.

df_dt100 <- dt100 %>% 
  as_data_frame() %>% 
  separate(col = V1, into = c("ds18b20","dHt22", "dhT22", "gy30", "LM35"), sep = ",") %>% 
   mutate(ds18b20 = as.numeric(ds18b20),
         dHt22 = as.numeric(dHt22),
         dhT22 = as.numeric(dhT22),
         gy30 = as.numeric(gy30),
         LM35 = as.numeric(LM35)) %>% 
  mutate(tiempo = c(seq(1:nrow(dt100)))) %>% 
  relocate(tiempo, everything()) %>%
  na.omit()

Expected 5 pieces. Missing pieces filled with `NA` in 50 rows [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, ...].

df_dt100

Teniendo la base de datos conformada, es posible obtener las métricas que se desee.

summary(df_dt100)

     tiempo         ds18b20          dHt22          dhT22      
 Min.   :  2.0   Min.   :31.19   Min.   :99.9   Min.   :30.90  
 1st Qu.: 26.5   1st Qu.:31.25   1st Qu.:99.9   1st Qu.:30.90  
 Median : 51.0   Median :31.25   Median :99.9   Median :30.90  
 Mean   : 51.0   Mean   :31.26   Mean   :99.9   Mean   :30.91  
 3rd Qu.: 75.5   3rd Qu.:31.31   3rd Qu.:99.9   3rd Qu.:30.90  
 Max.   :100.0   Max.   :31.37   Max.   :99.9   Max.   :31.00  
      gy30            LM35      
 Min.   :23.33   Min.   :31.25  
 1st Qu.:25.83   1st Qu.:31.25  
 Median :25.83   Median :31.25  
 Mean   :26.37   Mean   :31.25  
 3rd Qu.:26.67   3rd Qu.:31.25  
 Max.   :30.83   Max.   :31.25  

df_dt100 %>% 
  pull(LM35) %>% 
  mean()

[1] 31.25

df_dt100 %>% 
   select("tiempo","ds18b20","dHt22", "dhT22", "gy30", "LM35") %>% 
  pivot_longer(cols = -tiempo, names_to = "sensor", values_to = "valor") %>% 
  group_by(sensor) %>% 
  summarise(media = mean(valor),
            mediana = median(valor),
            desv = round(sd(valor), digits = 2)
                         ) %>% 
  datatable(rownames = FALSE)

Gráfico interactivo

library(plotly)

ggplotly(
df_dt100 %>% 
  ggplot(mapping = aes(x = tiempo, y = gy30))+
  geom_line(color = "green")+
  labs(title = "Intensidad Lumínica",
       y = "lux",
       x = "tiempo [s]")+
  scale_x_continuous(breaks = seq(2,100, 2))+
  scale_y_continuous(breaks = seq(0,40, 1))+
  theme_get()+
  theme(axis.text.x = element_text(angle = 45)),
width = 900
)