sábado, 17 de junho de 2017

Criando caracteres especiais no display LCD

Caracteres especiais no LCD



Nesse tutorial, vamos demonstrar como criar caracteres especiais para aplicação em projetos com microcontroladores. 
Os conceitos aplicados podem ser adotados em qualquer modelo de placa que o usuário tiver mais afinidade em usar, levando sempre, em consideração as diferenças e particularidades entre elas.
No caso estarei demonstrando com o módulo Node MCU.
A aplicação de caracteres especiais podem ser necessários em aplicações onde, muitas vezes precisa-se inserir na tela do LCD uma aplicação exclusiva.
No tutorial também estarei usando um módulo I2C para display. Esse módulo tem a praticidade de utilizar somente 4 fios de ligação, 2 para alimentação e 2 para dados.

Componentes

Módulo NodeMCU
Módulo I2C
Display LCD 16x2
Fonte de protoboard 5 Vcc/ 3.3 Vcc
Protoboard e cabos jumpers

Deve ser feita a ligação dos componentes conforme o esquema.

fonte: próprio autor

Para melhor entendimento do funcionamento do display LCD deve-se ter o conhecimento de que o display é dividido da seguinte maneira: quando em sua especificação denomina-se 16x2 quer dizer que a tela está dividida em 16 colunas e 2 linhas.

fonte: blog baú da eletrônica

Em cada divisão das colunas com as linhas existem segmentos que numa visão ampliada divide-se em outro segmentos de 5 colunas e 8 linhas.


fonte: próprio autor

Para formar a figura que atenda a necessidade do programador, o caractere pode ser feito na divisão dos segmentos ou em vários segmentos e serem agrupados no display.
O programa (LCDv1.0) pode auxiliar na organização dos seguimentos para formar caracteres mais complexos.



fonte: próprio autor

O programa facilita, cabendo ao usuário inserir os bits conforme os caracteres necessários.

Código fonte

O código exibido abaixo é um exemplo utilizado, que pode ser visto melhor no vídeo, ao final desse tutorial.

//Caracteres Display LCD 16 x 2
//Autor: Tony Emerson Marim
//===http://www.mecatronizando.com.br===
 
#include <Wire.h>  //INCLUSÃO DE BIBLIOTECA
#include <LiquidCrystal_I2C.h> //INCLUSÃO DE BIBLIOTECA

LiquidCrystal_I2C lcd(0x3F, 16, 2); //FUNÇÃO DO TIPO "LiquidCrystal_I2C"
 
// copiar para aqui o codigo fornecido pela aplicação de criar caracteres
// caracter 1
byte punho[8] = {
B00000,
B00000,
B11111,
B11111,
B11111,
B11111,
B11111,
B00000
};
// caracter 2
byte mao[8] = {
  B10000,
  B11000,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111
};
// caractere 3
byte youtube[8] = {
  B11111,
  B11111,
  B01111,
  B00111,
  B00111,
  B01111,
  B11111,
  B11111
};
 byte youtube2[8] = {
  B11111,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11110,
  B11111
};
void setup() 
{

  lcd.init();   // INICIALIZA O DISPLAY LCD
  lcd.backlight(); // HABILITA O BACKLIGHT (LUZ DE FUNDO)


lcd.createChar(1, punho);

lcd.createChar(2, mao);

lcd.createChar(3, youtube);

lcd.createChar(4, youtube2);

lcd.begin(16, 2); //inicializa o LCD 16x2
 
lcd.setCursor(0, 0); //aponta para coluna 0, linha 2
lcd.write(1); //escreve o caracter
lcd.setCursor(1, 0); //aponta para coluna 0, linha 2
lcd.write(2); //escreve o caracter
lcd.setCursor(2, 0);
lcd.print(" ****CURTA****");
lcd.setCursor(1, 1); //aponta para coluna 0, linha 2
lcd.write(3); //escreve o caracter
lcd.setCursor(0, 1); //aponta para coluna 0, linha 2
lcd.write(4); //escreve o caracter
lcd.setCursor(2,1);
lcd.print(" -INSCREVA-SE- ");
 
}
 
void loop() 
{

}


fonte: próprio autor

Para elaborar os mais diferentes caracteres que atenda a função do usuário é só deixar a imaginação fluir.



Gostou? Curta e Compartilhe a FanPage!
Assine o canal!
Adquira seus componentes!

Caso seja necessário, os arquivos apresentados podem ser baixados por esse LINK!

Bons estudos!

quinta-feira, 15 de junho de 2017

Conectando display LCD ao NodeMCU

Conectando display LCD ao NodeMCU


fonte: próprio autor

Esse tutorial vai ser destinado ao usuário que pretende realizar uma ligação entre o NodeMCU e um display LCD com I2C. 
As informações exibidas no display deverão aparecer de forma estática, onde são trocadas depois de um período e de maneira em que rolam da direita para a esquerda.

Para esse projeto vai ser utilizado:


Esquema

A ligação do circuito é bastante simple, para ligar o display LCD ao NodeMCU, foi utilizado somente duas portas digitais do módulo D1 e D2, além do VCC e GND.
O módulo I2C torna o projeto ainda mais prático, pois otimiza o uso de pinos e sua conexão é direta com o display.


fonte: próprio autor


Com as ligações feitas é necessário carregar os códigos na IDE do Arduino e testar o projeto.
Selecione a placa utilizada, NodeMCU e a porta COM. Caso seja iniciante no uso dos módulos relacionados, acesse o tutorial de uso pelos atalhas NodeMCU e I2C.

Código 1

Nesse código as informações exibidas no NodeMCU trocam conforme o delay especificado, de forma estática.

//Tony Emerson Marim em 15/06/2017.
/** mecatronizando@gmail.com **/
/** Display LCD **/

#include <Wire.h>  //INCLUSÃO DE BIBLIOTECA
#include <LiquidCrystal_I2C.h> //INCLUSÃO DE BIBLIOTECA

LiquidCrystal_I2C lcd(0x3F, 16, 2); //FUNÇÃO DO TIPO "LiquidCrystal_I2C"
 
void setup()
{
  lcd.init();   // INICIALIZA O DISPLAY LCD
  lcd.backlight(); // HABILITA O BACKLIGHT (LUZ DE FUNDO) 
}

void loop()
{
 lcd.clear();
 lcd.setCursor(2, 0);
 lcd.print("Mecatronizando"); // EXIBE O TEXTO DA PRIMEIRA LINHA
 lcd.setCursor(0, 1);
 lcd.print("ESP8266 nodeMCU"); // EXIBE TEXTO DA SEGUNDA LINHA
 delay(5000);//TEMPO EM QUE PERMANECE EXIBINDO
 lcd.clear();// LIMPA O DISPLAY
 lcd.setCursor(0, 0);
 lcd.print("Tutoriais"); // EXIBE O SEGUNDO TEXTO NA PRIMEIRA LINHA
 lcd.setCursor(0, 1);
 lcd.print("CompartilheCURTA"); // EXIBE O SEGUNDO TEXTO NA SEGUNDA LINHA
 delay(5000);
}

Código 2

No segundo exemplo, os textos a serem exibidos devem rolar da direita para esquerda, exibindo constantemente.

//Tony Emerson Marim em 15/06/2017.
/** mecatronizando@gmail.com **/
// Baseado no programa original de Nishant Arora 
/** Display LCD_2 **/

#include <Wire.h>  //INCLUSÃO DE BIBLIOTECA
#include <LiquidCrystal_I2C.h> //INCLUSÃO DE BIBLIOTECA

LiquidCrystal_I2C lcd(0x3F, 16, 2); //FUNÇÃO DO TIPO "LiquidCrystal_I2C"
 
//line1 = TEXTO DA ROLAGEM SUPERIOR
String line1 = "Mecatronizando: www.mecatronizando.com.br/ curta / inscreva-se / compartilhe"; 
 
//line2 = TEXTO DA LINHA INFERIOR  
String line2 = "-MECATRONIZANDO-";  
   
// REFERENCE FLAGS 
int stringStart, stringStop = 0;  
int scrollCursor = 16;  
int tamanho =0;  
   
void setup() 
{  
  lcd.init();   // INICIALIZA O DISPLAY LCD
  lcd.backlight(); // HABILITA O BACKLIGHT (LUZ DE FUNDO)   
}  
   
void loop() 
{  
  lcd.setCursor(scrollCursor, 0);  
  lcd.print(line1.substring(stringStart,stringStop));  
  lcd.setCursor(0, 1);  
  lcd.print(line2);  
 
  delay(200); //TEMPO DE TRANSPOSIÇÃO DA ROLAGEM 
  scroll_sup(); //ROTINA DA ROLAGEM

  //VERIFICA TAMANHO DA STRING 
  tamanho = line1.length();  
  if (stringStart == tamanho)  
  {  
    stringStart = 0;  
    stringStop = 0;  
  }  
}  
//ROTINA DE ROLAGEM 
void scroll_sup()  
{  
  lcd.clear();  
  if(stringStart == 0 && scrollCursor > 0)
  {  
    scrollCursor--;  
    stringStop++;  
  } else if (stringStart == stringStop){  
    stringStart = stringStop = 0;  
    scrollCursor = 16;  
  } else if (stringStop == line1.length() && scrollCursor == 0) {  
    stringStart++;  
  } else {  
    stringStart++;  
    stringStop++;  
  }  
}

No vídeo abaixo possível ver o funcionamento do projeto.



Se necessário, por meio deste LINK é possível baixar os arquivos e bibliotecas relacionadas ao projeto.

Curta! Compartilhe e Inscreva-se no Canal!

Todos os componentes utilizados podem ser adquiridos por esse LINK!


Bons estudos!

domingo, 23 de abril de 2017

Acionando o Arduino por meio do Excel

Interface Arduino/Excel 

Pesquisando pela internet esse dias encontrei um artigo bastante interessante no site ao qual acompanho e admiro (https://www.embarcados.com.br/) um artigo elaborado por Daniel Madeira ao qual mostrava a integração do Excel com Arduino e que devido a grande utilidade estarei usando-o como base para esse post.




Dentro do pacote Microsoft Office do Windows, o Excel é uma das ferramentas mais poderosas que o compõe. A variante do Visual Basic ao qual faz parte no Excel, o VBA (Visual Basic for Appication), tem suas aplicações específicas, mas é como um sistema de controle de acionamentos e desacionamentos dos pinos digitais da plataforma Arduino é que vamos trabalhar nesse post.

Vamos iniciar o passo a passo da interface.

A planilha de desenvolvimento

Primeiramente, abra um novo arquivo (pasta de trabalho) dentro do Excel.
Nomeie conforme sua preferência, chamarei minha planilha de Mecatronizando.


Normalmente as planilhas do Excel não vêm com a opção de ferramentas de desenvolvedor habilitadas, sendo necessário fazer isso. O caminho é > acesse o menu > Arquivo > Opções.



Uma janela vai abrir de opções do Excel, então deve selecionar Personalizar faixa de opções e selecionar a guia Desenvolvedor.




fonte: próprio autor

Com uma nova guia inserida o modo Desenvolvedor passa a fazer parte das opções do Excel, podendo agora ser iniciado a inserção dos componentes necessários para a configuração da planilha.


fonte: próprio autor

Acessando a Porta COM

Depois de estar habilitado para inserir as ferramentas de desenvolvedor, o próximo passo é elaborar o acesso à Porta COM ao qual a plataforma Arduino vai estar conectada.
Vamos fazer a inserção de dois botões ao qual poderemos ligar e desligar a comunicação com a Porta COM selecionada.

Selecione Inserir na aba Desenvolvedor > Botão




fonte: próprio autor

Antes de prosseguir, formate a célula da planilha em mais ou menos altura: 50 e largura: 30, nessa primeira configuração vamos deixar as células com bastante espaço e depois elaborar uma planilha, mais apresentável, estilo um supervisório.


fonte: próprio autor

Selecione a área onde deve ser inserido o botão conforme sua escolha. Clique e arraste para fixar o botão, antes de finalizar vai abrir uma aba, onde deve ser inserido o código de função do botão.
Para atribuir uma macro, clique em novo e insira o código.






fonte: próprio autor


Sub Botão1_Clique()
  
  com$ = UCase(Cells(1, 1)) 'variável do tipo string que vai informar a linha e coluna onde vai ser informado a porta em COM em uso        
  baud$ = UCase(Val(Cells(2, 1))) 'variável tipo string que informa em qual linha e coluna vai ser informado a taxa de comunicacao com a porta COM  
  ReturnValue = Shell("mode.com " + com$ + " baud=" + baud$ + " parity=n data=8 stop=2 to=off xon=off dtr=off rts=off") 'parâmetros da porta COM
  Application.Wait TimeSerial(Hour(Now()), Minute(Now()), Second(Now()) + 2) 'tempo de espera para segurança  

  Open com$ For Binary Access Read Write As #1 'termo responsável pela abertura da porta COM
  
End Sub


fonte: próprio autor

O segundo botão deve seguir os mesmos procedimentos, no entanto sua função deve ser de fechar a comunicação com a Porta COM.


fonte: próprio autor

Sub Botão2_Clique()

 
  Close #1 'Fechar a porta COM

End Sub

* Lembrando que #1 está relacionada com a porta COM da nossa interface"



fonte: próprio autor

Acessando aos pinos do Arduino

Para um primeiro exemplo, devemos testar nossa interface, então vamos usar o LED do Arduino do Pino 13 para verificarmos o acionamento.

Deve ser inserido na planilha de controle mais dois botões para ligar e desligar o LED no teste.


fonte: próprio autor

O Arduino deve ler a instrução que chega até ele por meio da porta serial e executar a função de maneira correta.

O código abaixo deve ser atribuído ao botão responsável por ligar o LED.

Clique com o botão direto e acesse o atribuir macro para inserção do código.


fonte: próprio autor

No código abaixo está a função encarregada de colocar uma determinada saída em nível alto na planilha do usuário.

Sub Botão3_Clique()

  Put #1, , "a" ' caractere de referencia a porta COM
  Sheets("Mecatronizando").Range("d5") = "HIGH" 'planilha e celula ao qual serao incluidas funcoes

End Sub


fonte: próprio autor

O meso procedimento deve ser feito com o botão desliga LED, que deve ser responsável para deixar a saída digital em nível baixo.



fonte: próprio autor


Sub Botão4_Clique()
    Put #1, , "b" 'caractere de referencia a porta COM
    Sheets("Mecatronizando").Range("d5") = "LOW"
End Sub


fonte: próprio autor

Código fonte do Arduino

Agora vamos incluir um código fonte para que o Arduino consiga reconhecer as funções à ele atribuídos.
Vamos criar um código onde é possível que o Arduino Uno (ou similar), seja acionado para acender o LED que está no pino 13.

Copie o código e cole na IDE do seu Arduino, e faça upload para a plataforma.

 /** Código **/
//Baseado no original de daniel madeira**/
//Tony Emerson Marim em 23/04/2017.
/** mecatronizando@gmail.com **/
/** Interface Excel **/

char comando;//variável que armazena a informacao do Excel

void setup() {
 
    Serial.begin(9600);//define comunicacao serial
    pinMode(13,OUTPUT);//define pino 13 como saída
  
  }

void loop() {
 
    if (Serial.available()>0)
    {
        comando = Serial.read();
 
        switch (comando) 
        {
            case 'a':
                digitalWrite(13, HIGH);
            break;
  
            case 'b':
                digitalWrite(13,LOW);
            break;
         }
   }
}

Indicador de estado do pino de saída

E para finalizar, vamos elaborar um indicador, onde por meio da leitura da planilha é possível observar o acionamento da saída digital ao qual está sendo acionada.

Estaremos fazendo somente com o pino de saída ao qual escolhemos acionar o LED, mas se for necessário que o usuário utilize mais saídas, é só acrescentar repetindo os passos.

Os códigos citados anteriormente ao qual estavam ligados a função HIGH/LOW nos botões encarregados por ligar e desligar o LED, estavam atribuídos uma posição linha e coluna relacionada a uma célula do Excel. Essa célula vai ser exatamente onde deve ser apresentado o estado do LED para o usuário.

Formule as regras acessando Página inicial > Formatação condicional > Nova regra


fonte: próprio autor



Depois declare o texto ao qual estará atribuído quando no acionamento do LED a cor da célula vai ser alterada, no exemplo o funcionamento vai se dar da seguinte forma, LED 13 ligado = cor verde, LED 13 desligado = cor vermelha.



fonte: próprio autor

O procedimento para a célula relacionada ao estado LOW, deve ser o mesmo.


fonte: próprio autor

O usuário deve sempre lembrar que se houver necessidade de inserir novo indicadores na planilha, deve ser atribuídos dentro da função do botão, na declaração da Range onde está localizada a célula ao qual estará alterando os estados.

Depois de todos os passos, basta testar e se for necessário configurar a planilha conforme a necessidade ou o gosto do usuário.


fonte: próprio autor

No vídeo abaixo é possível ver o funcionamento completo da planilha e seu acionamento na plataforma Arduino.



Está precisando adquirir Boards e Shields? Acesse AQUI!

Todos os arquivos relacionados ao post podem ser baixados por esse LINK!

Bons estudos!

sexta-feira, 14 de abril de 2017

Arduino Ethernet Shield

Ethernet Shield W5100

Um modulo interessante e que faz o usuário entender e empregar o conceito de Internet of Things (IoT) é o Arduino Ethernet Shield 5100.


fonte: warehouse 3D

Com essa placa é possível que o usuário acesse comandos com o Arduino conectado na rede utilizando acesso remoto, troca de dados, verificação de dispositivos remotos, entre outros. O modulo é facilmente encontrado no mercado de eletrônicos e dispositivos, e com bom custo benefício, além do mais é compatível com o Arduino UNO, Mega e possui um leitor de cartão MicroSD.

O modulo baseia-se no chip WIZnet Ethernet W5100 que possibilita o acesso a rede IP no protocolo TCP, utilizando a biblioteca Ethernet Library e SD Library.

Utilizando o modulo

Primeiramente é necessário testar a placa utilizando um programa que configura o endereço de IP, utilizando os valores mais comuns nesse tipo de comunicação :
  • Endereço de IP: 192.168.0.100
  • Gateway: 192.168.0.1
  • Máscara: 255.255.255.0
Faça o acoplamento do modulo sobre a placa Arduino UNO e conecte os cabos de alimentação e de rede.




fonte: próprio autor

Ao observar na parte de cima do modulo, é possível ver alguns LEDs que indicam o estado de funcionamento.



fonte: próprio autor

Feito as conexões é hora de carregar um programa para configurar o endereço IP. Os valores apresentados são os mais comuns e foram apresentados acima no texto.

Carregue o programa na IDE do Arduino, abra o prompt de comado do seu computador e digite o seguinte comando seguido de <ENTER>:

ping 192.168.0.100

#include <SPI.h>
#include <Ethernet.h>

// A linha abaixo permite que voce defina o endereço 
// fisico (MAC ADDRESS) da placa de rede
byte mac[] = { 0xAB, 0xCD, 0x12, 0x34, 0xFF, 0xCA };

// Os valores abaixo definem o endereço IP, gateway e máscara. 
// Configure de acordo com a sua rede.
IPAddress ip(192,168,0,100);         //Define o endereço IP
IPAddress gateway(192,168,0,1);    //Define o gateway
IPAddress subnet(255, 255, 255, 0); //Define a máscara de rede

void setup() 
{
  Ethernet.begin(mac, ip, gateway, subnet); //Inicializa o Ethernet Shield
}

void loop() {}

Se tudo estiver de acordo uma janela como a apresentada abaixo deve ser apresentada indicando que o modulo está corretamente configurado para enviar e receber dados.


fonte: próprio autor

Testando um programa simples

Agora é hora de acionar um pino do Arduino por meio do browser do seu computador, monte um circuito simples como o demonstrado abaixo.
Utilize um LED de qualquer cor e um resistor no valor de 220 ohms.

fonte: próprio autor

Nesse circuito, vai ser acionado um LED, onde o comando vai ser por meio do seu navegador, algo bastante parecido com um projeto desenvolvido anteriormente com o NodeMCU (LINK).

Abra a IDE do Ardino, copie e cole o código abaixo para testar a comunicação da seua rede ethernet com a Shield.

#include <SPI.h> 
#include <Ethernet.h> // Biblioteca utilizada para comunicação com o Arduino
 
// A linha abaixo permite definir o endereço físico (MAC ADDRESS) da placa...
//de rede.  
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

byte ip[] = { 192, 168, 0, 104 }; // Define o endereço IP.

// Porta onde estará aberta para comunicação Internet e Arduino.
EthernetServer server(80);  
 
String readString;
int Pin = 7; //  Pino digital onde será ligado e desligado o LED.
 
void setup(){
 
  pinMode(Pin, OUTPUT); // Define o Pino 9 como saída.
  Ethernet.begin(mac, ip); // Chama o MAC e o endereço IP da placa Ethernet.
  //  Inicia o servidor que esta inserido junto a placa Ethernet.
  server.begin();  
}
 
void loop(){
  EthernetClient client = server.available();
  if (client) {
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
 
        if (readString.length() < 100) {
          readString += c;             
        }

        if (c == '\n') {
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println();
    
           // A partir daqui começa os códigos html.
    
          client.println("<HTML>");
          client.println("<BODY>");
          client.println("<H1>Acende LED</H1>");
          client.println("<H1>Projeto basico Demonstrar Shield Ethernet</H1>");
          client.println("<hr />");
          client.println("<br />");
          
          client.println("<a href=\"/Mecatronizando/LedOn\"\">Acender led</a>");
          client.println("<a href=\"/Mecatronizando/LedOff\"\">Apagar led</a><br />");   
          
          client.println("</BODY>");
          client.println("</HTML>");
          
          delay(1);
          client.stop();
          
          if(readString.indexOf("Mecatronizando/LedOn") > 0)
          {
            digitalWrite(Pin, HIGH);  // Liga LED.
          }
          else {
            if(readString.indexOf("Mecatronizando/LedOff") > 0)
            {
              digitalWrite(Pin, LOW);  // Desliga LED.
            }
          }
          readString="";    
        }
      }
    }
  }
}

É importante observar que, o endereço da rede está com IP: 192.168.0.100, mas para evitar conflitos, deve ser alterado o IP da utilização da Shield, no meu caso por exemplo foi utilizado o endereço 192.168.0.104.


fonte: próprio autor

Enviando e recebendo dados pela rede Ethernet

Agora vamos elaborar um projeto onde dados vão trafegar por meio da rede Ethernet.
Para isso é necessário que você tenha disponível:


O circuito

Para que o controle seja feito, é necessário montar um circuito conforme abaixo e carregar o código na IDE do seu Arduino.


fonte: próprio autor

O código

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192, 168, 0, 106 }; // Define o endereço IP.
EthernetServer server(80);
String readString;

int Pin = 7; 
const int LM35 = A0;
float tempc = 0; 

void setup(){
 
  pinMode(Pin, OUTPUT); 
  Ethernet.begin(mac, ip); 
  server.begin();  
}

void loop(){

  tempc = (float(((analogRead(LM35))* 5.0 *100) / 1024.0)/2);
 
  EthernetClient client = server.available();
  if (client) {
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
 
        if (readString.length() < 100) {
          readString += c;             
        }

        if (c == '\n') {
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println();
    
           // A partir daqui começa os códigos html.
    
          client.println("<HTML>");
          client.println("<BODY>");
          client.println("<H1>Acende LED</H1>");
          client.println("<H1>Projeto basico para demonstracao com Shield Ethernet</H1>");
          client.println("<div id='wrapper'><img src='http://i.imgur.com/cam8R9X.jpg' width=200 height=100 /><br/>");
          client.println("<hr />");
          client.println("<br />");     
          
          client.println("</BODY>");
          client.println("</HTML>");

          client.println("<H1>Mecatronizando</H1><br/>");
          client.println("<a href=\"/mecatronizando/LedOn\"\">Acender led</a>");
          client.println("<br/><br/>");
          client.println("<a href=\"/mecatronizando/LedOff\"\">Apagar led</a><br />"); 
          client.println("<br/><br/>");
          client.println("<b>Valor potenciometro porta analogica 5 :    ");
          client.println(analogRead(A5)/ 204.6);
          client.println("<br/><br/>");
          client.println("Valor temperatura (*Celsius): ");
          client.println(tempc);
          client.println("&deg<br/><br/>");
          client.println("<div id='wrapper'><img src='http://i.imgur.com/ftgQPBX.png' width=100 height=100 /><br/>");
          
          delay(1);
          client.stop();
          
          if(readString.indexOf("mecatronizando/LedOn") > 0)
          {
            digitalWrite(Pin, HIGH);  
          }
          else {
            if(readString.indexOf("mecatronizando/LedOff") > 0)
            {
              digitalWrite(Pin, LOW);  
            }
          }
          readString="";    
        }
      }
    }
  }
}

No vídeo abaixo é possível ver o funcionamento do circuito de forma completa.



Gostou?
Curta a FanPage! Compartilhe!
Inscreva-se no canal!

Todos os componentes podem ser adquiridos por meio deste LINK!

Os arquivos do projetos podem ser baixados pelo LINK!


Continue com a gente e bons estudos!