Registrando temperatura, umidade e ponto de orvalho com Imp elétrico

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, ensinaremos como usar a placa de interrupção do Electric Imp com um sensor DHT11 para medir temperatura e umidade relativa e, em seguida, calcular o ponto de orvalho usando o mecanismo matemático da Ubidots

O Ponto de Orvalho pode ser utilizado como índice de percepção humana de conforto em relação ao clima; um ponto de orvalho entre 13-16°C (55-59°F) faz você se sentir confortável, mas um ponto de orvalho acima de 21°C (70°F) fará você se sentir muito quente porque o ar teria muita umidade e seu corpo não consegui esfriar:

Materiais

• Um diabrete

• Uma placa elétrica de interrupção de Imp

• Três fios fêmea para 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 codificar! ao trabalhar com 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 possui classe para lidar com o DHT11):

const SPICLK = 937,5; // Classe para leitura do sensor de temperatura/umidade DHT11 // Esses sensores utilizam um protocolo proprietário de um fio. O imp // emula este protocolo com SPI. // Para usar: // - vincular o MOSI ao MISO com um resistor de 10k // - vincular o MISO à linha de dados no sensor class DHT11 { static STARTTIME_LOW = 0.001000; // Tempo mínimo de 1 ms para início static STARTTIME_HIGH = 0.000020; // 20 us min de tempo máximo para início static STARTTIME_SENSOR = 0.000080; // 80 us baixo / 80 us alto "ACK" do sensor em START static MARKTIME = 0.000050; // 50 us pulso baixo entre marcas 0 ou 1 static ZERO = 0.000026; // 26 us de altura para "0" static ONE = 0.000075; // 70 us de altura para "1" spi = null; clkspeed = null; bittime = 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; marca_bits = nulo; mark_bytes = nulo; zero_bits = nulo; zero_bytes = nulo; um_bits = nulo; um_bytes = nulo; // construtor de classe // Entrada: // _spi: um periférico SPI pré-configurado (por exemplo, spi257) // _clkspeed: a velocidade em que o SPI foi configurado para rodar // Return: (None) constructor(_spi, _clkspeed) { isto.spi = _spi; this.clkspeed = _clkspeed; bittime = 1,0 / (clkspeed * 1000); bytetime = 8,0 * bittime; start_low_bits = STARTTIME_LOW / bittime; start_low_bytes=(start_low_bits/8); start_high_bits=STARTTIME_HIGH/bittime; start_high_bytes=(start_high_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 = ZERO/bittime; zero_bytes = (zero_bits/8); one_bits = UM/bittime; um_bytes = (um_bits/8); } // função auxiliar // dado um blob longo, encontre os tempos entre as transições e analise // os valores de temperatura e umidade. Assume valor de retorno de 40 bits (16 umidade / 16 temp / 8 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; lastbitidx local = 0; ataque local = falso; rawidx local = 0; resultado local = blob(5); // Umidade de 2 bytes, temperatura de 2 bytes, soma de verificação de 1 byte umidade local = 0; temperatura local = 0; // itera através de cada bit de cada byte do sinal retornado for (local byte = 0; byte < hexblob.len(); byte++) { for (local bit = 7; bit >= 0; bit--) { local thisbit = (hexblob[byte] & (0x01 << bit)) ? 1:0; if (thisbit! = laststate) { if (thisbit) { // transição de baixo para alto; observe para ver quanto tempo fica alto laststate = 1; últimobitidx = (8 * byte) + (7 - bits); } else { // transição de alto para baixo; último estado = 0; idx local = (8 * bytes) + (7 - bits); hora alta local = (idx - lastbitidx) * hora de bit; // agora temos uma informação válida. Descubra que símbolo é esse. byte de resultado local = (rawidx / 8); bit de resultado local = 7 - (rawidx% 8); //server.log(format("bit %d do byte %d",resultbit, resultbyte)); if (hightime <ZERO) { // este é um zero if (gotack) { // não registre nenhum dado antes que o ACK seja visto result[resultbyte] = result[resultbyte] & ~(0x01 << resultbit); rawidx++; } } else if (hightime < ONE) { // este é um if (gotack) { resultado[resultbyte] = resultado[resultbyte] | (0x01 << bit de resultado); rawidx++; } } else { // este é um START ACK gotack = true; } } } } } //server.log(format("analisado: 0x %02x%02x %02x%02x %02x",resultado[0],resultado[1],resultado[2],resultado[3],resultado [4])); úmido = (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":humid,"temp":temp}; } } // lê o sensor // Entrada: (nenhum) // Retorno: // tabela contendo: // "rh": umidade relativa (float) // "temp": temperatura em Celsius (float) // se lido 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())); resultado local = spi.writeread(startblob); retornar análise(resultado); } } rele <- hardware.pin9; spi <-hardware.spi257; while(1){ clkspeed <- spi.configure(MSB_FIRST, SPICLK); dht11 <- DHT11(spi, clkspeed); dados <-dht11.read(); server.log(format("Umidade Relativa: %0.1f",data.rh)+" %"); server.log(format("Temperatura: %0.1f C",data.temp)); agente.send("temp",dados.temp); imp.sleep(1); }

Obrigado a Thomas Byrne por fornecer a aula para lidar com o sensor DHT11 no Github .

Como você pode ver, o código do Agente é muito simples, mas não se esqueça de colocar seu próprio token de autenticação e ID de variável na chamada HTTP:

device.on("temp", function(value) { server.log("Tentando postar o valor no Ubi:"); server.log(value); local headers = { "Content-Type": "application/json ", "X-Auth-Token": "NBbF3PWPxWc2IaO40aXOKnhIu8tOv92rYN3ibiEc7Jh6GV3KZUUCHtXuNz7Y" } // Substitua o token pelo seu local url = "http: ubidots .com/api/v1.6/variables/53d2beb37625424630223dac/values"; // Substitua o ID da variável pelo seu local string = {"value": value}; local request = http.post(url, headers, http.jsonencode( string)); resposta local = request.sendsync() });

Crie uma variável sintética em 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:

É assim que deveria ser:

Agora você deve começar a ver os dados do ponto de orvalho sendo atualizados toda vez que seu Imp envia dados de temperatura e umidade para Ubidots !

Concluindo

Neste projeto conseguimos conectar um Imp ao Ubidots , medindo e calculando variáveis ​​físicas para entender melhor o nosso entorno. Você pode explorar mais coisas, 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 de nossas últimas postagens:

• O poder de educar fazendo
• Construindo um monitor de sistema multiplataforma com Ubidots

Se você é novo no Ubidots , clique aqui para começar!