PRÁCTICA: CUBE SAT
UNIDAD Ill
INTERFACES Y REDES INDUSTRIALES
ANDRADE CERVANTES YVES EDUARDO CRUZ SANTOS RUBEN ISAAC
GARCIA SERRANO CUAUHTÉMOC ELIAS SANCHEZ ALVAREZ LUIS FERNANDO
TECNOLÓGICO NACIONAL DE MÉXICO
INSTITUTO TECNOLÓGICO DE COLIMA
Departamento de Ingeniería Mecatrónica
Av. Tecnológico #1 CP 28976 Villa de Álvarez, Colima
Resumen: En este reporte se muestra la práctica que se asemeja a Omitiendo la parte de la conexión del LED, se observa
muchas aplicaciones en la industria, se puede observar este tipo de que el radio está conectado de tal forma que funcionará
monitoreo en automóviles y en la industria aeroespacial, por ejemplo. como receptor, el Arduino recibirá el dato de forma serial
Se expondrá los resultados y los métodos empleados para llevar a cabo para poder captar una respuesta y en base a ella
dicha práctica. encender o apagar dicho LED.
• Micro SD card adapter: La comunicación de la memoria
I. INTRODUCCIÓN es por SPI pero trabajan con 3.3V, para utilizarlo con
Arduino necesitamos módulos externos que aparte de
Se pondrá en práctica lo visto en clase y hecho durante la materia, tener el socket traen los componentes necesarios para
el uso de protocolos de comunicación, en este caso adaptar los voltajes a TTL y poder conectarlo de forma
específicamente utilizaremos I2C y SPI, el objetivo de la práctica fácil a nuestro Arduino.
es monitorear distintas variables a una altura predeterminada,
dichas variables serán la temperatura, la humedad y la presión.
Todo ello será almacenado en formato de registro en una memoria
micro SD.
Para ello utilizaremos los siguientes dispositivos que nos ayudarán
a lograr el objetivo:
• Radiofrecuencia XBEE
• Micro SD card adapter
• Sensor GY-BME280
• Reloj DS1307
• 2 placas de ARDUINO
• Cable dupont para conexión
Descripción de cada uno de los componentes:
• Xbee: El Xbee-Pro S2C es un módulo de bajo costo que
permite realizar conexiones inalámbricas entre
dispositivos electrónicos. Trabaja con una frecuencia de
2.4Ghz y permite crear redes de conexión punto a punto,
punto a multipunto, broadcast y mesh.
Además, en esta nueva generación de Xbee se
incorpora la comunicación SPI (serial peripheral
interface) que provee un intercambio de datos con una
alta velocidad entre dispositivos, optimizando la
conexión con microcontroladores. Este modelo en
concreto posee un alcance de 90 metros en lugares
cerrados y hasta 3200 metros en lugares abiertos, línea • Sensor GY-BME280: Este módulo incluye el
vista y en las mejores condiciones. Cuenta con 15 pines componente BME 280 que realiza con alta precisión las
I/0 de los cuales 4 se usan para entradas analógicas de mediciones de la presión atmosférica, la temperatura y
10-bit. también la humedad.
El equipo utiliza 2 interfaces, la I2C y la SPI.
El BME280 no permite ser usado como altímetro al
contrario del BMP280, sin embargo, es capaz de
emplearse mediante programación una diferencia de
presión para poder ser calculado un aproximado
bastante real de dicha variable.
Su conector recto de 5 pines permite conectarlo
fácilmente a otras placas electrónicas.
El sensor realiza mediciones de presión atmosférica,
temperatura y humedad relativa todo eso integrado en
un solo chip realmente compacto y de bajo consumo
energético. Presenta alta precisión y linealidad en sus El sensor BME280 nos ayudará a registrar los parámetros que
mediciones. Este chip se encuentra montado en un necesitamos registrar, con un arreglo PULL UP habremos de
módulo para simplificar su conexión a un habilitar los registros para poder comunicar el sensor con el
microcontrolador, solo conéctalo directamente a través microcontrolador, con el protocolo I2C haremos dicha
de I2C o SPI. Algunos usos de este sensor pueden ser comunicación.
para calcular la altitud de sistemas de autopiloto,
monitoreo de clima, internet de las cosas o en domótica. El reloj DS1307 será la encargada de registrar la fecha en donde
Existen versiones de este módulo que soportan 5V, pero se obtiene el dato, dicho evento será comunicado con un protocolo
el nuestro en particular funciona a 3.3V, de modo que no SPI, el fin de utilizar otro protocolo es para verificar la eficacia que
debemos conectarlo directamente al bus del Arduino. Lo presenta utilizar diferentes protocolos en un mismo controlador.
mejor es utilizar un adaptador de niveles y si no
disponemos de él se pueden usar un par de resistencias Por último, los XBEE obtendrán y recibirán los datos de manera
pull-up de 4.7K para conectar directamente Arduino con serial, sin embargo, la comunicación entre dichos radios es
un componente que usa el bus I2C a 3.3V. radiofrecuencia cabe aclararlo.
El esquema para la conexión con el Arduino UNO II. METODOLOGÍA
mediante I2C sería así usando los pines A4(SDA) y A5
(SLC): Los pines a utilizar serían de la siguiente forma.
• BME280: Alimentación de 3.3v, su respectiva tierra, SCL
en el Pin 21 Arduino MEGA, y SDA en el PIN 20 Arduino
MEGA. Un arreglo PULL UP en SDA Y SCL.
• Reloj DS1307 PINES 7,8 Y 9 del Arduino MEGA. Para
la comunicación SPI, además de su respectivo 5V y
tierra.
• Radio XBEE: De parte del emisor se utiliza TX
conectado al PIN 1 del Arduino MEGA y su respectiva
alimentación 5V y tierra. De lado del receptor la conexión
varía únicamente en utilizar el RX en vez del TX para
recibir y usando un Arduino UNO en el PIN 0.
Para iniciar la práctica se investigó por medio de sus hojas de
datos (datasheet) de cada componente su funcionamiento, la
comunicación y como este interactúa con el entorno para la
• Reloj DS 1307: Módulo RTC (Real Time Clock) o reloj obtención de los datos, para el caso de BME280 la
en Tiempo Real con soporte de batería para una pila de comunicación podía ser I2C o SPI, se optó por el primero ya
botón CR2032. El módulo permite a un microcontrolador que estábamos más familiarizados con el protocolo, además
leer la hora y fecha actuales con una precisión muy alta. de que el otro componente no tenía esa dualidad de
El módulo puede proporcionar el tiempo en segundos, posibilidad por ende, decidimos usar 1 y 1 para no tener
minutos, horas, fecha, mes y año. Las funciones problemas en direccionamiento. Dicho esto, pudimos facilitar
adicionales incluyen compensación de año bisiesto, un poco el trabajo al ver que en el caso del BME280 ocupaba
formato de 12/24 h y una salida de onda cuadrada una muestra y estar transformándola en números ya sea de
programable. El módulo detecta cuándo desciende la 25 bits o 7 bits, como nuestra intención era mandarlo en una
tensión de alimentación y cambia automáticamente a la sola trama, se optó por desempaquetar los datos, hacer una
batería de respaldo para que el reloj siga funcionando. media, redireccionarlos en diferentes tiempos y mandar todo
Cuando se alimenta de la batería de respaldo, el módulo de manera fragmentada, de tal forma que al recibirlo solo
consume muy poca corriente y continuará funcionando tuviera que juntar los pedazos y unirlos de manera natural, así
durante mucho tiempo. El RTC se comunica a través de como los mandó. Para el reloj se hizo prácticamente lo mismo,
I2C. sin embargo, como el protocolo cambió un poco las cosas no
El módulo está basado en el RTC DS1307 de MAXIM y serían lo mismo, en este caso fuimos más específicos ya que
la EEPROM AT24C32 de ATMEL. Ambos circuitos eliminábamos la posibilidad de reprogramar el reloj cada que
integrados comparten el mismo bus comunicación con se subiera el programa, sin embargo, no queríamos depender
el Protocolo I2C. La memoria EEPROM AT24C32 te de la pila que se acopló al dispositivo para guardar la fecha,
permite almacenar 32Kbits (4K Bytes) de datos de entonces usamos el método de “variables dinámicas” las
manera permanente. cuales eran usadas o no en formatos de banderas para poder
identificar cuando el programa creía o no conveniente
DS1302_SCLK_PIN 9 // Arduino pin for the Serial reprogramar dicha fecha, por lo tanto, si nuestro reloj se le
DS1302_IO_PIN 8 // Arduino pin for the Data I/O extraía la pila este compararía la última fecha guardada con
DS1302_CE_PIN 7 // Arduino pin for the la fecha actual, y si la diferencia era más de 24 horas, esta
entraría en un reset y eliminaría la hora anterior, conservando
La radiofrecuencia será encargada por los radios de la marca la que consiguió al ser reprogramada. Por lo demás todo era
XBEE, el cual nos ayudarán para poder intercomunicar los mandado de forma serial por los radios entre ambos
sensores con los microcontroladores ARDUINO de manera serial. microcontroladores.
La micro sd card adapter será esencial para poder guardar los Para los radios XBEE utilizamos el software XCTU, para
datos que lleguen al microcontrolador. configurar su canal “1234”, identificar sus ID’s y poder
enlazarlos, utilizar uno como emisor y el otro como receptor. typedef struct ds1302_struct
Cabe destacar que pusimos los router en el modo [0] “No {
sleep router” el cual nos aseguraba que no dudaría en estar uint8_t Seconds:4; // low decimal digit 0-9
siempre pendiente de solicitudes entre ambos radios. uint8_t Seconds10:3; // high decimal digit 0-5
uint8_t CH:1; // CH = Clock Halt
[CÓDIGO DEL EMISOR] uint8_t Minutes:4;
#include<Wire.h> uint8_t Minutes10:3;
uint8_t reserved1:1;
#define Addr 0x76 union
#define DS1302_SCLK_PIN 9 // Arduino pin for the Serial {
Clock struct
#define DS1302_IO_PIN 8 // Arduino pin for the Data I/O {
#define DS1302_CE_PIN 7 // Arduino pin for the Chip uint8_t Hour:4;
Enable uint8_t Hour10:2;
#define bcd2bin(h,l) (((h)*10) + (l)) uint8_t reserved2:1;
#define bin2bcd_h(x) ((x)/10) uint8_t hour_12_24:1; // 0 for 24 hour format
#define bin2bcd_l(x) ((x)%10) } h24;
#define DS1302_SECONDS 0x80 struct
#define DS1302_MINUTES 0x82 {
#define DS1302_HOURS 0x84 uint8_t Hour:4;
#define DS1302_DATE 0x86 uint8_t Hour10:1;
#define DS1302_MONTH 0x88 uint8_t AM_PM:1; // 0 for AM, 1 for PM
#define DS1302_DAY 0x8A uint8_t reserved2:1;
#define DS1302_YEAR 0x8C uint8_t hour_12_24:1; // 1 for 12 hour format
#define DS1302_ENABLE 0x8E } h12;
#define DS1302_TRICKLE 0x90 };
#define DS1302_CLOCK_BURST 0xBE uint8_t Date:4; // Day of month, 1 = first day
#define DS1302_CLOCK_BURST_WRITE 0xBE uint8_t Date10:2;
#define DS1302_CLOCK_BURST_READ 0xBF uint8_t reserved3:2;
#define DS1302_RAMSTART 0xC0 uint8_t Month:4; // Month, 1 = January
#define DS1302_RAMEND 0xFC uint8_t Month10:1;
#define DS1302_RAM_BURST 0xFE uint8_t reserved4:3;
#define DS1302_RAM_BURST_WRITE 0xFE uint8_t Day:3; // Day of week, 1 = first day (any day)
#define DS1302_RAM_BURST_READ 0xFF uint8_t reserved5:5;
#define DS1302_D0 0 uint8_t Year:4; // Year, 0 = year 2000
#define DS1302_D1 1 uint8_t Year10:4;
#define DS1302_D2 2 uint8_t reserved6:7;
#define DS1302_D3 3 uint8_t WP:1; // WP = Write Protect
#define DS1302_D4 4 };
#define DS1302_D5 5
#define DS1302_D6 6 void DS1302_clock_burst_read( uint8_t *p)
#define DS1302_D7 7 {
int i;
#define DS1302_READBIT DS1302_D0 // READBIT=1: read
instruction _DS1302_start();
#define DS1302_RC DS1302_D6 _DS1302_togglewrite( DS1302_CLOCK_BURST_READ,
true);
#define DS1302_CH DS1302_D7 // 1 = Clock Halt, 0 = start
for( i=0; i<8; i++)
#define DS1302_AM_PM DS1302_D5 // 0 = AM, 1 = PM {
#define DS1302_12_24 DS1302_D7 // 0 = 24 hour, 1 = 12 *p++ = _DS1302_toggleread();
hour }
_DS1302_stop();
#define DS1302_WP DS1302_D7 // 1 = Write Protect, 0 = }
enabled
void DS1302_clock_burst_write( uint8_t *p)
#define DS1302_ROUT0 DS1302_D0 {
#define DS1302_ROUT1 DS1302_D1 int i;
#define DS1302_DS0 DS1302_D2
#define DS1302_DS1 DS1302_D2 _DS1302_start();
#define DS1302_TCS0 DS1302_D4
#define DS1302_TCS1 DS1302_D5 _DS1302_togglewrite( DS1302_CLOCK_BURST_WRITE,
#define DS1302_TCS2 DS1302_D6 false);
#define DS1302_TCS3 DS1302_D7
for( i=0; i<8; i++)
{ }
_DS1302_togglewrite( *p++, false); return( data);
} }
_DS1302_stop();
} void _DS1302_togglewrite( uint8_t data, uint8_t release)
{
uint8_t DS1302_read(int address) int i;
{
uint8_t data; for( i = 0; i <= 7; i++)
{
bitSet( address, DS1302_READBIT);
digitalWrite( DS1302_IO_PIN, bitRead(data, i));
_DS1302_start(); delayMicroseconds( 1); //
_DS1302_togglewrite( address, true);
data = _DS1302_toggleread(); digitalWrite( DS1302_SCLK_PIN, HIGH);
_DS1302_stop();
delayMicroseconds( 1);
return (data); if( release && i == 7)
} {
pinMode( DS1302_IO_PIN, INPUT);
void DS1302_write( int address, uint8_t data) }
{ else
bitClear( address, DS1302_READBIT); {
digitalWrite( DS1302_SCLK_PIN, LOW);
_DS1302_start(); delayMicroseconds( 1);
_DS1302_togglewrite( address, false); }
_DS1302_togglewrite( data, false); }
_DS1302_stop(); }
} void setup()
{
void _DS1302_start( void) // I2C MASTER
{ Wire.begin();
digitalWrite( DS1302_CE_PIN, LOW); // default, not enabled // SERIAL SOLICITUDES
pinMode( DS1302_CE_PIN, OUTPUT); Serial.begin(9600);
digitalWrite( DS1302_SCLK_PIN, LOW); // default, clock low ds1302_struct rtc;
pinMode( DS1302_SCLK_PIN, OUTPUT);
DS1302_write (DS1302_ENABLE, 0);
pinMode( DS1302_IO_PIN, OUTPUT);
DS1302_write (DS1302_TRICKLE, 0x00);
digitalWrite( DS1302_CE_PIN, HIGH); // start the session
delayMicroseconds( 4); // tCC = 4us }
}
void loop()
void _DS1302_stop(void) {
{
// Set CE low unsigned int b1[24];
digitalWrite( DS1302_CE_PIN, LOW); unsigned int data[8];
unsigned int dig_H1 = 0;
delayMicroseconds( 4); // tCWH = 4us for(int i = 0; i < 24; i++)
} {
// I2C START
uint8_t _DS1302_toggleread( void) Wire.beginTransmission(Addr);
{ // SELECCION DEL REGISTRO
uint8_t i, data; Wire.write((136+i));
// I2C STOP
data = 0; Wire.endTransmission();
for( i = 0; i <= 7; i++)
{ // SOLICITUD DE 1 BYTE
digitalWrite( DS1302_SCLK_PIN, HIGH); Wire.requestFrom(Addr, 1);
delayMicroseconds( 1);
// LECTURA DE 24 BYTES
digitalWrite( DS1302_SCLK_PIN, LOW); if(Wire.available() == 1)
delayMicroseconds( 1); {
b1[i] = Wire.read();
bitWrite( data, i, digitalRead( DS1302_IO_PIN)); }
} Wire.endTransmission();
// CONVERSION DE DATOS
// TEMPERATURA Wire.beginTransmission(Addr);
unsigned int dig_T1 = (b1[0] & 0xff) + ((b1[1] & 0xff) * 256); // SELECTOR DE MEDICION DE CONTROL
int dig_T2 = b1[2] + (b1[3] * 256); Wire.write(0xF4);
int dig_T3 = b1[4] + (b1[5] * 256); // MODO NORMAL, TEMP Y PRESSION ARRIBA DEL
RATIO 1
// PRESION RELATIVA Wire.write(0x27);
unsigned int dig_P1 = (b1[6] & 0xff) + ((b1[7] & 0xff ) * 256);
int dig_P2 = b1[8] + (b1[9] * 256); Wire.endTransmission();
int dig_P3 = b1[10] + (b1[11] * 256);
int dig_P4 = b1[12] + (b1[13] * 256);
int dig_P5 = b1[14] + (b1[15] * 256); Wire.beginTransmission(Addr);
int dig_P6 = b1[16] + (b1[17] * 256); // SELECTOR DEL REGISTRO
int dig_P7 = b1[18] + (b1[19] * 256); Wire.write(0xF5);
int dig_P8 = b1[20] + (b1[21] * 256); // ESPERA DE 1 SEGUNDO
int dig_P9 = b1[22] + (b1[23] * 256); Wire.write(0xA0);
Wire.beginTransmission(Addr); Wire.endTransmission();
Wire.write(161); for(int i = 0; i < 8; i++)
{
Wire.endTransmission();
Wire.beginTransmission(Addr);
// SELECTOR DE DATOS EN EL REGISTRO
Wire.requestFrom(Addr, 1); Wire.write((247+i));
// LECTURA Y EVALACIÓN DEL BYTE Wire.endTransmission();
if(Wire.available() == 1)
{
dig_H1 = Wire.read(); Wire.requestFrom(Addr, 1);
}
for(int i = 0; i < 7; i++) if(Wire.available() == 1)
{ {
data[i] = Wire.read();
Wire.beginTransmission(Addr); }
}
Wire.write((225+i));
//CONVERSOR DE PRESION Y TEMPERATURA EN
Wire.endTransmission(); NUMEROS DE 19-bits
long adc_p = (((long)(data[0] & 0xFF) * 65536) +
((long)(data[1] & 0xFF) * 256) + (long)(data[2] & 0xF0)) / 16;
Wire.requestFrom(Addr, 1); long adc_t = (((long)(data[3] & 0xFF) * 65536) +
((long)(data[4] & 0xFF) * 256) + (long)(data[5] & 0xF0)) / 16;
// VERIFICACIÓN DE LOS 7 BITS // Convert the humidity data
if(Wire.available() == 1) long adc_h = ((long)(data[6] & 0xFF) * 256 + (long)(data[7] &
{ 0xFF));
b1[i] = Wire.read();
} // TEMPERATURA CALCULADA
} double var1 = (((double)adc_t) / 16384.0 - ((double)dig_T1)
/ 1024.0) * ((double)dig_T2);
// HUMEDAD RELATIVA double var2 = ((((double)adc_t) / 131072.0 -
int dig_H2 = b1[0] + (b1[1] * 256); ((double)dig_T1) / 8192.0) *
unsigned int dig_H3 = b1[2] & 0xFF ; (((double)adc_t)/131072.0 - ((double)dig_T1)/8192.0)) *
int dig_H4 = (b1[3] * 16) + (b1[4] & 0xF); ((double)dig_T3);
int dig_H5 = (b1[4] / 16) + (b1[5] * 16); double t_fine = (long)(var1 + var2);
int dig_H6 = b1[6]; double cTemp = (var1 + var2) / 5120.0;
double fTemp = cTemp * 1.8 + 32;
Wire.beginTransmission(Addr);
// PRESION CALCULADA
Wire.write(0xF2); var1 = ((double)t_fine / 2.0) - 64000.0;
// HUMEDAD ARRIBA DE 1 var2 = var1 * var1 * ((double)dig_P6) / 32768.0;
Wire.write(0x01); var2 = var2 + var1 * ((double)dig_P5) * 2.0;
var2 = (var2 / 4.0) + (((double)dig_P4) * 65536.0);
var1 = (((double) dig_P3) * var1 * var1 / 524288.0 + ((double) [CÓDIGO DEL RECEPTOR]
dig_P2) * var1) / 524288.0; #include <SD.h>
var1 = (1.0 + var1 / 32768.0) * ((double)dig_P1);
double p = 1048576.0 - (double)adc_p; File logFile;
p = (p - (var2 / 4096.0)) * 6250.0 / var1;
var1 = ((double) dig_P9) * p * p / 2147483648.0; void setup() {
var2 = p * ((double) dig_P8) / 32768.0; Serial.begin(9600);
double pressure = (p + (var1 + var2 + ((double)dig_P7)) / Serial.print(F("Iniciando SD ..."));
16.0) / 100; if (!SD.begin(9))
{
// HUMEDAD CALCULADA Serial.println(F("Error al iniciar"));
double var_H = (((double)t_fine) - 76800.0); return;
var_H = (adc_h - (dig_H4 * 64.0 + dig_H5 / 16384.0 * var_H)) }
* (dig_H2 / 65536.0 * (1.0 + dig_H6 / 67108864.0 * var_H * Serial.println(F("Iniciado correctamente"));
(1.0 + dig_H3 / 67108864.0 * var_H))); }
double humidity = var_H * (1.0 - dig_H1 * var_H / 524288.0); int readSensor()
if(humidity > 100.0) {
{ return 0;
humidity = 100.0; }
} void loop()
else if(humidity < 0.0) {
{ String R;
humidity = 0.0; if(Serial.available()){
} R=Serial.readStringUntil('Y');
Serial.print(R);
ds1302_struct rtc; // Abrir archivo y escribir valor
char buffer[80]; logFile = SD.open("datalog.txt", FILE_WRITE);
DS1302_clock_burst_read( (uint8_t *) &rtc); if (logFile) {
sprintf( buffer, "Time = %02d:%02d:%02d ", \ int value = readSensor;
bcd2bin( rtc.h24.Hour10, rtc.h24.Hour), \ logFile.println(R);
bcd2bin( rtc.Minutes10, rtc.Minutes), \
bcd2bin( rtc.Seconds10, rtc.Seconds)); logFile.close();
double altura; }
altura = ((951.58 - pressure) / .19); else {
Serial.println("Error al abrir el archivo");
// TODOS LOS DATOS DE SALIDA }
Serial.print("Temperatura : "); }
Serial.print(cTemp); }
Serial.println(" C");
Serial.println(); ¿Qué es lo que hace?
Serial.print("Presion : "); Básicamente utiliza un Arduino Mega como el receptor de los
Serial.print(pressure); datos censados del BME y el reloj con protocolos I2C Y SPI
Serial.println(" hPa"); respectivamente, cuando el microcontrolador tiene los datos,
Serial.println(); procede a enviarlos al otro Arduino, un UNO, este recibe los
Serial.print("Humedad relativa : "); datos de forma serial obtenido de su receptor XBEE que este
Serial.print(humidity); recibió por un canal en radio frecuencia de su emisor XBEE,
Serial.println(" RH"); cuando el UNO obtiene los datos, procede a guardarlos en
Serial.println(); una memoria SD de forma serial.
Serial.print("Altura : ");
Serial.print(altura);
Serial.println(" Mts"); III. RESULTADOS Y DISCUSIÓN
Serial.println();
Serial.println(buffer); Se adjuntará un video en donde se demuestra por medio de los
Serial.println(); monitores seriales de ambos microcontroladores el
sprintf(buffer, "Día del mes = %d, Mes = %d, " \ funcionamiento.
"Año = %d", \
bcd2bin( rtc.Date10, rtc.Date), \ Para la práctica real, estimamos que, al no tener antena en uno de
bcd2bin( rtc.Month10, rtc.Month), \ los sensores, el alcance de estos es aproximadamente entre 10 y
2000 + bcd2bin( rtc.Year10, rtc.Year)); 20 metros entre los radios, con una altura de 5 metros, haciendo
Serial.println( buffer); este un radio de entre 10 y 15 metros para obtener una buena
Serial.print("----------------------"); comunicación, más allá de eso, recibirá datos de manera
Serial.println(); incompleta, todo con una pauta de 3 segundos.
delay(3000);
}
IV. CONCLUSIONES
Hemos de concluir que la práctica en general fue entretenida y muy
educativa de hacer, reforzamos lo que hemos estado aprendiendo
sobre protocolos de comunicación y como estos funcionan en una
aplicación industrial, sabemos que el uso de sensores como el
BME280 son utilizados por su bajo costo, consumo y su discreción
física, sin embargo, hemos de mencionar que al no poseer unos
radios con una antena física, tuvimos muchas limitaciones para
poder demostrar en todo su esplendor la practicidad de esta
práctica, aún así, estamos satisfechos con los resultados y nos
damos la idea del alcance que puede tener este tipo de
aplicaciones en la industria.
V. REFERENCIAS
https://forum.arduino.cc
http://sheepdogguides.com/arduino/ah3rtcDS13
02.htm
http://enrique.latorres.org/es_ES/2017/10/24/usa
ndo-el-sensor-bme280-de-presion-humedad-y-
temperatura/
Datasheets [No oficiales] usados para
componentes no manufacturados por los
fabricantes originales.
