Registro de temperatura, humedad y punto de rocío con Imp eléctrico
Electric Imp es un dispositivo increíble para IoT y su integración con Ubidots hace que sea muy sencillo crear gráficos y alertas por SMS/correo electrónico en unos minutos. En este tutorial de Electric Imp, le enseñaremos cómo usar la placa de ruptura de Electric Imp con un sensor DHT11 para medir la temperatura y la humedad relativa, y luego calcular el punto de rocío usando el motor matemático de Ubidots
El punto de rocío se puede utilizar como índice de la percepción humana del confort en relación con el clima; un punto de rocío entre 13 y 16°C (55-59°F) te hace sentir cómodo, pero un punto de rocío por encima de 21°C (70°F) te hará sentir demasiado caliente porque el aire tendría demasiada humedad y tu cuerpo no pude enfriarme:
| Punto de rocío | Percepción humana |
| 24-26°C / 75-80°F | Extremadamente incómodo, opresivo. |
| 21-24°C / 0-74°F | Muy húmedo, bastante incómodo. |
| 18-21°C / 65-69°F | Algo incómodo para la mayoría de las personas en el borde superior. |
| 16-18°C / 60-64°F | Está bien para la mayoría, pero todos perciben la humedad en el borde superior. |
| 13-16°C / 55-59°F | Cómodo |
| 10-12°C / 50-54°F | Muy comodo |
| Menos de 10°C / 50-54°F | Muy comodo |
| Menos de 10°C / Menos de 50°F | un poco seco |
| Menos de 10°C / Menos de 50°F | Afortunadamente, existe una función lineal para calcular el punto de rocío en función de la temperatura y la humedad relativa. |
Materiales
- Un diablillo
- Una placa de ruptura de diablillo eléctrico
- Tres cables hembra a hembra
- resistencia de 10k
- Sensor de humedad y temperatura DHT11
Alambrado
Así es como se conecta el sensor DHT11 a su placa Electric Imp:
Código
¡Es hora de codificar! Cuando trabajes con Electric imp, necesitarás dos secciones de código: una para el dispositivo y otra para el agente. Aquí está el código del dispositivo (un poco largo ya que tiene la clase para manejar el DHT11):
constante SPICLK = 937,5; // Clase para leer el sensor de temperatura/humedad DHT11 // Estos sensores utilizan un protocolo propietario de un solo cable. El imp // emula este protocolo con SPI. // Para usar: // - vincula MOSI a MISO con una resistencia de 10k // - vincula MISO a la línea de datos en el sensor clase DHT11 { static STARTTIME_LOW = 0.001000; // 1 ms de tiempo bajo para inicio estático STARTTIME_HIGH = 0.000020; // 20 us min tiempo máximo para inicio estático STARTTIME_SENSOR = 0.000080; // 80 us bajo / 80 us alto "ACK" del sensor en INICIO static MARKTIME = 0.000050; // 50 us pulso bajo entre 0 o 1 marcas static ZERO = 0.000026; // 26 us alto para "0" estático UNO = 0.000075; // 70 us alto para "1" spi = null; clkspeed = nulo; tiempo de bits = nulo; bytetime = nulo; start_low_bits = nulo; start_low_bytes = nulo; start_high_bits = nulo; start_high_bytes = nulo; start_ack_bits = nulo; start_ack_bytes = nulo; mark_bits = nulo; marca_bytes = nulo; cero_bits = nulo; cero_bytes = nulo; uno_bits = nulo; one_bytes = nulo; // constructor de clase // Entrada: // _spi: un periférico SPI preconfigurado (por ejemplo, spi257) // _clkspeed: la velocidad a la que se ha configurado el SPI para ejecutarse // Retorno: (Ninguno) constructor(_spi, _clkspeed) { this.spi = _spi; this.clkspeed = _clkspeed; tiempo de bits = 1,0 / (velocidad de clk * 1000); tiempo de bytes = 8,0 * tiempo de bits; start_low_bits = STARTTIME_LOW / bittime; inicio_low_bytes = (inicio_low_bits / 8); start_high_bits = STARTTIME_HIGH / bittime; inicio_alto_bytes = (inicio_alto_bits / 8); start_ack_bits = STARTTIME_SENSOR / bittime; start_ack_bytes = (start_ack_bits / 8); mark_bits = MARKTIME / bittime; marca_bytes = (marca_bits / 8); zero_bits = CERO / bittime; cero_bytes = (cero_bits / 8); one_bits = UNO / bittime; un_bytes = (un_bits / 8); } // función auxiliar // dado un blob largo, encontrar tiempos entre transiciones y analizar // valores de temperatura y humedad. Asume un valor de retorno de 40 bits (16 humedad / 16 temperatura / 8 suma de comprobación) // Entrada: // hexblob (blob de longitud arbitraria) // Retorno: // tabla que contiene: // "rh": humedad relativa (flotante) / / "temp": temperatura en grados centígrados (flotante) // si la lectura falla, rh y temp devolverán 0 function parse(hexblob) { local laststate = 0; último bitidx local = 0; gotack local = falso; rawidx local = 0; resultado local = blob(5); // Humedad de 2 bytes, temperatura de 2 bytes, suma de comprobación de 1 byte humedad local = 0; temperatura local = 0; // iterar a través de cada bit de cada byte de la señal devuelta for (byte local = 0; byte < hexblob.len(); byte++) { for (bit local = 7; bit >= 0; bit--) { thisbit local = (blob hexadecimal [byte] & (0x01 << bit))? 1:0; if (thisbit! = laststate) { if (thisbit) { // transición de bajo a alto; observe cuánto tiempo permanece alto laststate = 1; últimobitidx = (8 * byte) + (7 - bit); } else { // transición de alto a bajo; último estado = 0; idx local = (8 * byte) + (7 - bit); hora alta local = (idx - lastbitidx) * bittime; // ahora tenemos un poco de información válida. Averigua qué símbolo es. byte de resultado local = (rawidx / 8); bit de resultado local = 7 - (rawidx % 8); //server.log(format("bit %d del byte %d",resultbit, resultbyte)); if (hightime < ZERO) { // esto es un cero if (gotack) { // no registre ningún dato antes de que se vea el ACK resultado[resultbyte] = resultado[resultbyte] & ~(0x01 << resultbit); rawidx++; } } else if (hightime < UNO) { // este es un if (gotack) { resultado[resultbyte] = resultado[resultbyte] | (0x01 << bit de resultado); rawidx++; } } else { // este es un INICIO ACK gotack = true; } } } } } //server.log(format("parsed: 0x %02x%02x %02x%02x %02x",resultado[0],resultado[1],resultado[2],resultado[3],resultado [4])); húmedo = (resultado[0] * 1.0) + (resultado[1] / 1000.0); if (resultado[2] & 0x80) { // resultado de temperatura negativa[2] = ((~resultado[2]) + 1) & 0xff; } temp = (resultado[2] * 1.0) + (resultado[3] / 1000.0); if (((resultado[0] + resultado[1] + resultado[2] + resultado[3]) & 0xff) != resultado[4]) { return {"rh":0,"temp":0}; } else { return {"rh":húmedo,"temp":temp}; } } // lee el sensor // Entrada: (ninguna) // Retorno: // tabla que contiene: // "rh": humedad relativa (flotación) // "temp": temperatura en grados centígrados (flotación) // si se lee falla, rh y temp devolverán 0 function read() { local bloblen = start_low_bytes + start_high_bytes + (40 * (mark_bytes + one_bytes)); startblob local = blob(bloblen); for (local i = 0; i < start_low_bytes; i++) { startblob.writen(0x00,'b'); } for (local j = start_low_bytes; j < bloblen; j++) { startblob.writen(0xff,'b'); } //server.log(format("Enviando %d bytes", startblob.len())); resultado local = spi.writeread(startblob); devolver análisis (resultado); } } rele <- hardware.pin9; spi <-hardware.spi257; while(1){ clkspeed <- spi.configure(MSB_FIRST, SPICLK); dht11 <- DHT11(spi, clkspeed); datos <- dht11.read(); server.log(format("Humedad relativa: %0.1f",data.rh)+" %"); server.log(format("Temperatura: %0.1f C",data.temp)); agente.enviar("temp",datos.temp); diablillo.dormir(1); }
Gracias a Thomas Byrne por brindar la clase para manejar el sensor DHT11 en Github .
Como puedes ver, el código del Agente es realmente simple, pero no olvides poner tu propio token de autenticación y ID de variable en la llamada HTTP:
device.on("temp", function(value) { server.log("Intentando publicar en Ubi el valor:"); server.log(value); encabezados locales = { "Content-Type": "application/json ", "X-Auth-Token": "NBbF3PWPxWc2IaO40aXOKnhIu8tOv92rYN3ibiEc7Jh6GV3KZUUCHtXuNz7Y" }; // Reemplace el token con el suyo local url = "http: ubidots .com/api/v1.6/variables/53d2beb37625424630223dac/values" // Reemplace el ID de variable con el suyo local string = {"value ": valor}; solicitud local = http.post(url, encabezados, http.jsonencode(cadena)); respuesta local = request.sendsync(); });
Crea una variable sintética en Ubidots .
Del mismo modo que agregaría una nueva variable, vaya a “Fuentes”–> “Electric Imp (el nombre de su fuente de datos)”–>”Agregar nueva variable”:
Ahora ingrese esta ecuación para calcular el valor del punto de rocío:
Así es como debería verse:
¡Ahora deberías comenzar a ver que los datos del punto de rocío se actualizan cada vez que tu diablillo envía datos de temperatura y humedad a Ubidots !
Concluyendo
En este proyecto pudimos conectar un diablillo a Ubidots , midiendo y calculando variables físicas para comprender mejor nuestro entorno. Puede explorar más cosas, como crear alertas cuando el punto de rocío sea demasiado alto o crear gráficos para compartir como los que se encuentran al principio de este artículo.
No olvides revisar algunas de nuestras últimas publicaciones:
Si eres nuevo en Ubidots , ¡haz clic aquí para comenzar!
