Comunicação IoT baseada em TCP/IP com plataforma ThingSpeak: IoT Parte 29

No tutorial anterior, foram discutidos recursos, vantagens e limitações do protocolo TCP/IP. Embora o TCP/IP não seja o mais adequado para aplicações IoT devido às sobrecargas de pacotes, ainda sendo a pilha de protocolos mais comum na Internet, oferece conectividade onipresente. Um dispositivo IoT pode ser feito para se comunicar com uma nuvem ou servidor usando o protocolo TCP/IP sem qualquer incômodo de programação e administração de rede. Neste projeto, será projetado um dispositivo IoT que poderá transmitir dados de sensores para a plataforma ThingSpeak usando o protocolo TCP/IP.
O dispositivo IoT projetado neste projeto é construído usando Arduino UNO. O Arduino é apenas uma placa microcontroladora e não pode se conectar sozinho a uma rede de Internet. Para conectividade com a Internet, o Arduino UNO faz interface com o módulo ESP8266. O Módulo Wi-Fi ESP8266 é um SOC independente com pilha de protocolo TCP/IP integrada que pode acessar uma rede Wi-Fi. O módulo ESP permite que a placa Arduino se conecte a um roteador e acesse a rede de internet. O Arduino está programado para se comunicar com a plataforma em nuvem, ou seja, ThingSpeak sobre o protocolo TCP/IP. O Arduino pode implementar o protocolo TCP/IP passando comandos AT serialmente para o módulo ESP8266.
O dispositivo IoT projetado é um contador de visitantes, bem como um monitor de temperatura e umidade. Para funcionar como contador de visitantes, os sensores IR e fotodiodos fazem interface com a placa Arduino. Para funcionar como monitor de temperatura e umidade, um sensor DHT-11 faz interface com a placa Arduino. O Arduino lê os dados dos sensores e os envia para a plataforma ThingSpeak. Um OLED 128 X 64 de 0,6 polegadas também faz interface com o Arduino, que recebe dados seriais da placa no protocolo I2C e exibe as leituras atuais de temperatura e umidade. O usuário pode monitorar o número de ocupantes da casa, valores de temperatura e umidade de qualquer lugar acessando a plataforma ThingSpeak.
A placa Arduino controla todas as funcionalidades do dispositivo IoT como contagem de visitantes, leitura de valores de temperatura e umidade do sensor DHT-11, exibição de dados de temperatura e umidade em OLED, implementação do protocolo TCP/IP, conexão com a plataforma ThingSpeak e envio de dados para a nuvem servidor. Para isso, o código do Arduino é escrito e compilado usando o Arduino IDE.
Componentes necessários –
Exibição de dados de sensores baseados em realidade aumentada
Fig. 1: Lista de componentes necessários para comunicação IoT baseada em TCP/IP com o servidor Thingspeak
Software necessário –
• Servidor ThingSpeak
• IDE do Arduino
Diagrama de bloco –
Exibição de dados de sensores baseados em realidade aumentada
Fig. 2: Diagrama de blocos de comunicação IoT baseada em TCP/IP entre Arduino e Thingspeak Server
Conexões de Circuito –
O dispositivo IoT que se comunica com o ThingSpeak Cloud é construído no Arduino UNO. O sensor DHT-11, sensor IR, fotodiodos, módulo ESP8266 e módulo OLED fazem interface com a placa Arduino para criar o dispositivo IoT.

Circuito monitor de temperatura ThingSpeak Arduino baseado em TCP-IP baseado em ESP8266

O dispositivo IoT possui as seguintes conexões de circuito –
Arduino UNO – Arduino UNO é uma das placas de prototipagem mais populares. É uma placa controladora baseada em Atmega 328 que possui 14 pinos GPIO, 6 pinos PWM, 6 entradas analógicas e interfaces UART, SPI e TWI integradas. O Atmega 328 é o MCU instalado na placa Arduino. O controlador tem a seguinte configuração de pinos –
Tabela listando a configuração dos pinos do Arduino Uno
Fig. 3: Tabela listando a configuração dos pinos do Arduino Uno
Existem dois pinos GPIO (pinos de interrupção externa INT0 e INT1) da placa Arduino usados ​​​​para fazer a interface de fotodiodos, os pinos TX e RX (pinos 3 e 2 respectivamente) são usados ​​​​módulo ESP de interface, pinos SDA e SCL (pinos 27 e 28 respectivamente) usados para fazer interface com o módulo OLED.
Módulo OLED – O módulo OLED é utilizado para exibir as informações de temperatura e umidade, bem como a contagem de visitantes (ocupantes) na casa. O módulo se comunica com a placa Arduino usando o protocolo I2C. Este é um protocolo de dois fios. O módulo possui quatro pinos – SDA, SCL, VCC e GND. O VCC e o aterramento são conectados a 5 Vcc e aterramento comum, respectivamente. Os 5V DC podem ser fornecidos através de uma bateria via IC regulador de tensão 7805. Os pinos SDA e SCL do módulo OLED são conectados aos pinos SDA e SCL ((pinos 27 e 28 respectivamente) da placa Arduino. Os OLED são feitos de materiais orgânicos à base de carbono. Portanto, ao contrário dos monitores LCD, eles não requerem luz de fundo e filtros.
Imagem mostrando mensagens iniciais exibidas no display OLED
Fig. 4: Imagem mostrando mensagens iniciais piscando no display OLED
Módulo ESP8266 – O Módulo Wi-Fi ESP8266 é um SOC independente com pilha de protocolo TCP/IP integrada que pode acessar uma rede Wi-Fi. O ESP8266 é capaz de hospedar um aplicativo ou descarregar todas as funções de rede Wi-Fi de outro processador de aplicativo. Cada módulo ESP8266 vem pré-programado com um firmware de conjunto de comandos AT. O módulo está disponível em dois modelos – ESP-01 e ESP-12. O ESP-12 possui 16 pinos disponíveis para interface, enquanto o ESP-01 possui apenas 8 pinos disponíveis para uso. O ESP-12 possui a seguinte configuração de pinos –
Tabela de listagem de configuração de pinos do módulo ESP8266 ESP-12
Fig. 5: Tabela listando a configuração dos pinos do módulo ESP8266 ESP-12
O modelo ESP-01 é utilizado no projeto. O modelo ESP-01 possui a seguinte configuração de pinos –
Tabela de listagem de configuração de pinos do módulo ESP8266 ESP-01
Fig. 6: Tabela listando a configuração dos pinos do Módulo ESP8266 ESP-01
Os pinos Chip Enable e VCC do módulo são conectados a 3,3 V DC enquanto o pino Ground está conectado ao terra comum. O pino de habilitação do chip é conectado ao VCC por meio de um resistor pull up de 10K. O pino RESET não está conectado. Os pinos Tx e Rx do módulo são conectados aos pinos RX e TX do Arduino UNO. O pino GPIO-0 do módulo é conectado ao VCC por meio de um resistor pull up de 10K.
O módulo ESP permite que o Arduino acesse a internet conectando-se a um roteador via Wi-Fi.
Imagem típica do modem Wi-Fi ESP8266 ESP-01
Fig. 7: Imagem típica do modem Wi-Fi ESP8266 ESP-01
Sensores IR – Um conjunto de dois LEDs IR é usado no circuito para detectar a entrada de qualquer visitante. Esses LEDs IR são instalados na entrada da casa. Um LED IR é um tipo de LED que emite luz na faixa de frequência infravermelha. As radiações infravermelhas não são visíveis ao olho humano, mas podem ser vistas pelas lentes de uma câmera. Operacionalmente, os LEDs IR não são muito diferentes dos LEDs normais. Eles também precisam de 3 Vcc para polarização e consomem corrente de 20 mA. Eles também precisam ser conectados com um resistor pull-up em um circuito. Na matriz, os LEDs IR são conectados com resistores pull-up de 220 ohms.
Fotodiodos – Os fotodiodos são usados ​​como receptores IR no circuito. Um fotodiodo é um tipo de diodo que fica polarizado diretamente quando a luz incide sobre ele. Possui alta resistência quando nenhuma luz incide sobre ele. Quando a intensidade da luz incidente sobre ele aumenta, ele começa a ficar polarizado e a corrente começa a fluir através dele. Portanto, quando a luz incide sobre ele, sua resistência diminui e há menos queda de tensão nele. Quando a luz não incide sobre ele, sua resistência aumenta e há maior queda de tensão através dele. O fotodiodo se parece exatamente com um LED e pode ter uma película azul escura ou preta no revestimento externo. Os fotodiodos são usados ​​na configuração de polarização reversa no circuito. Um conjunto de dois fotodiodos instalados em linha com transmissores IR é usado no circuito. Os fotodiodos fazem interface nos pinos de interrupção externos INT0 e INT1 da placa Arduino.
Imagem do transmissor IR e da matriz de fotodiodos usados ​​para contagem de visitantes
Fig. 8: Imagem do transmissor IR e do conjunto de fotodiodos usados ​​para contagem de visitantes
Sensor DHT-11 – DHT-11 é um sensor de temperatura e umidade. O sensor DHT11 consiste em dois componentes principais – um é o componente de detecção de umidade e o outro é o sensor de temperatura NTC (ou termistor). O termistor é na verdade um resistor variável que muda sua resistência com a mudança de temperatura. Ambos detectam a temperatura e a umidade da área e fornecem saída para o IC (que é colocado na parte traseira do sensor). O sensor possui quatro pinos – VCC, Terra, saída de dados e NC. Os pinos VCC e Terra são conectados ao VCC e Terra comuns, respectivamente. O pino Data Out do sensor é conectado ao pino PD7 da placa Arduino por meio de um resistor pull-up de 10K.
Diagrama de pinos do sensor de temperatura e umidade DHT-11
Fig. 9: Diagrama de pinos do sensor de temperatura e umidade DHT-11
Servidor ThingSpeak – O servidor ThingSpeak é usado para visualizar os dados recebidos do dispositivo IoT. Os dados são exibidos em forma de gráficos na plataforma. O ThingSpeak gera a chave API de leitura e gravação. A chave Write API é usada para gravar os dados no canal e ler o canal API é usado para permitir que outras pessoas visualizem feeds e gráficos de canais privados. Os dados também podem ser salvos na plataforma para referência futura.
Para configurar a plataforma ThingSpeak para acessar os dados nela contidos, primeiro deve ser criada uma conta na plataforma. Em seguida, um canal deve ser criado para os dados dessa conta. Isso pode ser feito navegando até a janela do canal e criando um novo canal. As informações solicitadas devem ser preenchidas no formulário disponibilizado no site para que os campos necessários sejam criados. Para este projeto devem ser criados três campos – Total de Pessoas, Temperatura e Umidade. Esses campos podem então ser verificados ao vivo no servidor. Após salvar as configurações do canal, é gerada uma chave Write API que deve ser anotada. Esta chave Write API é usada no código do firmware do Arduino para acessar o canal privado criado na conta ThingSpeak.
Protótipo de contador de visitantes Arduino Thingspeak conectado com TCP-IP baseado em ESP8266
10: Protótipo de contador de visitantes Arduino Thingspeak conectado com TCP-IP baseado em ESP8266
Como funciona o circuito –
À medida que o circuito é ligado, a placa Arduino começa a ler os dados dos receptores IR e do sensor DHT-11. Os receptores IR são conectados em série com resistores variáveis ​​entre VCC e terra em configuração de polarização reversa formando um circuito divisor de tensão. A saída dos receptores IR (fotodiodos) é extraída da junção dos terminais catódicos do receptor IR. Em condições normais, a luz emitida pelos transmissores IR é continuamente recebida pelos fotodiodos. Isso mantém a saída lógica digital dos fotodiodos em ALTO. Quando uma pessoa entra na casa, a luz dos transmissores IR é bloqueada e a saída lógica dos fotodiodos é alterada para BAIXO. Os receptores IR são conectados nos pinos de interrupção externos do Arduino, portanto, uma interrupção é gerada nos pinos INT0 e INT1 do Arduino quando uma pessoa entra ou sai de casa. Existem dois pares de transmissor e receptor IR usados. A sequência em que são geradas as interrupções nos pinos INT0 e INT1 indica se uma pessoa entrou ou saiu da casa. Conseqüentemente, a contagem dos atuais ocupantes da casa aumenta ou diminui.
O sensor de temperatura e umidade DHT11 é um sensor digital com sensor de umidade capacitivo e termistor integrados. 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 temperaturas 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 de detecção de umidade é um substrato de retenção de umidade com eletrodos aplicados à 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 a placa Arduino em 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. Depois de 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 Arduino. O Arduino também se conecta à Ethernet usando uma biblioteca de código aberto. Os valores lidos de temperatura e umidade junto com o número dos ocupantes são exibidos no módulo OLED.
Imagem mostrando dados do sensor e contagem de visitantes exibidos no módulo OLED
Fig. 11: Captura de tela do gráfico mostrando o número de visitantes no servidor Thingspeak
Os mesmos dados são passados ​​​​para o servidor ThingSpeak a cada três segundos, acessando o servidor por meio da chave Write API. Os dados são transmitidos pelo protocolo TCP/IP enviando comandos AT para o módulo ESP por meio de comunicação serial. Os dados passados ​​para todos os três campos são atualizados a cada três segundos e exibidos em forma de gráficos no servidor. A contagem de visitantes é exibida da seguinte forma –
Captura de tela do gráfico mostrando o número de visitantes no servidor Thingspeak
Fig. 11: Captura de tela do gráfico mostrando o número de visitantes no servidor Thingspeak
Da mesma forma, a temperatura é exibida no servidor da seguinte forma –
Captura de tela do gráfico mostrando a temperatura no servidor Thingspeak
Figura 12: Captura de tela do gráfico mostrando a temperatura no servidor Thingspeak
A umidade também é exibida graficamente no servidor da seguinte forma –
Captura de tela do gráfico mostrando a umidade no servidor Thingspeak
Fig. 13: Captura de tela do gráfico mostrando a umidade no servidor Thingspeak
Guia de programação –
A placa Arduino é carregada com um esboço para contagem de visitantes, leitura de valores de temperatura e umidade do sensor DHT-11, exibição de dados de temperatura e umidade em OLED, implementação do protocolo TCP/IP, conexão com a plataforma ThingSpeak e envio de dados para o servidor em nuvem. O código Arduino carrega uma biblioteca padrão para interface entre o módulo OLED e o sensor DHT-11. As variáveis ​​e objetos são declarados para armazenar informações de temperatura, umidade e contagem de visitantes.
A função timer1_init é definida para inicializar os temporizadores. O OLED_Welcome_Message(void) é chamado para exibir mensagens iniciais no OLED.
O Arduino usa o módulo ESP para se conectar à rede local e assim ao servidor ThingSpeak. O código a seguir é usado para inicializar a conexão com o ponto de acesso Wi-Fi e para definir a chave Write API para acessar o servidor ThingSpeak.
//ESP866-01 Conexão WIFI
#define SSID “Escreva seu SSID” //”SSID-WiFiname”
#define PASS “senha //”senha”
#define IP “184.106.153.149” //thingspeak.com ip
String mensagem = “GET /update?key=Write_API_Key”; //API KEY do nosso canal
A função connectWiFi é chamada para conectar-se aos pontos de acesso Wi-Fi. Os comandos AT – AT+CWMODE=1 são passados ​​​​para o módulo ESP para definir o Wi-Fi para o modo estação. O comando AT – AT+CWJAP é passado ao módulo ESP para conectar-se ao ponto de acesso Wi-Fi.
Após a conexão ser estabelecida com a rede local e o servidor ThingSpeak, o Arduino lê os dados dos sensores. As funções PERSONIN e PERSONOUT são usadas para aumentar e diminuir a contagem de visitantes. A função Temperature_and_Humidity_Test é usada para ler os valores de temperatura e umidade do sensor DHT-11 e formatar as informações em uma string. A função Display_Data_on_OLED consegue exibir os dados no módulo OLED.
A função update_Data_To_Server é chamada para atualizar os dados do sensor para o servidor ThingSpeak. Na função, o comando AT – AT+CIPSTART é passado para o módulo ESP para iniciar a conexão TCP e em seguida o comando AT – AT+CIPSEND é passado para enviar dados ao servidor. A conexão TCP é fechada passando o comando AT – AT+CIPCLOSE para o módulo ESP.
Confira o esboço completo do Arduino na seção de código para melhor compreensão.
No próximo tutorial, o protocolo UDP será discutido.

Código-fonte do projeto

###



//Program to 


/*

 * File Name - IR_based_Visitor_counter_and_DHT11_test.ino

 * Created: 2/14/2017 11:02:11 AM

 * Main Source Code for IR based Visior couter and DHT11 test

 * Tested on ATmega328 based Arduino board running on Internal Oscillator at 16MHz

 */ 


 /*

 * Input/Output Pins of the Arduino Baord

 *A5 - OLED SCL pin

 *A4 - OLED SDA pin

 *Tx - ESP8266-01 Rx

 *Rx - ESP8266-01 Tx

 *D2 - IR1 (PERSONIN) output

 *D3 - IR2 (PERSONOUT) output

 *D7 - DHT11 output (pin2)

*/


//Universal graphic Library for Oled(128x64) Dispaly

#include "U8glib.h"   


//DHT11 or DHT22 Temperature sensor Library    

#include "DHT.h"


//Setup u8g object

U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE U8G_I2C_OPT_DEV_0);


//Declare all global variables

const int PersonIn = 2;                   //Variable to hold Incoming Entry of person

const int PersonOut = 3;                  //Variable to hold Outgoing Entry of person 

volatile unsigned int count = 0;          //Variable to hold the count value                                             

int temperature;                         //Variable to hold Temperature

int humidity;                                //Variable to hold Humidity 

String tempC;                               //Variable to hold the character value


char str(10);                              //Array Initialization to hold the String


// DHT11 or DHT22 pin and Type declaration

#define DHTPIN 7                            //DHT11 ouptput connected to Digital Pin 7

#define DHTTYPE DHT11                       //DHT TYPE-DHT 11 or 22

DHT dht(DHTPIN, DHTTYPE);                    //DHTPIN and TYPE declaration


//ESP866-01 WIFI CONNECTION

#define SSID "NOT UR WIFI"                //"SSID-WiFiname" 

#define PASS "marketing"                   //"password"

#define IP "184.106.153.149"           //thingspeak.com ip

String msg = "GET /update?key=03JHV63FG27FYL3R";       //API KEY of our channnel


//Initialise the variable in setup Function

void setup 

{

  Serial.begin(115200);               //Initialise Serial communication at 115200 bps

  Serial.println("AT");              //When baud rate matches, Print AT on Serial Monitor

  delay(5000);


  //Condition to check Whether Serial finds Ok response from ESP8266 or not

  //If It finds Ok response the call the connectWifi  Function 

  if(Serial.find("OK"))

  {

    connectWiFi ;

  }


  pinMode(PersonIn, INPUT);               //Initialise the Digital Pin-2 as Input

  pinMode(PersonOut, INPUT);               //Initialise the Digital Pin-3 as Input

  

  attachInterrupt(digitalPinToInterrupt (2), PERSONIN, FALLING);     //Attach Interrupt handler for D2

  attachInterrupt(digitalPinToInterrupt (3), PERSONOUT, FALLING);      //Attach interrupt handler for D3


  //Initialize Timer1 Function

  timer1_init ;

                                 

  //Display Welcome messgage on OLED

  OLED_Welcome_Message ;                          

}


//Loop function

void loop 

{   

  // check whether the flag bit is set

    // if set, it means that there has been a compare match

    // and the timer has been cleared

    // use this opportunity to update the data on OLED and Thingspeak

  if (TIFR1 & (1 << OCF1A))

  {

    //Get the temperature and Humidity value from DHT11 Sensor

      Temperature_and_Humidity_Test ;

  

    //Update the Temperature, Humidity and Total Person on Server(Thingspeak)

      update_Data_To_Server ;

  

      //Display the Temperature, Humidity and Total Person on OLED 

      Display_Data_on_OLED ;

    }

    // wait! we have one more thing to do

    // clear the flag bit manually since there is no ISR to execute

    // clear it by writing '1' to it (as per the datasheet)

    TIFR1  = (1 << OCF1A);

}


/*

* Function Name - OLED_Welcome_messgage

* To diplay the text when OLED starts

* Input Paraameter - void

* Return - void

*/

void OLED_Welcome_Message(void) 

{

  u8g_uint_t x = 0;

  u8g_uint_t y = 20;

  const char *s = "VISIOR COUNTER!";

  //Draw the string "VISITOR COUNTER!" on OLED with given reference points

  u8g.firstPage ;  

  do

  {

    u8g.setFont(u8g_font_unifont);

    u8g.drawStr( x, y,s );

  } 

  while( u8g.nextPage  );

}


/*

* External Interrupt Function INT0- PERSONIN

* To count the person coming in the room                                                               

*/

void PERSONIN 

{

  count++;

} 


/*

* External Interrupt Function INT1- PERSONOUT 

* To count the person coming out of the room

*/

void PERSONOUT 

{

  count--; 

  if (count <= 0)

  count = 0;

}


/*

*Function Name - Temperature_and_Humidity_Test   

*Read the Temperature and Humidity value from DHT sensor

*/

void Temperature_and_Humidity_Test 

{

  //Read the Temperature and Humidity from DHT sensor  

  temperature = dht.readTemperature ;

  humidity = dht.readHumidity ;

  char buffer(10);


  //There is a useful c function called dtostrf  which will convert a float to a char array so it 
can then be printed easily.  

  //The format is: dtostrf(floatvar, StringLengthIncDecimalPoint, numVarsAfterDecimal, charbuf);

  tempC = dtostrf(temperature, 4, 1, buffer); 

}


/*

*Function Name= Display_Data_on_OLED 

*To display the data on OLED with paticular format

*/

void Display_Data_on_OLED 

{

  //To Display on OLED

  u8g.firstPage ;  

  do

  {

    //Set the font of display

    u8g.setFont(u8g_font_helvB08);

    

    //Draw the string "Total Person" with specified reference points(x,y)

    u8g.drawStr( 0, 15, "TOTAL Person:");

    //set the count value to OLED specied points

    u8g.drawStr( 80, 15, dtostrf(count, 5, 2, str));


    //Draw the string "Humidity" with specified reference points(x,y)

    u8g.drawStr( 0, 30, "Humidity:");

    //set the Humidity value to OLED specied points

    u8g.drawStr( 80, 30, dtostrf(humidity, 5, 2, str));

    u8g.drawStr( 120, 30, "%");

    

    //Draw the string "Temperature" with specified reference points(x,y)

    u8g.drawStr( 0, 45, "Temperature:");

    //set the Temperature value to OLED specied points

    u8g.drawStr( 80, 45, dtostrf(temperature, 5, 2, str));

    u8g.drawStr( 120, 45, "260C");

  } 

  while( u8g.nextPage  );

}


/*

* Function Name- update_Data_To_Server 

* Establish TCP connection and send the updated Data to Server(Thingspeak)

*/

void update_Data_To_Server 

{

   //Specify which connection channel you wish to connect on ( 0 - 4 ), 

   //the protocol type (TCP/UDP),the IP address (or domain if you have DNS access) 

   //and the port number using the CIPSTART command:

   String cmd = "AT+CIPSTART="TCP","";

   cmd += IP;

   cmd += "",80";

   Serial.println(cmd);

   

   if(Serial.find("Error"))

    {

      return;

    }


   cmd = msg ;

   cmd += "&field1=";                    //Creates field1 for Total Person in the Room 

   cmd += String(count);                  //Upload count data to thingspeak

   cmd += "&field2=";                  //Creates field2 for Temperature

   cmd += tempC;                        //Upload Temperature data to Thingspeak

   cmd += "&field3=";                       //Creates field3 for Humidity

   cmd += String(humidity);              //Upload Humidity data to Thingpeak

   cmd += "rnrn";


   //Send Data Length

   Serial.print("AT+CIPSEND=");

   Serial.println(cmd.length );


   //If Everything works ok, then we get ">"

   if(Serial.find(">"))

   {

     //Serial monitor prints the Get command with the API key and fields speacified

     Serial.print(cmd);

   }

   else

   {

    //close the TCP connection

     Serial.println("AT+CIPCLOSE");

     Temperature_and_Humidity_Test ;

     count;

   }

}


/*

*Function Name- connectWifi 

*It establishes the connection between the ESP8266 and Wifi

*Input paramerter-void

*Return type- boolean 

*/

boolean connectWiFi 

{

   //Enable the module to act as both Station and an access point 

   Serial.println("AT+CWMODE=1");

   delay(2000);

   

   //Join the WIFI access point

   String cmd="AT+CWJAP="";

   cmd+=SSID;

   cmd+="","";

   cmd+=PASS;

   cmd+=""";

   

   //Print the Wifi SSID and Password on Serial monitor

   Serial.println(cmd);

   delay(5000);

   

   if(Serial.find("OK"))

   { 

     return true;

   }

   else

   {

     return false;

   }

}


/*

*Function Name- timer1_init 

Timer1(16bit) creates the delay time period

in order to display the data on OLED and Server(Thingpeak)

*/

void timer1_init 

{

   //Initialize registers 

   TCCR1A = 0;                //set entire TCCR1A register to 0

   TCCR1B = 0;                   //set entire TCCR1B register to 0

  

   //Initialize counter

   TCNT1 = 0;

   

   // Set the Compare value equal to count_value_for_Delay_time that

   // was calculated for generating a Delay Time period 

   // This updates the temperature, Humidity and Total person after every Delay Time Period

   OCR1A = 46874;

    

  //Start timer1                                                                                       

   //Set up timer with prescaler = 1024 and CTC mode

   TCCR1B  = (1 << WGM12) (1 << CS12) (1 << CS10);    

}


###

Vídeo do projeto

Conteúdo Relacionado

Voltar para o blog

Deixe um comentário

Os comentários precisam ser aprovados antes da publicação.