El internet de las cosas (IoT) generalmente se refiere a dispositivos capaces de recolectar datos y comunicar esa data a servidores y otros dispositivos a través de la internet sin necesidad de intervención humana. Cada “cosa” hace algo único, como recolectar datos de temperatura, monitorear la comida que ponemos en el refrigerador, y muchas otras. Los dispositivos IoT realizan funciones especificas, por lo tanto, requieren de menos recursos que una computadora o un teléfono.
Estos dispositivos están implementados con micro-controladores que son bastante pequeños, y por ser así consumen menos espacio y energía. Los micro-controladores también tienen periféricos que les permiten interactuar con el mundo a través de sensores (como un sensor de temperatura) y actores (como un motor)
Este post se enfoca en implementar un dispositivo IoT con un micro-controlador arduino. Como es de esperarse los dispositivos IoT deben ser capaces de conectarse a la internet, y este post mostrara como hacerlo con un dispositivo ESP8266.
Para llevar a cabo este proyecto necesitamos lo siguiente:
- Arduino Uno ( $8 )
- Protoboard ( $ 9.99 )
- Modulo WiFi ESP8266 ( 5 x $15.99 )
- Jumpers ( 120 x $6.98 )
- FTDI USB-Serial ( $5.99 )
- Sensor de temperatura LM35 ( $ 3.06 )
El proyecto cuesta un total de $50 si no tienen ninguno de los artículos listados, créanme que es una inversión que vale mucho la pena hacer 🙂
El proyecto consiste en realizar un monitor de temperatura que actualice constantemente un servicio web con la temperatura leída por el sensor.
Obteniendo Datos Del Sensor
Conectamos el pin de tierra a tierra, el de VCC al de 5V del arduino, y el pin de salida al pin análogo 0 del arduino.
El código que necesitamos para monitorear la lectura del controlador es el siguiente:
int sensor = A0;
void setup() {
// abrimos el puerto serial
Serial.begin(9600);
}
void loop() {
// enviar las lecturas del sensor al puerto serial
Serial.println(obtener_temp(sensor));
analogReference(INTERNAL);
}
// obtenemos la temperatura del sensor.
float obtener_temp(int pin){
float temperatura = analogRead(pin);
temperatura = (temperatura*5000.0)/1024; //pasar la temperatura a Celsius
return temperatura;
}Ahora deberían ver las lecturas de temperatura del LM35 en su monitor serial. Noten que el arduino lee una entrada análoga que oscila entre los 0V y los 5V y esta cuantificada en 1024 niveles. Entonces las lecturas análogas se convierten a temperatura en grados celsius con la formula que se da en el método “get_temp”.
Transmitiendo la información del sensor al internet
Lo siguiente que hay que hacer es un programa que grabaremos en el modulo WiFi, el tutorial para hacerlo se encuentra en este post.
#include <ESP8266WiFi.h>
const char* ssid = "RED_WIFI";
const char* password = "un_password_seguro";
const char* host = "<la_url_del_servidor>";
String temperatura;
void setup() {
Serial.begin(9600);
delay(100);
// Conectamos el modulo WiFi al internet
Serial.println();
Serial.println();
Serial.print("esp -> Conectandose... ");
Serial.println(ssid);
WiFi.begin(ssid, password); //que red y que password
while (WiFi.status() != WL_CONNECTED) {
delay(500);
}
Serial.println("esp -> WiFi Conectado");
Serial.println("esp -> Direccion IP: ");
Serial.println(WiFi.localIP());
Serial.println("Listo!");
}
void loop() {
WiFiClient cliente;
const int httpPort = 8000;
if (!cliente.connect(host, httpPort)) {
Serial.println("esp -> Cliente no conectado");
return;
}
String url = "/data";
// read the data from serial
for (int i = 0; i < 4; i++){
leer_data();
}
limpiar_data();
String data = "temperatura=" + temperatura;
Serial.print("esp -> Enviando POST: ");
// Enviamos el request al servidor:
cliente.println("POST " + url + " HTTP/1.1");
cliente.println("Host: " + String(host));
cliente.println("Accept: */*");
cliente.println("Content-Type: application/x-www-form-urlencoded");
cliente.print("Content-Length: ");
cliente.println(data.length());
cliente.println();
cliente.print(data);
delay(500); // Totalmente aleatoreo :) cambiar a conveniencia
if (client.connected()) {
client.stop(); // DESCONECTAR DEL SERVIDOR
}
Serial.println("esp -> ");
Serial.println("esp -> cerrando conexión");
delay(5000);
}
void leer_data(){
String var = Serial.readStringUntil('=');
String valor = Serial.readStringUntil('\t');
if (var == "TEMP"){
temperatura = valor;
}
}
void limpiar_data(){
// clear remnant of current data line
Serial.readStringUntil('\n');
}Este código le permite al modulo conectarse a una red WiFi existente y enviar los datos recibidos del arduino sobre comunicación serial a un servidor de internet, o bien a su red local.
Lo siguiente, es subir el código al arduino para establecer la comunicación entre el modulo WiFi y el arduino.
#include <SoftwareSerial.h>
SoftwareSerial espSerial(10, 9); // RX, TX
// Sensor
int temp_sensor = A0;
// Valores del sensor
float temperatura = 0; // lm35 lecturas de temperatura
// datos seriales
String esp_output;
void setup() {
// inicializar el puerto serial
Serial.begin(115200);
espSerial.begin(9600);
}
void loop() {
// revisar la lectura del sensor cada un segundo
if (millis()%1000 == 0){
temperatura = obtener_temp(temp_sensor);
esp_output = espSerial.readStringUntil('\n');
// enviar data al modulo
evniar_data();
// imprimir el resultado del modulo WiFi
Serial.println(esp_output);
}
}
void evniar_data(){
// send data to the cloud
espSerial.print("TEMP=");
espSerial.print(temperatura);
espSerial.print('\t');
}
float obtener_temp(int sensorPin){
float temp = analogRead(sensorPin);
temp = (temp*5000.0)/1024;
return temp;
}Finalmente, conectamos el modulo WiFi al arduino (diagrama abajo) para establecer comunicación a través del puerto serial.
El software serial nos permite usar PWM (pulse with modulation) en los pins seriales del arduino.
Después de realizar estos pasos, ahora podemos ver como nuestro nuevo dispositivo IoT entra en acción. Podemos poner un servidor en una red local y hacer una pequeña aplicación web que guarde todos los requests que el arduino hace como histórico de temperatura y temperatura en tiempo real.