Os sistemas de monitoramento meteorológico são usados para monitorar as condições climáticas em constante mudança. Os dados coletados por esses dispositivos são usados para prever o tempo e também para manter um registro das mudanças ambientais em um local. Esses dados são extremamente úteis no estudo da Terra e na análise das mudanças nas condições climáticas e ambientais de um local. Além disso, os dados e análises assim recolhidos podem ser utilizados numa variedade de aplicações, como agricultura, geologia, mineração e previsão meteorológica. Neste projeto, é projetado um sistema simples de monitoramento meteorológico que pode monitorar a temperatura e a umidade de um local.
O sistema de monitoramento climático projetado neste projeto é um dispositivo IOT construído no Particle Photon. O Particle Photon é uma placa IOT compatível com Arduino. Para escrever o código do programa para qualquer Photon, o desenvolvedor precisa criar uma conta no site do Particle e registrar a placa Photon com sua conta de usuário. O código do programa pode então ser escrito no Web IDE no site do Particle e transferido para uma placa IOT registrada pela internet. Se a placa Particle selecionada, Photon aqui, for ligada e conectada ao serviço de nuvem do Particle, o código é gravado na placa selecionada pelo ar via conexão de internet e a placa começa a operar de acordo com o código transferido.
No projeto, o Particle Photon faz interface com o sensor de temperatura e umidade DHT-11. A temperatura e a umidade medidas pelo sensor têm seus valores exibidos em uma tela LCD montada no aparelho. A placa permanece conectada a um servidor remoto via conexão Wi-Fi e continua enviando os dados do sensor para o serviço de nuvem. O aplicativo Blynk é usado para monitorar dados do serviço em nuvem, para que os dados em tempo real possam ser acessados a partir de qualquer smartphone compatível com Android ou IOS.
Blynk é um aplicativo móvel para Internet das Coisas que pode funcionar com uma variedade de placas IOT como Arduino, Raspberry Pi, ESP8266, SparkFun e outras. Para conectar o aplicativo a uma placa IOT, o usuário precisa obter um Authorization Token (Auth Token). Primeiramente, o usuário precisa baixar o aplicativo Blynk para Android ou IOS e instalá-lo em um smartphone. O usuário agora deve criar uma nova conta e criar um novo projeto. Durante a criação do projeto, a placa IOT (neste caso Particle Photon) e o tipo de conexão (neste caso Wi-Fi) precisam ser selecionados. Ao criar um novo projeto, o Auth Token é enviado para o e-mail cadastrado do usuário. Para codificar a placa alvo, a biblioteca Blynk deve ser baixada do site oficial do Blynk e os arquivos da biblioteca devem ser adicionados à pasta Sketchbook do Arduino IDE. Agora a placa de destino pode ser codificada especificando seu token de autenticação no Arduino Sketch.
Figura 1: Protótipo de sistema de monitoramento meteorológico IOT baseado em partículas fotônicas e Blynk
Componentes necessários –
Fig. 2: Lista de componentes necessários para o sistema de monitoramento meteorológico IOT baseado em Particle Photon e Blynk
Diagrama de bloco –
Fig. 3: Diagrama de blocos do sistema de monitoramento meteorológico IOT baseado em partículas fotônicas e Blynk
Conexões de Circuito –
O dispositivo de monitoramento meteorológico é construído em Particle Photon. O dispositivo é montado interligando o Sensor de Temperatura e Umidade DHT 11 e um LCD de 16X2 caracteres com a placa IOT. O circuito montado possui as seguintes conexões de circuito –
Fig. 4: Imagem do sistema de monitoramento meteorológico IOT baseado em Particle Photon e Blynk
Particle Photon – Photon é uma placa IOT popular disponível na plataforma Particle. A placa abriga o microcontrolador STM32F205 120Mhz ARM Cortex M3 e possui 1 MB de memória flash, 128 Kb de RAM e 18 pinos de saída de entrada de uso geral (GPIO) de sinal misto com periféricos avançados. O módulo possui chip Wi-Fi Cypress BCM43362 integrado para conectividade Wi-Fi e banda única 2,4 GHz IEEE 802.11b/g/n para Bluetooth. A placa vem equipada com 2 SPI, um I2S, um I2C, um CAN e uma interface USB. A partícula Photon tem a seguinte configuração de pinos –
Fig. 5: Tabela listando a configuração dos pinos do Particle Photon
Fig. 6: Tabela listando a configuração dos pinos do Particle Photon
Deve-se observar que 3V3 é uma saída filtrada utilizada para sensores analógicos. Este pino é a saída do regulador integrado e está conectado internamente ao VDD do módulo Wi-Fi. Ao alimentar o Photon via VIN ou porta USB, este pino produzirá uma tensão de 3,3 V DC. Este pino também pode ser usado para alimentar o Photon diretamente (entrada máxima de 3,3 V DC). Quando usado como saída, a carga máxima em 3V3 é 100 mA. Os sinais PWM têm resolução de 8 bits e funcionam na frequência de 500 Hz. No circuito, 6 pinos GPIO do módulo são usados para fazer a interface com o LCD de caracteres e um pino é usado para fazer a interface com o sensor de temperatura e umidade DHT-11.
LCD 16X2: O display LCD 16X2 é usado para exibir os valores de temperatura e umidade medidos. Ele é conectado ao Particle Photon conectando seus pinos de dados D7 a D4 aos pinos D0 a D3 do painel de partículas. Os pinos E e RS do LCD são conectados aos pinos D5 e D6 do painel de partículas, respectivamente. O pino RW do LCD está aterrado.
Fig. 7: Tabela listando as conexões do circuito entre o Character LCD e o Arduino UNO
Sensor de temperatura e umidade DHT-11 – O sensor DHT-11 lê a temperatura e umidade ambiente e retransmite os dados para o microcontrolador como dados digitais. O pino de dados do sensor de temperatura e umidade DHT11 está conectado ao pino D4 do Particle Photon. Os pinos VCC e terra do sensor são conectados ao VCC comum e ao terra.
Fonte de alimentação – No circuito, os módulos de partículas fótons e sensores precisam de uma corrente contínua regulada de 5 V para seu funcionamento. A rede CA é usada como fonte primária de energia. A alimentação da rede elétrica é reduzida por um transformador e retificada por um retificador de ponte completa. A saída retificada é regulada para 5V e 12V usando CIs 7805 e 7812. O pino 1 de ambos os CIs reguladores de tensão está conectado ao ânodo da bateria e o pino 2 de ambos os CIs está conectado ao terra. As respectivas saídas de tensão são extraídas do pino 3 dos respectivos CIs reguladores de tensão. Um LED junto com um resistor pull-up de 10K Ω também é conectado entre o terra comum e o pino de saída para obter uma dica visual da continuidade da alimentação.
Como funciona o circuito –
Após a montagem do circuito, o código do programa pode ser carregado no painel de partículas usando o Arduino IDE. Os arquivos da biblioteca do App Blynk devem ser incluídos na pasta sketchbook do Arduino para gerar o código que pode se conectar ao App Blynk. O código para o quadro alvo (Particle Photon neste caso) deve ter o modelo de código mencionado no esboço de exemplo abaixo –
Exemplo de esboço de partícula fóton para aplicativo Blynk
O modelo de código fornecido no link acima adiciona a biblioteca Blynk ao Particle Photon expondo as variáveis à nuvem Blynk. O novo código deve ser atualizado para o novo kit de desenvolvimento. O Photon deve estar conectado a um Hotspot de Internet via Wi-Fi. O código do programa do fóton pode ser transferido para a placa pelo ar. À medida que o código é transferido para a placa, ela passa a operar de acordo com ele.
O Sensor de Temperatura e Umidade DHT11 é um sensor digital com sensor de umidade capacitivo embutido e termistor. Ele transmite uma leitura de temperatura e umidade em tempo real a cada 2 segundos. O sensor opera com alimentação de 3,5 a 5,5 V e pode ler temperatura entre 0° C e 50° C e umidade relativa entre 20% e 95%. O DHT11 detecta vapores de água medindo a resistência elétrica entre os dois eletrodos. O componente sensor de umidade é um substrato que retém a umidade com eletrodos aplicados na superfície. Quando os vapores de água são absorvidos pelo substrato, os íons são liberados pelo substrato, o que aumenta a condutividade entre os eletrodos. A mudança na resistência entre os dois eletrodos é proporcional à umidade relativa. Uma umidade relativa mais alta diminui a resistência entre os eletrodos, enquanto uma umidade relativa mais baixa aumenta a resistência entre os eletrodos. O DHT11 mede a temperatura com um sensor de temperatura NTC montado na superfície (termistor) embutido na unidade.
O Sensor DHT 11 envia dados em formato digital para o pino do controlador no protocolo one-wire que deve ser implementado no lado do firmware. Primeiro, o pino de dados é configurado para entrada e um sinal de início é enviado a ele. O sinal de início compreende um BAIXO por 18 milissegundos seguido por um ALTO por 20 a 40 microssegundos seguido por um BAIXO novamente por 80 microssegundos e um ALTO por 80 microssegundos. Após enviar o sinal de início, o pino é configurado para saída digital e os dados de 40 bits compostos pela leitura de temperatura e umidade são bloqueados. Dos dados de 5 bytes, os dois primeiros bytes são a parte inteira e decimal da leitura da umidade relativa, respectivamente, o terceiro e o quarto bytes são a parte inteira e decimal da leitura da temperatura e o último é o byte da soma de verificação. O protocolo one-wire é implementado no firmware usando uma biblioteca de código aberto disponível para Photon.
A temperatura e umidade medidas através do sensor DHT 11 são exibidas no LCD de caracteres e enviadas para o Blynk Cloud através de conexão Wi-Fi. O projeto usa o painel do Blynk App para exibir temperatura e umidade. O aplicativo emula a placa de prototipagem do Smartphone onde botões, controles deslizantes, displays, gráficos e outros widgets funcionais podem ser arrastados e soltos. Em questão de minutos, esses widgets podem controlar e obter dados de placas de prototipagem como Arduino, Raspberry Pi e, neste caso, Particle Photon. No aplicativo desenvolvido para o projeto, existem dois widgets de medidores utilizados para exibir o valor de temperatura e umidade. Para saber mais sobre como usar o aplicativo Blynk, confira o seguinte documento no site do Blynk –
Primeiros passos com Blynk
Fig. 8: Captura de tela móvel da interface do usuário do aplicativo Blynk para sistema de monitoramento meteorológico IOT baseado em Particle Photon
Os dados são exibidos no aplicativo em tempo real e são atualizados a cada 2 segundos. Confira o código do programa para saber como o Photon lê a temperatura e a umidade do sensor DHT-11 e envia-o para o aplicativo Blynk.
Guia de programação –
Primeiro de tudo, a biblioteca do sensor DHT e da biblioteca LiquidCrystal é importada. A biblioteca é adicionada automaticamente pelo Web IDE da partícula. Uma constante é definida para denotar o pino ao qual o sensor DHT 11 está conectado e uma constante é definida para denotar a variante do sensor DHT. Um objeto do tipo LCD é instanciado e mapeado nos pinos que conectam o LCD ao painel de partículas. Uma função dht_wrapper é declarada e chamada na instanciação do objeto DHT. Algumas variáveis para manter o tempo de amostragem para o sensor DHT e o valor do contador são declaradas. Uma matriz de caracteres é declarada para conter os dados do sensor a serem enviados para a página da web. Outra matriz de caracteres contendo o token de autenticação é definida. O token de autenticação enviado ao e-mail do usuário deve ser armazenado nesta matriz de caracteres.
Fig. 9: Captura de tela do código C incorporado usado no Particle Photon para o sistema de monitoramento meteorológico IoT
A função setup é chamada e a taxa de transmissão para comunicação serial com o hotspot de Internet é definida como 9600 baud por segundo. O objeto LCD é inicializado chamando o método Begin no objeto LCD onde o objeto LCD é inicializado para exibição 16X2. Algumas mensagens iniciais são exibidas no LCD e o tempo de amostragem DHT é definido como 0 para a primeira amostra. Uma variável é exposta à partícula usando o método variável e uma string é enviada para a nuvem usando o método Publish . O aplicativo Blynk é inicializado usando o método Begin no objeto Blynk, onde a variável que carrega o token de autenticação é passada como parâmetro. Dentro da função dht_wrapper , o método isrCallback é chamado no objeto DHT que executa a rotina de serviço de interrupção para o objeto.
Fig. 10: Captura de tela da função de configuração no código C incorporado usado no Particle Photon para o sistema de monitoramento meteorológico IoT
A função loop é chamada e itera infinitamente. Na função loop , o método run é chamado no objeto Blynk. Esta função é chamada para processar os comandos recebidos e gerenciar a conexão do Blynk. Ao chamar a função Millis , é verificado se a placa já iniciou a execução do código e, caso tenha feito isso, os dados de amostra do sensor DHT são coletados usando o método adquirir no objeto DHT. Se a placa já adquiriu dados do sensor, os dados do sensor DHT são obtidos usando os métodos getCelcius e getHumidity no objeto dht. Os dados são armazenados em variáveis, agrupados em strings adequadas e enviados para a URL de registro de dados usando o métodopublish no objeto Particle. A função Blynk.virtualwire é usada para transferir os dados para a nuvem Blynk e exibidos no painel do aplicativo Android. A variável counter é incrementada para cada coleta de amostra.
Fig. 11: Captura de tela da função Loop no código C incorporado usado no Particle Photon para o sistema de monitoramento meteorológico IoT
Confira o código completo na seção de código. Pegue um painel de partículas e os outros componentes, monte o circuito e comece a codificar. Este projeto IOT vai ser realmente divertido.
//Program to
// This #include statement was automatically added by the Particle IDE.
#include
// This #include statement was automatically added by the Particle IDE.
#include
#define BLYNK_PRINT Serial // Set serial output for debug prints
//#define BLYNK_DEBUG // Uncomment this to see detailed prints
#include
#define DHTTYPE DHT11
#define DHTPIN 4
#define DHT_SAMPLE_INTERVAL 60000
LiquidCrystal lcd(6, 5, 0, 1, 2, 3);
void dht_wrapper ; // must be declared before the lib initialization
// Lib instantiate
PietteTech_DHT DHT(DHTPIN, DHTTYPE, dht_wrapper);
// globals
unsigned int DHTnextSampleTime; // Next time we want to start sample
bool bDHTstarted; // flag to indicate we started acquisition
int n; // counter
//this is coming from
char resultstr(64); //String to store the sensor data
// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth = "0395c08357fd480ba67b172ccdfa7039";
// Attach a Button widget (mode: Switch) to the Digital pin 7 - and control the built-in blue led.
// Attach a Graph widget to Analog pin 1
// Attach a Gauge widget to Analog pin 2
char VERSION(64) = "0.04";
void setup
{
Serial.begin(9600);
lcd.begin(16,2);
lcd.setCursor(0,0);
lcd.print("IoT Weather");
lcd.setCursor(0,1);
lcd.print(" Monitoring ");
delay(2000);
lcd.clear ;
lcd.setCursor(0,0);
lcd.print("ENGINEERS GARAGE");
delay(2000);
lcd.clear ;
delay(5000); // Allow board to settle
DHTnextSampleTime = 0; // Start the first sample immediately
Particle.variable("result", resultstr, STRING);
Particle.publish("DHT11 - firmware version", VERSION, 60, PRIVATE);
Blynk.begin(auth);
}
void dht_wrapper
{
DHT.isrCallback ;
}
void loop
{
Blynk.run ;
if (millis > DHTnextSampleTime) {
if (!bDHTstarted) { // start the sample
DHT.acquire ;
bDHTstarted = true;
}
if (!DHT.acquiring ) { // has sample completed?
float temp = (float)DHT.getCelsius ;
int temp1 = (temp - (int)temp) * 100;
lcd.clear ;
lcd.setCursor(0,0);
lcd.print("T:");
lcd.print((int)temp1);
lcd.write(1);
lcd.print("C");
char tempInChar(32);
sprintf(tempInChar,"%0d.%d", (int)temp, temp1);
Particle.publish("The temperature from the dht11 is:", tempInChar, 60, PRIVATE);
//virtual pin 1 will be the temperature
Blynk.virtualWrite(V1, tempInChar);
//google docs can get this variable
sprintf(resultstr, "{"t":%s}", tempInChar);
float humid = (float)DHT.getHumidity ;
int humid1 = (humid - (int)humid) * 100;
lcd.clear ;
lcd.setCursor(0,0);
lcd.print("Humidty:");
lcd.print((int)humid1);
sprintf(tempInChar,"%0d.%d", (int)humid, humid1);
Particle.publish("The humidity from the dht11 is:", tempInChar, 60, PRIVATE);
//virtual pin 2 will be the humidity
Blynk.virtualWrite(V2, tempInChar);
n++; // increment counter
bDHTstarted = false; // reset the sample flag so we can take another
DHTnextSampleTime = millis + DHT_SAMPLE_INTERVAL; // set the time for next sample
}
}
delay(2000);
}