Registro de temperatura, umidade e ponto de orvalho com impedância elétrica
O Electric Imp é um dispositivo incrível para IoT e sua integração com Ubidots torna muito simples a criação de gráficos e alertas por SMS/e-mail em poucos minutos. Neste tutorial do Electric Imp, você aprenderá a usar a placa de breakout do Electric Imp com um sensor DHT11 para medir a temperatura e a umidade relativa e, em seguida, calcular o ponto de orvalho usando o mecanismo matemático do Ubidots
O ponto de orvalho pode ser usado como um índice da percepção humana de conforto em relação ao clima; um ponto de orvalho entre 13-16°C (55-59°F) proporciona uma sensação de conforto, enquanto um ponto de orvalho acima de 21°C (70°F) causa uma sensação de calor excessivo, pois o ar estaria muito úmido e o corpo não conseguiria se resfriar
| Ponto de orvalho | Percepção humana |
| 24-26°C / 75-80°F | Extremamente desconfortável, opressivo |
| 21-24°C / 0-74°F | Muito úmido, bastante desconfortável |
| 18-21°C / 65-69°F | Um tanto desconfortável para a maioria das pessoas na edge superior |
| 16-18°C / 60-64°F | Para a maioria, está bom, mas todos percebem a umidade na edge superior |
| 13-16°C / 55-59°F | Confortável |
| 10-12°C / 50-54°F | Muito confortável |
| Abaixo de 10°C / 50-54°F | Muito confortável |
| Abaixo de 10°C / Abaixo de 50°F | Um pouco seco |
| Abaixo de 10°C / Abaixo de 50°F | Felizmente, existe uma função linear para calcular o ponto de orvalho com base na temperatura e na umidade relativa. |
Materiais
- Um duende
- Uma placa de breakout Electric Imp
- Três fios fêmea-fêmea
- resistor de 10k
- Sensor de umidade e temperatura DHT11
Fiação
Veja como o sensor DHT11 é conectado à sua placa Electric Imp:
Código
Hora de programar! Ao trabalhar com o Electric Imp, você precisará de duas seções de código: uma para o dispositivo e outra para o agente. Aqui está o código do dispositivo (um pouco longo, pois inclui a classe para lidar com o DHT11):
const SPICLK = 937.5; // Classe para ler o sensor de temperatura/umidade DHT11 // Esses sensores usam um protocolo proprietário de um fio. O imp // emula esse protocolo com SPI. // Para usar: // - conecte MOSI a MISO com um resistor de 10k // - conecte MISO à linha de dados do sensor class DHT11 { static STARTTIME_LOW = 0.001000; // 1 ms de tempo baixo para iniciar static STARTTIME_HIGH = 0.000020; // 20 us min de tempo alto para iniciar static STARTTIME_SENSOR = 0.000080; // 80 us baixo / 80 us alto "ACK" do sensor no START static MARKTIME = 0.000050; // Pulso baixo de 50 us entre as marcas 0 ou 1 static ZERO = 0.000026; // 26 us em nível alto para "0" static ONE = 0.000075; // 70 us em nível alto para "1" spi = null; clkspeed = null; bittime = null; bytetime = null; start_low_bits = null; start_low_bytes = null; start_high_bits = null; start_high_bytes = null; start_ack_bits = null; start_ack_bytes = null; mark_bits = null; mark_bytes = null; zero_bits = null; zero_bytes = null; one_bits = null; one_bytes = null; // construtor da classe // Entrada: // _spi: um periférico SPI pré-configurado (ex: spi257) // _clkspeed: a velocidade na qual o SPI foi configurado para operar // Retorno: (Nenhum) constructor(_spi, _clkspeed) { this.spi = _spi; this.clkspeed = _clkspeed; tempo_de_bit = 1,0 / (velocidade_do_clk * 1000); tempo_de_byte = 8,0 * tempo_de_bit; bits_iniciais_baixos = TEMPO_INICIAL_BAIXO / tempo_de_bit; bytes_iniciais_baixos = (bits_iniciais_baixos / 8); bits_iniciais_altos = TEMPO_INICIAL_ALTO / tempo_de_bit; bytes_iniciais_altos = (bits_iniciais_altos / 8); bits_iniciais_de_reconhecimento = TEMPO_INICIAL_SENSOR / tempo_de_bit; bytes_iniciais_de_reconhecimento = (bits_iniciais_de_reconhecimento / 8); bits_de_marcação = TEMPO_DE_MARCAÇÃO / tempo_de_bit; bytes_de_marcação = (bits_de_marcação / 8); bits_zero = ZERO / tempo_de_bit; bytes_zero = (bits_zero / 8); bits_um = UM / tempo_de_bit; bytes_um = (bits_um / 8); } // função auxiliar // dado um blob longo, encontra os tempos entre transições e os converte em // valores de temperatura e umidade. Assume um valor de retorno de 40 bits (16 para umidade / 16 para temperatura / 8 para checksum) // Entrada: // hexblob (blob de comprimento arbitrário) // Retorno: // tabela contendo: // "rh": umidade relativa (float) // "temp": temperatura em Celsius (float) // se a leitura falhar, rh e temp retornarão 0 function parse(hexblob) { local laststate = 0; local lastbitidx = 0; local gotack = false; local rawidx = 0; local result = blob(5); // Umidade de 2 bytes, temperatura de 2 bytes, checksum de 1 byte local humid = 0; local temp = 0; // itera por cada bit de cada byte do sinal retornado para (local byte = 0; byte < hexblob.len(); byte++) { para (local bit = 7; bit >= 0; bit--) { local thisbit = (hexblob[byte] & (0x01 << bit)) ? 1:0; se (thisbit != laststate) { se (thisbit) { // transição de baixo para alto; observa por quanto tempo fica em nível alto laststate = 1; lastbitidx = (8 * byte) + (7 - bit); } senão { // transição de alto para baixo; laststate = 0; local idx = (8 * byte) + (7 - bit); local hightime = (idx - lastbitidx) * bittime; // agora temos um bit de informação válido. Descobrimos qual símbolo é. local resultbyte = (rawidx / 8); local resultbit = 7 - (rawidx % 8); //server.log(format("bit %d do byte %d",resultbit, resultbyte)); if (hightime < ZERO) { // isto é um zero if (gotack) { // não registre nenhum dado antes do ACK ser visto result[resultbyte] = result[resultbyte] & ~(0x01 << resultbit); rawidx++; } } else if (hightime < ONE) { // isto é um um if (gotack) { result[resultbyte] = result[resultbyte] | (0x01 << resultbit); rawidx++; } } else { // isto é um ACK de INÍCIO gotack = true; } } } } } //server.log(format("analisado: 0x %02x%02x %02x%02x %02x",result[0],result[1],result[2],result[3],result[4])); úmido = (resultado[0] * 1.0) + (resultado[1] / 1000.0); se (resultado[2] & 0x80) { // temperatura negativa resultado[2] = ((~resultado[2]) + 1) & 0xff; } temp = (resultado[2] * 1.0) + (resultado[3] / 1000.0); se (((resultado[0] + resultado[1] + resultado[2] + resultado[3]) & 0xff) != resultado[4]) { return {"rh":0,"temp":0}; } senão { return {"rh":úmido,"temp":temp}; } } // ler o sensor // Entrada: (nenhuma) // Retorno: // tabela contendo: // "rh": umidade relativa (float) // "temp": temperatura em Celsius (float) // se a leitura falhar, rh e temp retornarão 0 function read() { local bloblen = start_low_bytes + start_high_bytes + (40 * (mark_bytes + one_bytes)); local startblob = 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())); local result = spi.writeread(startblob); return parse(result); } } rele <- hardware.pin9; spi <- hardware.spi257; while(1){ clkspeed <- spi.configure(MSB_FIRST, SPICLK); dht11 <- DHT11(spi, clkspeed); data <- dht11.read(); server.log(format("Umidade Relativa: %0.1f",data.rh)+" %"); server.log(format("Temperatura: %0.1f C",data.temp)); agent.send("temp",data.temp); imp.sleep(1); }
Agradecemos a Thomas Byrne por disponibilizar a classe para lidar com o sensor DHT11 no Github .
Como você pode ver, o código do agente é bem simples, basta não se esquecer de inserir seu próprio token de autenticação e ID da variável na chamada HTTP:
device.on("temp", function(value) { server.log("Tentando enviar o valor para a Ubi:"); server.log(value); local headers = { "Content-Type": "application/json", "X-Auth-Token": "NBbF3PWPxWc2IaO40aXOKnhIu8tOv92rYN3ibiEc7Jh6GV3KZUUCHtXuNz7Y" }; // Substitua o token pelo seu local url = "ubidots"; // Substitua o ID da variável pelo seu local string = {"value": value}; local request = http.post(url, headers, http.jsonencode(string)); local response = request.sendsync(); });
Criar uma variável sintética no Ubidots.
Assim como você adicionaria uma nova variável, vá em “Fontes” –> “Electric Imp (nome da sua fonte de dados)” –> “Adicionar nova variável”:
Agora insira esta equação para calcular o valor do ponto de orvalho:
Deverá ficar assim:
Agora você deverá começar a ver os dados de ponto de orvalho sendo atualizados sempre que seu Imp enviar dados de temperatura e umidade para Ubidots!
Concluindo
Neste projeto, conseguimos conectar um Imp ao Ubidots, medindo e calculando variáveis físicas para melhor compreender o ambiente ao nosso redor. Você pode explorar outras funcionalidades, como criar alertas quando o ponto de orvalho estiver muito alto ou criar gráficos compartilháveis como os do início deste artigo.
Não se esqueça de conferir algumas das nossas publicações mais recentes:
Se você é novo no Ubidots , clique aqui para começar!
