Pastilha Peltier com Arduino

Pastilha Peltier TEC1-12706 com Arduino

Neste tutorial, vamos desenvolver uma aplicação envolvendo o controle de temperatura utilizando uma Pastilha Termoelétrica Peltier TEC1-12706.

Em nossos tutoriais, já apresentamos soluções que podem ser utilizadas quando queremos medir a temperatura em algum determinado ambiente ou de alguma substância. Desta vez, iremos apresentar para você um dispositivo capaz de esquentar ou resfriar alguma coisa, de forma que você possa usar em projetos variados.

[toc]

A pastilha peltier

As Pastilhas Peltier são elementos que funcionam segundo o princípio do Efeito Peltier. Esse efeito, também chamado de efeito termoelétrico, descreve a conversão da tensão elétrica entre os terminais de um dispositivo condutor ou semicondutor, em diferença de temperatura na sua junção. Dito de outra forma, quando passamos uma corrente elétrica por este componente, geramos um gradiente de temperatura que vai de um lado da placa para o outro.

Nos módulos constituídos por junções semicondutoras, como os da figura abaixo, o efeito da tensão faz com que haja um fluxo de cargas pelos semicondutores Tipo P e Tipo N, ligados em série. No semicondutor do Tipo N, próximo ao terminal negativo há absorção de calor, esquentando, e próximo ao terminal positivo há perda de calor, esfriando. No semicondutor Tipo P acontece o efeito complementar, com absorção de calor no terminal positivo e perda de calor no terminal negativo.

Devido a essas características, arranjando corretamente os semicondutores em pares, é possível ampliar o efeito de aquecimento e resfriamento. A corrente pelos terminais dos semicondutores Tipo N e Tipo P gera uma diferença de temperatura entre as superfícies, de forma que uma é aquecida e a outra resfriada.

A eficiência desse tipo de resfriamento não pode ser comparada aos sistemas de resfriamento convencionais, com compressores e fluidos refrigerantes, mas a ausência de partes móveis e a ausência de elementos mecânicos torna a simplicidade desse dispositivo muito atrativa para alguns tipos de equipamento.

Essa pastilha é empregada em resfriamento de bebedouros eletrônicos, coolers para processadores de computador, coolers para resfriar bebidas, entre outros.

Uma informação importante é que essa pastilha se caracteriza por uma curva de aquecimento muito acentuada na sua superfície quente, portanto, em ocasiões nas quais a placa permanecerá ligada durante um tempo considerável, nós aconselhamos que você utilize um dissipador de calor para não danificá-la.

Outro ponto muito importante, e que deve ser levado em conta quando utilizamos a Pastilha Peltier TEC1-12706, é o fato de que não devemos acioná-la diretamente com a nossa placa Arduino. Como os terminais de saída do Arduino tem uma capacidade bem limitada de corrente - 20 mA para o Arduino UNO, por exemplo - não é desejável alimentar cargas como motores ou a placa Peltier de forma direta. Nesse tutorial vamos alimentar a Pastilha Peltier com uma fonte externa de 2 A, acionada por um módulo relé.

Mãos à obra - "Acionando a Pastilha Peltier TEC1-12706"

Componentes necessários

Para reproduzir este projeto, você irá precisar dos seguintes componentes:

• 1 x Arduino UNO Rev 3
• 1 x Módulo relé
• 1 x Pastilha Termoelétrica Peltier TEC1-12706
• 1 x Fonte Bivolt 12V 2A
• 1 x Adaptador P4/KRE Fêmea
• 1 x Led verde difuso
• 1 x Led vermelho difuso

Montando o projeto

O nosso projeto será montado em duas partes. A primeira delas irá conter o sistema de acionamento do relé utilizado para acionarmos a nossa Pastilha Peltier.

A segunda parte consiste na montagem do circuito necessário para alimentar a placa Peltier.

Programando

String comando;

void setup() {
  Serial.begin(9600);
  pinMode(7, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(12, OUTPUT);
}

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

Colocando para funcionar

Entendendo a fundo

Software

- Declarando a variável global

Inicialmente, nós vamos declarar uma variável do tipo String e que será responsável por receber os comandos enviados através da porta serial para ligar ou desligar a nossa Pastilha Peltier.

String comando;

- Definindo as configurações iniciais

Em seguida, vamos definir as configurações do Arduino. Dentro da função setup() nós inicializamos a comunicação serial através da sentença Serial.begin(). Também definimos o modo de operação dos pinos 7, 9 e 12 para que estes trabalhem como saídas digitais através da função pinMode().

Além disso, utilizamos também a função digitalWrite() para ligar o led vermelho (pino 9) e garantir que o led verde esteja apagado (pino 12).

void setup() {
  Serial.begin(9600);
  pinMode(7, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(12, OUTPUT);
  digitalWrite(9,HIGH);
  digitalWrite(12,LOW);
}

- Acionando o relé de controle da Pastilha Peltier

Dentro da função loop() vamos criar o acionamento da placa Peltier. Inicialmente, utilizamos a sentença Serial.available() para detectar a existência de algum caractere enviado através da porta serial para o nosso Arduino. Caso exista um valor na porta serial, a variável comando armazena o seu valor, e é realizado um teste para que seja verificado se é a letra a ou a letra b. Se for a letra a, a porta de saída digital do pino 7 é colocada em nível baixo para ligar o relé (lembre-se que os relés existentes no módulo em questão são acionados com nível baixo). Também ligamos o led verde para sinalizar que a Pastilha Peltier está acionada.

No segundo caso, o relé é desligado, colocando o pino 7 em nível alto, e o led vermelho é acionado.

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

Considerações finais

Neste tutorial, demonstramos como acionar a sua Pastilha Peltier TEC1-12706 utilizando um módulo relé de 4 canais. Esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira

Tratando bounce com o ESP8266 NodeMCU

Tratando o bounce com o ESP8266 NodeMCU

Em nosso tutorial sobre a utilização de botões com os módulos ESP8266 NodeMCU, nós te mostramos como você deve proceder para usá-los em seus projetos de automação. Entretanto, apesar de termos te apresentado uma situação bem legal para reproduzir, ela não é tão útil assim na maioria dos casos, devido a um evento chamado bounce que, por sua vez, neste tutorial, nós vamos aprender o que é e como tratá-lo de maneira rápida.

Antes de entrarmos diretamente no tópico deste tutorial, você pode estar se perguntando por que nós dissemos que a situação apresentada no tutorial anterior não é tão útil na maioria dos casos. Bem, perceba que o projeto que foi desenvolvido necessitava que o botão fosse continuamente pressionado para que o led permanecesse aceso.

Normalmente, o que nós buscamos em aplicações que utilizam botões é a transição entre estados de algum elemento baseada apenas no acionamento destes, independentemente do fato de continuarmos pressionando eles ou não. Em outras palavras, o que nós buscamos, utilizando o contexto do tutorial anterior, é que ao simplesmente apertarmos o botão (e soltarmos em seguida), uma variável booleana tenha o seu conteúdo invertido e permaneça com ele inalterado até que o botão seja pressionado novamente. É isso que faremos aqui!

Mãos à obra - Entendendo o bounce na prática e aprendendo a tratá-lo

Para que seja possível entendermos o que é o bounce e a relação dele com a aplicação que queremos desenvolver, vamos dividir esta seção de mãos à obra em duas partes, de modo que, na primeira delas, fazer uma pequena experiência para mostrar o problema causado pelo bounce e na segunda, resolveremos este impasse.

Componentes necessários

• 1 x NodeMcu Wifi ESP8266 ESP-12E
• 1 x Push-button
• 1 x Protoboard
• 1 x Resistor 150 Ω
• 1 x Resistor 10k Ω

Montando o projeto

A montagem deste circuito é bem simples e consiste apenas no encaixe do módulo ESP8266 NodeMCU no protoboard e na inclusão do botão no circuito.

Programando - Parte 1: identificação do problema

Nesta parte, nós queremos te mostrar o resultado da criação de uma aplicação com a utilização de um botão, no qual o usuário deverá apertar o botão (sem segurar) para que o led mude de estado, ou seja, de apagado para aceso ou de aceso para apagado.

bool estado;

void setup()
{
   Serial.begin(9600);
   pinMode(D2,INPUT);
}
void loop() 
{ 
   if(digitalRead(D2) == 1) 
   { 
      estado = !estado; 
      Serial.println(estado);
      while(digitalRead(D2) == 1) 
      { 
      
      }
   }
}

Caso você compile este código, você perceberá que em algumas vezes, ao apertar o botão, o seu módulo ESP8266 NodeMCU irá apresentar no Serial Monitor a transição correta do conteúdo da variável estado (isto é, de nível lógico baixo para nível lógico alto e vice-versa), no entanto, em outros momentos você poderá presenciar uma espécie de confusão, sem que você tenha controle sobre a transição, com o conteúdo da variável estado sendo alterado aleatoriamente.

Entendendo este código

A primeira coisa que nós fizemos foi declarar uma variável booleana (que só admite dois estados, 0 ou 1) chamada estado antes da função setup().

bool estado;

Em seguida, determinamos, dentro da função setup(), o modo de operação do pino D2 para que ele atue como uma porta de entrada digital e também habilitamos a comunicação serial através da sentença Serial.begin().

bool estado;

void setup()
{
   Serial.begin(9600)
   pinMode(D2,INPUT);
}

Por fim, dentro da função loop(), vamos recorrer a uma estrutura condicional if() para detectar o momento em que o botão for pressionado, ou seja, o momento em que um sinal de nível lógico alto estiver presente na porta de entrada digital D2, utilizando a função digitalRead(), de modo que, caso esta situação aconteça, nós iremos inverter o conteúdo da variável estado, imprimi-lo no Monitor Serial e manter o programa preso no laço while até que o botão seja solto.

void loop() 
{ 
   if(digitalRead(D2) == 1) 
   { 
      estado = !estado; 
      Serial.println(estado);
      while(digitalRead(D2) == 1) 
      { 
      
      }
   }
}

Analisando este código, parece que tudo irá funcionar da maneira que nós queremos, pois, ao apertarmos o botão, o conteúdo da variável estado será invertido e o programa só voltará a ser executado desde o começo quando o botão for solto.

Note que apesar da lógica utilizada para realizarmos este tipo de automação estar correta, o projeto não vai funcionar da maneira que nós queremos, simplesmente por que nós não estamos levando em conta alguns detalhes do processo.

Quando nós pressionamos um push button, mesmo que rapidamente, ocorre uma espécie de trepidação no mecanismo de fechamento do contato existente que faz com que o nível lógico que chega na porta de entrada digital D2 dê uma certa variação indo de alto para baixo e vice-versa. Desta forma, existe a possibilidade de ESP8266 NodeMCU entender que o estado estável do botão é o existente em alguma parte da trepidação e sendo assim nós não conseguimos afirmar qual será o resultado do acionamento do mesmo. Este tipo de fenômeno é chamado de bounce.

Desta forma, existe a possibilidade de ESP8266 NodeMCU confundir o estado estável do botão com alguma parte da variação dos níveis lógicos existentes trepidação. Visualmente, como dissemos antes, este acontecimento será detectado por meio da aleatoriedade das transições do conteúdo da variável estado.

Programando - Parte 2: tratando o bounce

Nesta parte, nós queremos te mostrar o resultado da criação de uma aplicação com a utilização de um botão com o tratamento do bounce realizado.

Instalando a biblioteca

Basicamente, para tratarmos o bounce, nós temos que fazer com que ao detectar um aperto no botão, o nosso módulo ESP8266 NodeMCU espere alguns instantes e confira se o botão ainda está apertado após a ocorrência da trepidação. Existem muitas formas de realizar este procedimento, mas como aqui é um guia rápido, nós vamos pela que eu acho mais rápida. Ela consiste na utilização de uma biblioteca chamada bounce 2.

Ela pode ser encontrada neste link: https://github.com/thomasfredericks/Bounce2

Após abrir a página sugerida, clique no botão verde escrito “clone or download” e posteriormente na opção Download ZIP.

Depois deste procedimento, você deverá abrir a Arduino IDE, selecionar o menu Sketch, selecionar a opção incluir biblioteca e por último, marcar a alternativa Adicionar biblioteca ZIP. Neste momento, você deve selecionar o arquivo que acabou baixar no passo anterior.

Criando o código

#include <bounce2.h>

bool estado;

Bounce tratador = bounce()

void setup()
{    
  tratador.attach(D2);
  tratador.interval(25);
}

void loop() 
{
   tratador.update();
   if (tratador.fell()) 
   {  
     estado = !estado; 
     Serial.println(estado); 
   }
}

Ao contrário do caso anterior, caso você compile este código, você verá que a cada aperto de botão, o conteúdo da variável estado será alterado de uma maneira consistente, sem erros.

Entendendo este código

#include <bounce2.h>

bool estado;

#include <bounce2.h>

bool estado;

Bounce tratador = bounce()

void setup()
{
  Serial.begin(9600);
   
  tratador.attach(D2);
  tratador.interval(25);
}

void loop() 
{
   tratador.update();
   if (tratador.fell()) 
   {  
     estado = !estado; 
     Serial.println(estado); 
   }
}

Considerações finais

Esperamos que você tenha gostado deste tutorial e que você consiga implementar este tipo de técnica nos seus projetos com ESP8266 NodeMCU. Se tiver alguma dúvida, deixe ela nos comentários abaixo.

by Daniel Madeira

Hello World com NodeMCU e JavaScript

Hello World com NodeMCU e JavaScript

Em nossa coleção de tutoriais nós elaboramos alguns conteúdos sobre a utilização do módulo ESP8266 NodeMCU e também sobre a implementação de interfaces de controle para placas Arduino através do uso da linguagem HTML e de CSS3. Neste tutorial você irá aprender algo que agrega as duas vertentes citadas, pois, aqui nós vamos desenvolver interfaces de controle para o módulo ESP8266 NodeMCU utilizando os conceitos da linguagem HTML que nós já aprendemos em conjunto com uma ferramenta nova, o Javascript.

Veja os nossos tutoriais sobre o desenvolvimento de interfaces de controle com Arduino.

• Shield Ethernet W5100 - Criando um Servidor Web com Arduino
• Shield Ethernet W5100 - Monitorando Sensores com um Servidor Web
• Shield Ethernet W5100 - Controlando saídas via Servidor Web

Para desenvolvermos a proposta deste tutorial, nós devemos primeiramente configurar a Arduino IDE para que seja possível gravarmos códigos nos módulos ESP8266 NodeMCU, portanto, caso você não saiba realizar este procedimento, basta acessar este nosso outro tutorial:

• O que é ESP8266 - A família ESP e o NodeMCU

[toc]

O Javascript

Como nós aprendemos em nossos tutoriais citados anteriormente, a linguagem HTML é uma linguagem de marcação, isto é, um recurso responsável por organizar as informações de uma página web e também por atribuir sentido aos elementos existentes nas mesmas, portanto, caso nós tenhamos uma frase em uma página web, a linguagem HTML será a responsável por dizer ao navegador se a mesma é um título, um subtítulo, um link, entre outros e também como esta se enquadra em uma ordem hierárquica de importância em relação aos outros fragmentos textuais contidos na estrutura da página em questão.

Além disso, como tivemos a chance de aprender nos tutoriais apresentados na introdução deste tutorial, a utilização das tags estruturais mais adequadas não é suficiente para que a aplicação possua uma aparência estética bem elaborada, pois, o uso das mesmas produz resultados em uma espécie de estilo padrão.  Visando resolver este impasse, surgiu o CSS (Cascading Style Sheets), que por sua vez, consiste em um recurso semelhante a uma linguagem de marcação, como o HTML, porém totalmente distinta da mesma, com objetivo único de cuidar dos procedimentos de estilização. Uma das vantagens da utilização do CSS é a possibilidade de personalizar os objetos contidos em uma página web sem que seja necessário misturar as regras de estilização com os objetos citados (como acontecia anteriormente).

Utilizando a linguagem HTML e o CSS3 nós conseguimos estruturar uma página web e também estilizá-la entretanto apenas com estes dois recursos não é possível atuar sobre o comportamento da página. Mas o que seria este suposto comportamento? Imagine que você tenha duas imagens de uma lâmpada, de modo que, uma delas representa a lâmpada apagada e a outra acesa. A sua ideia é utilizá-las para fazer uma animação, na qual, quando o estado de uma determinada porta de saída digital do seu sistema embarcado estiver em nível lógico alto, a figura que representa a lâmpada acesa fique em evidência e em contrapartida, quando a mesma estiver disponibilizando nível lógico baixo em seu terminal, somente a figura referente à lâmpada apagada apareça. Esta alteração automática de elementos reflete um exemplo de comportamento de uma página web e pode ser realizada utilizando Javascript. Basicamente, com ele nós podemos criar funções que são executadas pelo navegador em detrimento de determinados eventos ocorridos na página, como por exemplo, quando um botão é pressionado.

Javascript em um código HTML

Como nós já vimos nos tutoriais apresentados na introdução deste post, o código referente às páginas web já adaptados para serem utilizados dentro de um programa a ser gravado em uma placa Arduino possuem a seguinte estrutura:

client.println("<!DOCTYPE html>");
client.println("<html lang=\"pt-br\">");                
   client.println("<head>"); 
   client.println("</head>");
   client.println("<body>");
   client.println ("</body>");
client.println ("</html>");

O primeiro passo para incluirmos o Javascript na estrutura de uma página web é utilizar o par de tags <script></script>.

<script>
    ... Trecho de código em Javascript ...
</script>

Em seguida, basta inserir a estrutura em Javascript que você deseja dentro do espaço delimitado no código acima. É claro que como Javascript é uma linguagem de programação, existem infinitas possibilidades para serem implementadas, porém, neste tutorial, vamos fazer o famoso Hello World utilizando apenas Javascript.

Mãos à obra - Utilizando Javascript com NodeMCU

Componentes necessários

• 1 x NodeMCU Wifi ESP8266 ESP-12E

Montando o projeto

Programando

O próximo passo que você deverá realizar será copiar este código para a sua Arduino IDE, alterar os valores das variáveis ssid e password com as informações referentes ao nome da sua rede sem fio e à senha dela e compilar o código.

#include <ESP8266WiFi.h> 
 
const char* ssid = "******"; 
const char* password = "******"; 

IPAddress ip(192,168,25,16);
IPAddress gateway(192,168,25,1); 
IPAddress subnet(255,255,255,0); 
 
WiFiServer server(80); 
 
void setup() 
{ 
  WiFi.begin(ssid, password); 
  WiFi.config(ip, gateway, subnet);
  server.begin(); 
}

void loop() 
{
  String req_str;
  WiFiClient client = server.available(); 
  if (client) 
  { 
    boolean currentLineIsBlank = true;
    req_str = "";
    while (client.connected()) 
    { 
       if (client.available()) 
      {
         char c = client.read(); 
         req_str = req_str + c;
         if(c == '\n' && currentLineIsBlank) 
        {    
            
             client.println("HTTP/1.1 200 OK");
             client.println("Content-Type: text/html");
             client.println("Connection: close");
             client.println();
             client.println("<!DOCTYPE html>");
             client.println("<html lang=\"pt-br\">");                
               client.println("<head>");
                 client.println("<meta charset= \"UTF-8\"/>"); 
               client.println("</head>");
               client.println("<body>");
                 client.println("<h1>Exemplo com JavaScript</h1>");
                 client.println("<script>");
                    client.println ("alert('Esse é o meu primeiro código em JS');");
                 client.println("</script>");                         
               client.println ("</body>");
             client.println ("</html>");
             
          break;
        }
        if (c == '\n') 
        {
         currentLineIsBlank = true;
        }
        else if (c != '\r') 
        {
           currentLineIsBlank = false;
        }
      }
    }
    delay(1); 
    client.stop();
  }
}

Resultado final

Veja o resultado final que nós obtemos:

Entendendo a fundo

Software

– Apenas uma primeira observação

Este software é praticamente igual a todos os outros que nós desenvolvemos em nossos tutoriais (apresentados na introdução deste documento) sobre a criação de interfaces de controle utilizando a linguagem HTML, portanto, não será necessário entrarmos nos detalhes referentes ao funcionamento do mesmo . Por outro lado, como nos tutoriais citados nós estávamos utilizando o conjunto Arduino UNO + Ethernet Shield, deveremos realizar algumas alterações básicas para que o mesmo funcione no módulo ESP8266 NodeMCU, de modo que, esta consiste na troca da sentença:

EthernetClient client = server.available();

por:

WiFiClient client = server.available();

– Definindo os pré-requisitos para o funcionamento do código

Inicialmente, devemos incluir uma biblioteca no código para que o mesmo possa funcionar corretamente. A biblioteca em questão é a ESP8266WiFi.h, que por sua vez, é a responsável por garantir a conectividade do módulo com a nossa rede local (essa biblioteca é automaticamente instalada no momento em que pacote do ESP8266 é instalado na Arduino IDE.

#include <ESP8266WiFi.h>

Após a inclusão da bibliotecas citadas, devemos definir a rede na qual queremos conectar o nosso módulo ESP8266 NodeMCU e a senha de acesso à esta mesma rede.

const char* ssid = "** digite aqui o nome da sua rede **"; 
const char* password = "** digite aqui a senha da sua **"; 

Em seguida, você deverá determinar um endereço IP (válido e disponível na sua rede) para o seu módulo ESP8266 NodeMCU e também outros dois elementos: o endereço do gateway (geralmente possui os 3 primeiros conjuntos de algarismos igual ao definido por você anteriormente, no entanto, com o número 1 no último grupo de algarismos) e a máscara de rede (subnet), que por sua vez, para residências costuma ter o padrão 255.255.255.0 (você pode levantar estes dois últimos elementos digitando ipconfig no prompt de comando (caso o sistema operacional que você estiver utilizando seja o Windows)).  Por fim, devemos criar o objeto que será responsável por representar o Servidor Web no código (aqui, chamamos este de server) e relacioná-lo com a porta 80.

IPAddress ip(192,168,25,16);
IPAddress gateway(192,168,25,1); 
IPAddress subnet(255,255,255,0);  
WiFiServer server(80);

– Definindo as configurações iniciais

Dentro da função setup() nós iniciamos a conexão com a rede local através da função WiFi.begin() (passando como parâmetro o nome da rede local e a senha de acesso à mesma, definidos anteriormente) e também realizamos a configuração do nosso módulo ESP8266 NodeMCU através da sentença WiFi.config(). Por fim, iniciamos o nosso Servidor Web por meio da sentença server.begin() (lembre-se que server é o objeto criado para representar o Servidor Web no código).

void setup() 
{
  WiFi.begin(ssid, password); 
  WiFi.config(ip, gateway, subnet);
  server.begin(); 
}

– Criando a página para responder à requisição do navegador

Nos artigos anteriores, elencados em nossa introdução, nós aprendemos como devemos proceder para elaborar uma página bem simples, contendo elementos escritos. Neste momento, como de praxe, nós também iremos inserir uma mensagem em nossa página, porém além desta, vamos fazer o famoso Hello World utilizando Javascript.

Você se lembra do cabeçalho padrão que enviamos para o navegador antes de enviarmos a página propriamente dita? Para ajudar, vamos colocá-lo aqui.

client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close");
client.println();

A estrutura da página em HTML

O próximo passo que faremos será construir, de fato, a página que será enviada ao navegador. Com uma breve recapitulação, devemos lembrar que todo conteúdo que compõe a página deve estar dentro da seguinte estrutura:

client.println("<!DOCTYPE HTML>");
client.println("<html>");
           .
           .
***** Conteúdo da página *****
           .
           .
client.println("</html>");

Como ressaltado anteriormente, dentro desta estrutura temos o conteúdo da página que queremos enviar para o navegador, de modo que, nesta, devemos ter pelo menos dois blocos, um responsável pelas informações gerais do documento, limitado pelo uso do par <head></head> e o outro, por sua vez, deve conter o corpo da página e está entre as tags <body> e </body>.

client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("<head>");
           .
           .
   ***** Bloco 1 *****
           .
           .
client.println("</head>");
client.println("<body>");
           .
           .
   ***** Bloco 2 *****
           .
           .
client.println("</body>");
client.println("</html>");

Definido o título para a página

Neste momento, vamos utilizar apenas uma tag dentro do bloco 1, denominada <title>, cuja função consistirá em definir um título para a página (este título aparecerá na aba do navegador). Para executarmos a ação proposta, devemos colocar o título desejado entre o par <title></title>.

client.println("<!DOCTYPE HTML>");
client.println("<html>");

client.println("<head>");
client.println("<title>Servidor Web VDS</title>");
client.println("</head>");

client.println("<body>");
           .
           .
   ***** Bloco 2 *****
           .
           .
client.println("</body>");
client.println("</html>");

Veja como ficou o título da nossa página:

Escrevendo o corpo da página web

Quanto ao corpo da página (entre o par <body></body>), a primeira coisa que faremos será colocar um título visível na própria página. Para realizar este procedimento, utilizaremos a tag <h1>, que por sua vez, consiste em uma tag para apresentar um determinado texto em um modelo predefinido.

client.println("<h1>Exemplo com JavaScript</h1>");

Exibindo uma mensagem de alerta com JavaScript

Como dissemos anteriormente para inserirmos algum trecho de código em JavaScript em nosso programa nós devemos primeiramente inserir o par de tags <script> e  </script> na estrutura de nossa página web. Após realizarmos o procedimento anterior, nós vamos recorrer à função alert() do JavaScript, cujo argumento será a frase que queremos mostrar na tela, veja o nosso código.

client.println("<body>");
  client.println("<h1>Exemplo com JavaScript</h1>");
  client.println("<script>");
    client.println ("alert('Esse é o meu primeiro código em JS');");
  client.println("</script>");                         
client.println ("</body>");                        

Considerações finais

Neste tutorial, demonstramos uma pequena introdução sobre a inclusão de códigos em JavaScript para personalizar o seu projeto de criação de interfaces web com o Módulo ESP8266 NodeMCU. Esta foi mais uma parte de uma série de artigos sobre a criação de Servidores Web, portanto, esperamos que continue nos acompanhando e sinta-se à vontade para nos dar sugestões. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira

Primeiros passos com o ESP8266 NodeMCU - Lendo o estado de um botão

Primeiros passos com o ESP8266 NodeMCU - Lendo o estado de um botão

No tutorial anterior nós mostramos como você deve fazer para ler o sinal de tensão proveniente de um potenciômetro com o seu módulo ESP8266 NodeMCU. Hoje você irá aprender algo um pouco parecido entretanto, que por sua vez, também servirá (assim como o potenciômetro) para a realização de acionamentos de dispositivos externos. Neste tutorial, nós vamos dar continuidade aos conteúdos voltados para o ensino dos conceitos básicos necessários para que você consiga começar a utilizar o seu NodeMCU e desenvolver os seus projetos de automação. O tópico deste conteúdo será a leitura do estado de botões utilizando o módulo ESP8266 NodeMCU.

[toc]

As grandezas digitais e as portas digitais

Antes de aprendermos a efetuar leitura do estado de um botão, nós devemos entender o que são as grandezas digitais. Bem, as grandezas digitais são aquelas que são aquelas que podem ser definidas por meio de saltos entre valores bem estabelecidos dentro de um determinado intervalo. Como um exemplo de elementos que trabalham com estas grandezas nós podemos citar os relógios digitais, os quais, apesar do tempo em si variar continuamente, o visor dos mesmos mostra o tempo em saltos de um em um segundo (observe que os visores destes relógios nunca mostrarão algo tipo 25,8 segundos, pois, para eles, só existem 25 e 26 segundos, ou seja, qualquer valor intermediário não está definido).

O nosso módulo ESP8266 NodeMCU possui  vários pinos destinados a lidar com este tipo de grandeza, ou seja, pinos cujas funções são trabalhar com basicamente dois níveis de tensão bem definidos: 0V e 3,3V. Os pinos digitais estão identificados em nosso NodeMCU através da letra D e podem atuar de duas maneiras, ou seja, podem funcionar como entradas digitais ou como saídas digitais, de modo que, na primeira opção, os pinos em questão deverão detectar os dois níveis de tensão citados e na segunda eles proporcionarão estes níveis para que nós possamos utilizá-los no acionamento de dispositivos externos. Neste tutorial, nós iremos utilizar o pino D1 como um pino de entrada digital e em seguida efetuaremos a leitura do estado de um botão (isto é, se o botão estão pressionado ou não) conectado nele.

Mãos à obra - Efetuando a leitura de um potenciômetro

Componentes necessários

• 1 x NodeMcu Wifi ESP8266 ESP-12E
• 1 x Push-button
• 1 x Protoboard
• 1 x Resistor 150 Ω
• 1 x Resistor 10k Ω

Montando o projeto

Programando

Este é o código que utilizaremos no desenvolvimento deste tutorial

float leitura;

 void setup() 
{ 
  pinMode(D1,INPUT);
  Serial.begin(115200);
  Serial.println("Estado do botão");
}

void loop() 
{
  if(digitalRead(D1) == 0)
  {
     Serial.println("Botão não pressionado");
  }
  else
  {
     Serial.println("Botão pressionado");
  } 
  delay(1500);  
}

Colocando para funcionar

Após compilarmos o código apresentado, nós teremos este resultado:

Entendendo a fundo

Software

– Definindo as configurações iniciais

Dentro da função setup() nós vamos primeiramente definir o modo de operação do pino que nós vamos utilizar, de modo que, como nós queremos ler o estado de um botão, devemos fazer com que o pino em questão seja uma entrada digital, desta forma, nós vamos recorrer à função pinMode() para fazermos com que o pino D1 seja a entrada digital desejada. Posteriormente, nós iniciaremos a conexão com o Serial Monitor através da função Serial.begin() (passando como parâmetro o valor da taxa de transmissão de dados (como sugestão, utilize este valor)). Além disso, nós vamos utilizar a sentença Serial.println() para escrevermos na tela um título para a nossa aplicação, de modo que, este será "Estado do botão".

void setup() 
{ 
  pinMode(D1,INPUT); 
  Serial.begin(115200); 
  Serial.println("Estado do botão"); 
}  

– Lendo o estado do botão

O que nós vamos fazer aqui é algo muito simples e envolve alguns conceitos bem legais para você aprender. Primeiramente, nós vamos utilizar uma estrutura condicional chamada if(), de modo que, através deste função nós podemos conferir se uma determinada hipótese é verdadeira. O que nós vamos verificar neste tutorial é se o botão não está pressionado, ou seja, se existe um nível de tensão de 0V na porta de entrada digital D1. Este procedimento será feito por meio da comparação do resultado da função digitalRead() (que ao ser usada retorna 0 ou 1, caso o nível de tensão na porta de entrada digital em questão seja 0 ou 3,3V respectivamente) com o valor 0.

  if(digitalRead(D1) == 0)
  {
     Serial.println("Botão não pressionado");
  }

Caso esta hipótese seja verdadeira, o nosso módulo ESP8266 NodeMCU deverá escrever a frase "Botão não pressionado" no Serial Monitor.

Em contrapartida, caso o resultado da leitura do estado do botão seja 1, a frase que deverá ser escrita será "Botão pressionado". Este procedimento é realizado por meio do uso da estrutura condicional complementar else.

 else
  {
     Serial.println("Botão pressionado");
  } 

Por fim, utilizamos a função delay() para determinar o intervalo entre cada uma das aquisições.

delay(1500);

Veja como ficou a nossa função loop()

void loop() 
{
  if(digitalRead(D1) == 0)
  {
     Serial.println("Botão não pressionado");
  }
  else
  {
     Serial.println("Botão pressionado");
  } 
  delay(1500);  
}

Considerações finais

Neste tutorial, nós demonstramos como você pode fazer para realizar a leitura do estado de um botão através de um módulo ESP8266 NodeMCU. Esperamos que continue nos acompanhando e sinta-se à vontade para nos dar sugestões. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira

Primeiros passos com o ESP8266 NodeMCU - Utilizando sinais PWM

Primeiros passos com o ESP8266 NodeMCU - Utilizando sinais PWM

Até agora nós já aprendemos a realizar as leituras das portas de entrada analógica e digital do nosso módulo ESP8266 NodeMCU e também vimos como devemos proceder para poder acionar dispositivos que funcionam baseados em um comportamento ON/OFF por meio das portas de saída digital existentes no mesmo. Para completar este ciclo, nós devemos apenas falar sobre a utilização das portas de saída analógica fictícias existentes no NodeMCU visando a manipulação de dispositivos externos, portanto, neste tutorial, nós vamos discutir o que são sinais PWM, o que eles tem a ver com as eventuais saídas analógicas citadas e como utilizá-los.

Confira aqui o nossos tutoriais para iniciantes no mundo do ESP8266 NodeMCU:

• O que é ESP8266 – A Família ESP e o NodeMCU 
• Primeiros passos com o ESP8266 NodeMCU – Lendo um potenciômetro
• Primeiros passos com o ESP8266 NodeMCU – Lendo o estado de um botão
• Primeiros passos com o ESP8266 NodeMCU – Ligando e desligando um led

[toc]

Simulando saídas analógicas com PWM

Apesar de possuir uma porta para realizar a leitura de variáveis analógicas, o módulo ESP8266 NodeMCU não conta com pinos que possam ser usados para fornecer sinais de tensão cujos módulos fazem parte dos valores intermediários do intervalo que vai de 0V e 3,3V. Entretanto, é possível utilizarmos as portas de saída digital para simularmos portas de saída analógica por meio do uso do PWM, que por sua vez, é uma técnica através da qual podemos obter resultados analógicos por meios digitais.

Este recurso consiste na geração de uma onda quadrada, na qual, controla-se a porcentagem do tempo em que a onda permanece em nível lógico alto. Esta porcentagem é chamada de Duty Cycle e sua alteração provoca mudança no valor médio da onda, indo desde 0V (0% de Duty Cycle) a 3,3V (100% de Duty Cycle) no caso do ESP8266 NodeMCU. O Duty Cycle a ser definido no projeto corresponde a um número inteiro, que é armazenado em um registrador 10 bits. Sendo assim, seu valor vai de 0 (0%) a 1023 (100%).

Mãos à obra - Efetuando a leitura de um potenciômetro

Componentes necessários

• 1 x NodeMcu Wifi ESP8266 ESP-12E
• 1 x Led vermelho difuso
• 1 x Protoboard
• 1 x Resistor 220 Ω

Montando o projeto

Programando

Este é o código que utilizaremos no desenvolvimento deste tutorial.

int pwm;

void setup() 
{ 
  pinMode(D1,OUTPUT);
  Serial.begin(115200);
}

void loop() 
{ 
       analogWrite(D1,pwm);
       Serial.print("O valor do pwm é: ");
       Serial.println(pwm);
       pwm = pwm +100;
       delay(1500);
       if(pwm>1023)
       {
            pwm = 0;
       }
}

Colocando para funcionar

Após compilarmos o código apresentado, nós teremos o seguinte resultado:

Entendendo a fundo

Software

– Definindo as configurações iniciais

Dentro da função setup() nós vamos primeiramente definir o modo de operação do pino que nós vamos utilizar, de modo que, como nós queremos manipular um led, devemos fazer com que o pino em questão seja uma saída digital, desta forma, nós vamos recorrer à função pinMode() para fazermos com que o pino D1 seja a saída digital desejada. Posteriormente, nós iniciaremos a conexão com o Serial Monitor através da função Serial.begin() (passando como parâmetro o valor da taxa de transmissão de dados (como sugestão, utilize este valor)).

void setup() 
{ 
  pinMode(D1,OUTPUT);
  Serial.begin(115200);
}

– Utilizando os sinais PWM

A primeira coisa que nós devemos fazer para gerar um sinal PWM em uma determinada porta do nosso módulo ESP8266 NodeMCU será recorrer a função analogWrite(), que por sua vez, é responsável pelo sinal em questão. Esta função possui dois parâmetros, de modo que, o primeiro deles diz respeito ao pino que queremos utilizar e o segundo à magnitude do sinal PWM gerado.

 analogWrite(D1,pwm);

Em seguida, nós utilizamos as sentenças Serial.print() e Serial.println() para escrever no Serial Monitor a frase "O valor do pwm é:" seguido do valor utilizado no acionamento do nosso led.

Serial.print("O valor do pwm é: ");
Serial.println(pwm);

Após estes procedimentos, nós incrementamos o valor da variável pwm em 100 unidades para que no próximo ciclo este seja utilizado aumentando o brilho do led em questão.

pwm = pwm +100;

Sendo assim, terminamos adicionando a função delay() para determinar o intervalo de tempo entre duas incrementações de brilho e também colocamos uma estrutura condicional if() para que quando a variável pwm atingir um valor maior do que 1023, o valor zero deve ser atribuído a ela.

delay(1500);
if(pwm>1023)
{
   pwm = 0;
}

Veja como ficou a nossa função loop().

void loop() 
{ 
       analogWrite(D1,pwm);
       Serial.print("O valor do pwm é: ");
       Serial.println(pwm);
       pwm = pwm +100;
       delay(1500);
       if(pwm>1023)
       {
            pwm = 0;
       }
}

Considerações finais

Neste tutorial, nós demonstramos como você pode fazer para utilizar sinais pwm para acionar dispositivos através de um módulo ESP8266 NodeMCU. Esperamos que continue nos acompanhando e sinta-se à vontade para nos dar sugestões. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira

Primeiros passos com o ESP8266 NodeMCU - Ligando e desligando um led

Primeiros passos com o ESP8266 NodeMCU - Ligando e desligando um led

Em nossos tutoriais anteriores você aprendeu a ler as informações provenientes tanto da porta de entrada analógica existente em nosso módulo ESP8266 NodeMCU quanto das portas de entrada digital presentes na estrutura do mesmo. Neste tutorial, nós vamos dar continuidade aos conteúdos voltados para o ensino dos conceitos básicos necessários para que você consiga começar a utilizar o seu NodeMCU e desenvolver os seus projetos de automação. Aqui, nós realizaremos o  procedimento inverso do que foi feito até aqui, ou seja, aqui você verá como devemos agir para que ao invés de lermos o estado de uma determinada porta, nós possamos atuar sobre ela determinando o nível de tensão que ela deve disponibilizar para que seja possível conectarmos (e manipularmos) um elemento externo na mesma.

Confira aqui o nossos tutoriais para iniciantes no mundo do ESP8266 NodeMCU:

• O que é ESP8266 – A Família ESP e o NodeMCU 
• Primeiros passos com o ESP8266 NodeMCU – Lendo um potenciômetro
• Primeiros passos com o ESP8266 NodeMCU – Lendo o estado de um botão
• Primeiros passos com o ESP8266 NodeMCU – Utilizando sinais PWM

[toc]

Os sinais digitais de tensão

Antes de qualquer coisa, nós devemos ter em mente que quando falamos em acionamentos de dispositivos através das portas de saída digital do nosso módulo ESP8266 NodeMCU estamos falando basicamente na manipulação de dois níveis de tensão definidos, de modo que, o nosso sistema embarcado possa fornece-los em suas portas de saída digital No caso do NodeMCU, estes valores são:

• 3,3V, correspondente a um nível lógico alto;
• 0V, correspondente a um nível lógico baixo;

É importante ressaltar que na prática existem faixas de valores próximos a esses números, as quais, o nosso módulo ESP8266 NodeMCU entende como nível alto ou nível baixo. Além disso, existe também uma faixa intermediária não definida que pode gerar resultados inesperados e que, portanto, deve ser evitada.

Mãos à obra - Ligando e desligando um led

Componentes necessários

• 1 x NodeMcu Wifi ESP8266 ESP-12E
• 1 x Led vermelho difuso
• 1 x Protoboard
• 1 x Resistor 220 Ω

Montando o projeto

Programando

Este é o código que utilizaremos no desenvolvimento deste tutorial

void setup() 
{ 
  pinMode(D1,OUTPUT);
  Serial.begin(115200);
  Serial.println("Estado do led");
}

void loop() 
{ 
   digitalWrite(D1,HIGH);
   Serial.println("Ligado");
   delay(1500);  
   digitalWrite(D1,LOW);
   Serial.println("Desligado");   
   delay(1500);
}

Colocando para funcionar

Após compilarmos o código apresentado, nós teremos este resultado:

Entendendo a fundo

Software

– Definindo as configurações iniciais

Dentro da função setup() nós vamos primeiramente definir o modo de operação do pino que nós vamos utilizar, de modo que, como nós queremos ligar ou desligar um led, devemos fazer com que o pino em questão seja uma saída digital, desta forma, nós vamos recorrer à função pinMode() para fazermos com que o pino D1 seja a saída digital desejada. Posteriormente, nós iniciaremos a conexão com o Serial Monitor através da função Serial.begin() (passando como parâmetro o valor da taxa de transmissão de dados (como sugestão, utilize este valor)). Além disso, nós vamos utilizar a sentença Serial.println() para escrevermos na tela um título para a nossa aplicação, de modo que, este será "Estado do led".

void setup() 
{ 
  pinMode(D1,INPUT); 
  Serial.begin(115200); 
  Serial.println("Estado do led"); 
}  

– Ligando e desligando um led

O que nós vamos fazer aqui é algo que pode ser considerado o chamado "Hello World" no mundo da eletrônica. De uma maneira mais específica, nós vamos fazer com que o Led conectado na porta de saída digital D1 fique piscando em intervalos de 1,5 segundo.

Para atingirmos este objetivo, nós iremos necessitar apenas de três funções: a primeira delas será a função digitalWrite(), que por sua vez, será a responsável por disponibilizar o nível de tensão que queremos. Esta função aparecerá duas vezes no nosso código, entretanto, em cada uma destas, o segundo parâmetro presente em sua estrutura será diferente em virtude de em um determinado momento estarmos fazendo com que a porta em questão disponibilize nível alto (para isto utilizamos HIGH) e em outro, nível lógico baixo (neste momento, recorremos ao parâmetro LOW)).

A segunda função utilizada é justamente a função delay() cuja função será exatamente promover o intervalo entre o acionamento e o desligamento do led. Por fim, a terceira sentença que vamos ter em nosso código será a Serial.println(), que por sua vez, terá o propósito de mostrar na tela do Serial Monitor o estado do led, isto é, se ele estará aceso ou apagado.

void loop() 
{ 
   digitalWrite(D1,HIGH);
   Serial.println("Ligado");
   delay(1500);  
   digitalWrite(D1,LOW);
   Serial.println("Desligado");
   delay(1500);
}

Considerações finais

Neste tutorial, nós demonstramos como você pode fazer para ligar e desligar um led através de um módulo ESP8266 NodeMCU. Esperamos que continue nos acompanhando e sinta-se à vontade para nos dar sugestões. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira

Lendo um potenciômetro com o ESP8266 NodeMCU

Lendo um potenciômetro com ESP8266 NodeMCU

Neste tutorial, nós vamos dar início a uma grande quantidade de conteúdos voltados para o ensino dos conceitos básicos necessários para que você consiga começar a utilizar o seu NodeMCU e desenvolver os seus projetos de automação, seja para sua escola, para sua casa ou até mesmo para uma indústria. Hoje, nós vamos te mostrar como você deve proceder para ler as informações provenientes de um potenciômetro com o seu ESP8266 NodeMCU.

[toc]

As grandezas analógicas e a porta de entrada analógica A0

Antes de aprendermos a efetuar  leitura de um potenciômetro, nós devemos definir o que são as grandezas analógicas. Bem, as grandezas analógicas são aquelas que, ao contrário das grandezas digitais, podem assumir infinitos valores de amplitude dentro de uma faixa de valores. Imagine por exemplo, o velocímetro de um carro. Este instrumento pode ser considerado como sendo um medidor analógico, pois o ponteiro gira continuamente conforme o automóvel acelera ou freia. Se o ponteiro girasse em saltos, o velocímetro seria considerado digital.

O módulo ESP8266 NodeMCU possui um pino destinado a lidar com a leitura deste tipo de grandeza, ou seja, um pino cuja função é receber níveis de tensão e em seguida traduzir os mesmos em uma linguagem adequada para que possamos manipulá-los. Este processo ocorre da seguinte maneira: o NodeMCU que estamos utilizando suporta sinais de tensão entre 0 e 3,3V em suas entradas, portanto, caso nós coloquemos um sinal de tensão de 0 volts na porta de entrada analógica A0, o nosso módulo irá associar esta informação ao número 0 (zero) . Em contrapartida, caso o sinal em questão tenha magnitude de 3,3V, o NodeMCU irá referenciar este valor ao número 1023.

Mãos à obra - Efetuando a leitura de um potenciômetro

Componentes necessários

• 1 x NodeMcu Wifi ESP8266 ESP-12E
• 1 x Potenciômetro Linear 10K

Montando o projeto

Hardware montado

Programando

Este é o código que utilizaremos no desenvolvimento deste tutorial

float leitura;

 void setup() 
{ 
  Serial.begin(115200);
  Serial.println("Leitura do potenciometro");
  Serial.println("Valor        Volts");
}

void loop() 
{
  Serial.print(analogRead(A0));
  Serial.print("         ");
  leitura = (analogRead(A0)*3.3/1023);
  Serial.println(leitura);
  delay(1500);  
}

Colocando para funcionar

Após compilarmos o código apresentado, nós teremos este resultado:

Entendendo a fundo

Software

– Declarando a variável global para armazenar o valor convertido do nível de tensão

Inicialmente, nós vamos declarar uma variável do tipo float para que ao efetuarmos os cálculos referentes à conversão do nível de tensão presente no potenciômetro, esta possa armazenar o resultado da maneira desejada, isto é, sob a forma de números com casas decimais.

float leitura;

– Definindo as configurações iniciais

Dentro da função setup() nós iniciamos a conexão com o Serial Monitor através da função Serial.begin() (passando como parâmetro o valor da taxa de transmissão de dados (como sugestão, utilize este valor)). Além disso, nós vamos utilizar a sentença Serial.println(). Para escrever na tela um título para a nossa aplicação, de modo que, este será "Leitura do potenciômetro". Por fim, recorremos à sentença Serial.println() novamente e enviamos através da porta serial o cabeçalho da tabela que estamos criando (repare que nós demos alguns espaços entre as duas palavras deste cabeçalho justamente para a tabela fique mais agradável de ser visualizada).

 void setup() 
{ 
  Serial.begin(115200); 
  Serial.println("Leitura do potenciômetro"); 
  Serial.println("Valor        Volts"); 
}  

– Lendo o valor do potenciômetro

A primeira ação que nós realizaremos dentro da função loop() será enviarmos o valor referente ao sinal de tensão já convertido na escala de 0 a 1023 através da porta serial para ser apresentado no Serial Monitor com a utilização da sentença Serial.print(). Em seguida, utilizamos a sentença Serial.print() novamente para enviar uma série de espaços para que o valor que virá depois (convertido para volts) esteja organizado logo abaixo da palavra Volts que faz parte do cabeçalho da tabela (note que aqui nós utilizamos somente as funções print() e não println() pois assim nós conseguimos escrever coisas na mesma linha).

Posteriormente, nós convertemos o valor obtido através da entrada analógica do nosso módulo ESP8266 NodeMCU para uma escala em volts e inserimos o resultado na variável leitura, de modo que, após este procedimento, nós utilizamos a sentença Serial.println() para fazer com que este valor seja enviado para o Serial Monitor. Por fim, utilizamos a função delay() para determinar o intervalo entre cada uma das aquisições.

void loop() 
{
  Serial.print(analogRead(A0));
  Serial.print("         ");
  leitura = (analogRead(A0)*3.3/1023);
  Serial.println(leitura);
  delay(1500);  
}

Considerações finais

Neste tutorial, nós demonstramos como você pode fazer para realizar a leitura de valores de sinais de tensão provenientes de um potenciômetro através de um módulo ESP8266 NodeMCU.  Esperamos que continue nos acompanhando e sinta-se à vontade para nos dar sugestões. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira

Utilizando CSS3 para customizar interface Web

Utilização de CSS3 para customizar interfaces web de controle

Se você acompanha os nossos tutoriais envolvendo a utilização da linguagem HTML com as placas Arduino, este será mais um conteúdo muito interessante que você  certamente irá gostar. Neste tutorial vamos apresentar uma melhoria no tutorial que fizemos sobre a leitura de um sensor de temperatura LM35 utilizando o Arduino como um Servidor Web, de modo que, aproveitaremos a ideia do tutorial citado entretanto vamos utilizar CSS3 para customizar de forma inteligente as informações referentes aos valores provenientes do sensor existente em nosso projeto.

Confira também nossos tutoriais anteriores sobre a utilização do Arduino UNO como um Servidor Web:

• Shield Ethernet W5100 - Criando um Servidor Web com Arduino
• Shield Ethernet W5100 - Monitorando sensores com um Servidor Web
• Shield Ethernet W5100 - Controlando saídas via Servidor Web
• Shield Ethernet W5100 - Acionamento remoto de relés com HTML
• Shield Ethernet W5100 - Controlando um LED RGB via PWM com HTML

[toc]

O que é CSS3?

Nós sabemos que ao desenvolvermos o código HTML de uma aplicação, devemos sempre utilizar as tags que melhor representam os significados das várias partes constituintes do mesmo, pois, como vimos em nossos outros tutoriais, uma das funções da linguagem HTML é atribuir sentido semântico aos elementos existentes em uma determinada página. Entretanto, a utilização das tags estruturais mais adequadas não é suficiente para que a aplicação possua uma aparência estética bem elaborada, pois, o uso das mesmas produz resultados contidos em uma espécie de estilo padrão. Sendo assim, podemos supor que exista alguma maneira de driblarmos este impasse através da possibilidade de customização do design dos elementos de uma página web.

Antigamente estes procedimentos de customização eram feitos no através de algumas tags do próprio HTML. Se você quisesse, por exemplo, escrever um título com a tag de cabeçalho h1 em vermelho, bastaria utilizar a tag <font>, veja:

<h1><font color="red">Como controlar o meu Arduino pela internet? - Volume II</font></h1>");

Além da tag <font>, várias outras tags de estilo também existiam, no entanto, este procedimento de estilização ficou para trás e apesar de alguns navegadores ainda reconhecerem as mesmas, utilizá-las nos dias de hoje constitui uma má prática. Como alternativa para realizar a customização dos elementos de uma página web, surgiu o CSS (Cascading Style Sheets), que por sua vez, consiste em um recurso semelhante a uma linguagem de marcação, como o HTML, porém totalmente distinta do mesmo, com objetivo único de cuidar dos procedimentos de estilização.

Uma das vantagens da utilização do CSS é a possibilidade de personalizar os objetos contidos em uma página web sem que seja necessário misturar as regras de estilização com os objetos citados (como acontecia anteriormente).

Sintaxe do CSS3

A sintaxe do CSS consiste em uma simples declaração de propriedades e valores, separados entre si por um sinal de dois pontos ":".

color: red; 
background-color: blue;

CSS3 em um código HTML

Basicamente existem três forma de utilizar os códigos de CSS3 para customizar os elementos existentes em uma página web, entretanto, neste momento vamos nos ater apenas à forma que utiliza o atributo style como porta de entrada para as personalizações dos mesmos. O procedimento a ser seguido é bem simples, de modo que, basta adicionar o atributo style na tag do objeto que você quer manipular. Veja o código abaixo:

<h1 style=propriedade:valor>Vida de Silício</h1>"));

Neste exemplo, a frase "Vida de silício" será exibida com o sentido semântico de uma tag de cabeçalho h1, no entanto, terá sua aparência alterada de acordo com a propriedade e o valor atribuídos à mesma. Perceba que esta maneira de utilizar o CSS3 é praticamente igual ao modo que as customizações eram feitas antigamente (somente com a utilização da linguagem HTML). Além disso, o exemplo apresentado contém apenas um atributo, no entanto, podemos utilizar múltiplos atributos:

<h1 style=color: red; background-color: blue;>Vida de Silício</h1>"));

No código em questão nós declaramos a propriedade color e atribuímos à mesma o valor red (isto significa que a frase citada seja exibida pelo navegador na cor vermelha). Por outro lado, temos também a propriedade background-color, que por sua vez, está associada ao valor blue (este procedimento fará com que a frase "Vida de Silício" seu fundo na cor azul). Existem uma infinidade de atributos que podem ser utilizados para customizar a sua interface de controle, basta fazer uma breve pesquisa que você certamente encontrará uma vasta gama de opções.

Mãos à obra - Monitorando sensores com um Servidor Web

Nesta seção iremos demonstrar todos os passos que você deve seguir para utilizar o CSS3 para customizar o valor de temperatura em sua interface de monitoramento.De maneira mais específica, vamos replicar o projeto em que o usuário consiga monitorar valores de temperatura provenientes de um sensor LM35 (não esqueça de conferir nosso tutorial sobre o sensor de temperatura LM35 clicando aqui) e fazer com que o valor seja apresentado de maneiras diferentes utilizando o CSS3.

Componentes necessários

Para reproduzir este projeto, você irá precisar dos seguintes componentes:

• 1 x Arduino UNO Rev 3
• 1 x Shield Ethernet Wiznet W5100
• 1 x Sensor de temperatura LM35

Montando o projeto

Na figura abaixo você pode conferir o hardware pronto para ser utilizado.

Gostaríamos de sugerir que você tenha bastante cuidado no momento em que for encaixar o Shield Ethernet W5100 no Arduino UNO, pois, além da possibilidade de entortar os pinos do shield, você também pode se machucar.

Lembre-se que o shield em questão possui uma série de pinos em sua parte inferior, tanto nas laterais como em sua parte dianteira, portanto, antes de pressionar o mesmo sobre o Arduino UNO, certifique-se de que os pinos estejam levemente posicionados em suas respectivas entradas para que então você possa ir realizando o encaixe lentamente.

Realizando as conexões

Para reproduzir este projeto, garanta que o seu Shield Ethernet W5100 esteja ligado corretamente a uma das portas LAN presentes no seu modem ou roteador.

Programando

Nesta seção apresentaremos o código da nossa aplicação

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

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 25, 16); 
EthernetServer server(80);     

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


void loop() {

    EthernetClient client = server.available();  

    if (client) 
    {    
        boolean currentLineIsBlank = true;
        while (client.connected()) 
        {
            if (client.available()) 
            {   
                char c = client.read(); 
                
                if (c == '\n' && currentLineIsBlank) {
                  
                    client.println("HTTP/1.1 200 OK");
                    client.println("Content-Type: text/html");
                    client.println("Connection: close");
                    client.println("Refresh: 2");
                    client.println();
                    
                    client.println("<!DOCTYPE html>");
                    client.println("<html>");
                       client.println("<head>");
                          client.println("<title>Servidor Web VDS</title>");
                       client.println("</head>");
                       client.println("<body>");
                          client.println("<h1 style=\"color:#4279c7\">Servidor Web do Vida de Sil&iacute;cio</h1>");
                          client.println("<hr/>");
                          client.println("<h1>Temperatura</h1>");
                          int valor = analogRead(A0); 
                          float temperatura = (((valor*5)/1023)-0.5)*100; 
                          if(temperatura >=50) 
                          { 
                              client.println("<p style=\"color:rgb(255,0,0)\">"); 
                              client.println(LM35: );
                              client.println(temperatura); 
                              client.println("graus"); 
                              client.println("</p>"); 
                          } 
                          else 
                          { 
                              client.println("<p style=\"color:rgb(0,0,0)\">"); 
                              client.println(LM35: );
                              client.println(temperatura); 
                              client.println("graus"); 
                              client.println("</p>"); } 
                        client.println("</body>");
                     client.println("</html>");
                     break;
                     }
                     if (c == '\n') 
                     {    
                     currentLineIsBlank = true;
                     } 
                     else if (c != '\r') 
                     {
                        currentLineIsBlank = false;
                     }
                 } 
              }  
        delay(1);      
        client.stop(); 
    } 
} 

Colocando para funcionar

Veja como ficou nosso segundo Servidor Web.

Entendendo a fundo

Antes de começarmos com a explicação do código, gostaríamos de ressaltar que iremos apresentar os detalhes apenas dos tópicos não contemplados nos nossos outros tutoriais, pois, desta maneira, será mais fácil focarmos nas partes referentes às modificações feitas sobre o programa já existente, portanto, caso você tenha alguma dúvida sobre alguma parte do programa que não seja explicada neste momento, sugerimos que acesse o nosso material citado anteriormente.

Software

- Definindo os pré-requisitos para o funcionamento do código

Inicialmente, devemos incluir duas bibliotecas no código para que o mesmo pudesse funcionar corretamente. A biblioteca SPI.h, responsável pela comunicação dos módulos do shield com o Arduino UNO utilizando o protocolo SPI e a biblioteca Ethernet.h que atua possibilitando a conexão do conjunto, em um primeiro momento, com uma rede local.

Após a inclusão das bibliotecas citadas, devemos definir um endereço MAC (lembre-se que este pode ser qualquer um, desde que seja único em sua rede local) e um endereço IP (este deve ser um endereço válido  e disponível dentro da sua rede local). Além disso, devemos criar o objeto que será responsável por representar o Servidor Web no código (aqui, chamamos este de server) e relacioná-lo com a porta 80.

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

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 25, 16); 
EthernetServer server(80);

- Definindo as configurações iniciais

Dentro da função setup() nós iniciamos a conexão com a rede local através da função Ethernet.begin() (passando como parâmetro os endereços MAC e IP definidos anteriormente) e também iniciamos o Servidor Web por meio da sentença server.begin() (lembre-se que server é o objeto criado para representar o Servidor Web no código).

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

- Criando a página para responder à requisição do navegador

No artigo anterior foi possível compreender como devemos proceder para elaborar uma página bem simples, contendo apenas elementos escritos e também estáticos, ou seja, que não sofriam nenhum tipo de alteração. Neste momento, iremos incrementar o programa criado anteriormente, portanto, vamos deixar de lado a parte referente ao processo de requisição do navegador (já explicado) e iremos focar apenas na elaboração da página que cumpra o objetivo proposto neste material.

Você se lembra do cabeçalho padrão que enviamos para o navegador antes de enviarmos a página propriamente dita? Para ajudar, vamos colocá-lo aqui.

client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close");
client.println();

Definindo tempo de atualização da página 

A primeira modificação que faremos neste momento será a inclusão de uma linha de código que faça com que a página seja atualizada em intervalos de tempo definidos. Isto é importante para este projeto em virtude de estarmos trabalhando com aquisição de variáveis, portanto, devemos atualizar a página periodicamente para que seja possível visualizarmos sempre os valores atuais das variáveis envolvidas. Sendo assim, utilizamos a seguinte sentença para que a página seja atualizada de 2 em 2 segundos.

client.println("Refresh: 2");

Veja como ficará o nosso cabeçalho padrão

client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close");
client.println("Refresh: 2");
client.println();

A estrutura da página em HTML

O próximo passo que faremos será construir, de fato, a página que será enviada ao navegador. Com uma breve recapitulação, devemos lembrar que todo conteúdo que compõe a página deve estar dentro da seguinte estrutura:

client.println("<!DOCTYPE HTML>");
client.println("<html>");
           . 
           .
***** Conteúdo da página *****
           .
           .
client.println("</html>"); 

Como ressaltado anteriormente, dentro desta estrutura temos o conteúdo da página que queremos enviar para o navegador, de modo que, nesta, devemos ter pelo menos dois blocos, um responsável pelas informações gerais do documento, limitado pelo uso do par <head></head> e o outro, por sua vez, deve conter o corpo da página e está entre as tags <body> e </body>.

client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("<head>");
           .
           .
   ***** Bloco 1 *****
           .
           .
client.println("</head>");
client.println("<body>");
           .
           .
   ***** Bloco 2 *****
           .
           .
client.println("</body>");
client.println("</html>");

Definido o título para a página

Neste momento, vamos utilizar apenas uma tag dentro do bloco 1, denominada <title>, cuja função consistirá em definir um título para a página (este título aparecerá na aba do navegador). Para executarmos a ação proposta, devemos colocar o título desejado entre o par <title></title>.

client.println("<!DOCTYPE HTML>");
client.println("<html>");

client.println("<head>");
client.println("<title>Servidor Web VDS</title>"); 
client.println("</head>");

client.println("<body>");
           .
           .
   ***** Bloco 2 *****
           .
           .
client.println("</body>");
client.println("</html>");

Veja como ficou o título da nossa página:

Escrevendo o corpo da página web

Quanto ao corpo da página (entre o par <body></body>), a primeira coisa que faremos será colocar um título visível na própria página. Para realizar este procedimento, utilizaremos a tag <h1>, que por sua vez, consiste em uma tag para apresentar um determinado texto em um modelo predefinido. Além disso, utilizaremos também o atributo style, através do qual, poderemos fazer alterações no título produzido.

client.println("<h1 style=\"color:#4279c7\">Servidor Web do Vida de Sil&iacute;cio</h1>");

Alguns pontos no trecho de código acima devem ser ressaltados:

1. Tudo que estiver escrito entre o par <h1></h1> estará pré formatado no estilo deste cabeçalho.
2. O atributo style é responsável por modificar alguma característica relativa à formatação de uma determinada porção de texto. Para isto, devemos colocar o nome da característica que queremos modificar, após o sinal de igual (=), sendo assim, quando escrevemos <style=\"color:#4279c7\">, estamos indicando que a porção de texto entre o par <h1></h1> deverá está colorida em um certo tom de azul (dado pelo código RGB em hexadecimal #4279c7).
3. Repare que a palavra Silício foi escrita no código como Sil&iacute;cio. Esta forma de escrita é necessária sempre que temos a utilização de algum tipo de acento, pois, nem todos os dispositivos estão configurados para apresentar caracteres acentuados da mesma forma. Sendo assim, utilizamos o comando &iacute; para colocar o acento agudo na letra i da palavra Silício.

Veja o resultado deste procedimento na figura abaixo:

Posteriormente, vamos inserir uma barra horizontal para separar o título criado no passo anterior dos textos que ainda serão criados, através do comando <hr/>.

client.println("<hr/>");

Após a inserção da barra citada, nossa página ficará da seguinte maneira:

Imprimindo a tempertatura

Em seguida, escrevemos outro texto utilizando o modelo de cabeçalho h1 referente ao valor que será obtido pelo sensor de temperatura LM35.

client.println("<h1>Temperatura</h1>");

Com este passo, a página será apresentada assim:

Em seguida, vamos trabalhar sobre a porção de código responsável por exibir a leitura do sensor de temperatura LM35. Primeiramente, utilizamos a função analogRead() para obter o sinal proveniente do sensor de temperatura LM35 e armazená-lo em uma variável do tipo int. Em seguida, realizamos os cálculos para converter o valor obtido pela porta de entrada analógica e inserimos o resultado do mesmo em uma variável do tipo float chamada temperatura, de modo que, caso o valor em questão seja maior do que 50, nós vamos escrever a frase LM35: x graus, entretanto, caso o valor citado seja menor do que 50, a mesma frase será escrita desta maneira LM35: x graus função. Repare que para realizar esta comparação nós utilizamos um conjunto if()/else.

int valor = analogRead(A0); 
float temperatura = (((valor*5)/1023)-0.5)*100; 
if(temperatura >=50) 
{ 
   client.println("<p style=\"color:rgb(255,0,0)\">"); 
   client.println(LM35: );
   client.println(temperatura); 
   client.println(" graus"); 
   client.println("</p>"); 
} 
else 
{ 
   client.println("<p style=\"color:rgb(0,0,0)\">"); 
   client.println(LM35: );
   client.println(temperatura); 
   client.println("graus"); 
   client.println("</p>"); 
}

A apresentação do valor de temperatura ficará conforme a figura abaixo:

Considerações finais

Neste tutorial, demonstramos como você utilizar CSS3 para personalizar alguns elementos do seu projeto, utilizando um Arduino UNO e um Shield Ethernet W5100. Esta foi mais uma parte de uma série de artigos sobre a criação de Servidores Web, portanto, esperamos que continue nos acompanhando e sinta-se à vontade para nos dar sugestões. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira

Módulo TM1637 - Display 4 dígitos com Arduino

Módulo TM1637 - Display 4 dígitos com Arduino

Muitas vezes, nós desenvolvemos alguns projetos de automação, os quais, para desempenharem as suas respectivas funções, necessitam da existência de uma interação entre os mesmos e o usuário. Quando falamos especificamente em sistemas de monitoramento a interação citada pode ser obtida através da utilização de dispositivos como leds, displays LCD e displays de 7 segmentos. Neste tutorial, nós vamos te mostrar como manipular um display de 7 segmentos com 4 dígitos utilizando o módulo TM1637 com display de 4 dígitos em conjunto com uma placa Arduino.

[toc]

A importância das Interfaces Homem-Máquina

Como dissemos anteriormente, em alguns tipos de aplicações é essencial que exista uma possibilidade de interação entre o sistema propriamente dito e o usuário. Dessa forma, nós precisamos de um caminho que torne essa interação possível. O nome desse caminho de comunicação chama-se IHM (Interface Homem Máquina).

IHM é um caminho pelo qual o homem e um projeto de automação podem se comunicar e interagir, visando atingir um objetivo comum.

Geralmente uma IHM é dada por algum tipo de saída como indicadores de velocidades, monitores, displays, auto-falantes, entre outros e algum tipo de entrada, como por exemplo, botões, telas do tipo touchscreen, microfones, câmeras, além de uma infinidade de outros elementos.

Neste momento que os displays de 7 segmentos tomam a atenção para si, pois, uma vasta gama de dispositivos automatizados faz o uso destes elementos pelos motivos que veremos em seguida. Confira aqui os nossos outros tutoriais sobre elementos integrantes de IHMs:

• Display Gráfico 128×64 com Arduino
• Display OLED 0.96″ I2C com Arduino
• Primeiros passos – Display LCD TFT 2.4″ Touchscreen – Descobrindo o drive
• Display LCD 20×4 e 16×2 com Adaptador I2C
• Usando o Display TFT 1.8″ ST7735 com NodeMCU ou Arduino
• Display LCD 16×2 com Arduino
• Display LCD Nokia 5110 – Aprenda como utilizá-lo com seu Arduino

Os displays de 7 segmentos

Como dissemos anteriormente, os displays de 7 segmentos são muito utilizados para comunicação visual em projetos de automação, estando presentes em diversos equipamentos, tais como: relógios, calculadoras e multímetros. Por serem simples de usar, robustos e seguirem um padrão em sua estrutura, estes que permitem imprimir os algarismo arábicos (0 a 9) e até mesmo algumas letras (no caso de displays alfanuméricos).

Como o próprio nome aponta, esse displays possuem 7 segmentos, de modo que, cada um destes corresponde a um led, os quais, são ligados em conjunto, podem formar um algarismo ou uma letra. Os segmentos deste display são identificados por letras que vão de a a g. Além disso, estes também possuem um ponto decimal, normalmente identificado pelas letras dp, veja a disposição dos segmentos conforme a figura abaixo:

Como podemos perceber, a representação de algarismos utilizando um único display é restrita à apresentação dos números contidos no intervalo de 0 a 9, de modo que, para fazermos com que o mesmo mostre algum sinalize algum numeral basta que os segmentos corretos sejam acionados ao mesmo tempo. Por exemplo, caso nosso desejo seja representar o número 0 (zero) nós devemos acender os segmentos a,b,c,d,e,f.

O módulo TM1637

O módulo TM1637 possui um display de 7 segmentos de 4 dígitos (que podem ser tratados como 4 displays de 7 segmentos em conjunto). Ao contrário de uma associação de displays "tradicional" que faria o uso de muitos pinos (no mínimo 7 pinos mais um para ligar e desligar cada display) de uma placa Arduino UNO, este módulo permite que os 4 displays sejam manipulados somente com 2 pinos.

Ao todo, o módulo TM1637 possui 4 pinos, sendo que, dois deles, conforme falamos anteriormente referem-se à manipulação dos displays e os outros 2 possuem a função de alimentar o módulo. Repare que além dos segmentos destinados à representação dos algarismos, existem também segmentos para serem utilizados como ":" (dois pontos) para representação de horas.

Mãos à obra - Utilizando o módulo TM1637 com Arduino

Componentes necessários

Para desenvolver este projeto, precisaremos dos seguintes componentes:

• 1 x Arduino UNO
• 1 x Módulo TM1637 com display 4 dígitos

Montando o projeto

Programando

Neste tutorial, nós vamos implementar uma aplicação na qual o usuário irá digitar um valor numérico de até 4 algarismos no Serial monitor e este mesmo valor será apresentado nos displays existentes no módulo TM1637.

#include <TM1637Display.h>

TM1637Display display(6,7);

int valorfinal;

void setup()
{
  Serial.begin(9600); 
  display.setBrightness(0x0f);
}

void loop() 
{ 
   char comando; 
   String numero; 
   if(Serial.available()>0) 
   { 
      for( int i = 0; i<4; i++) 
      { 
         comando = Serial.read(); 
         numero = numero + comando; 
      }
    valorfinal = numero.toInt(); 
   } 
   display.showNumberDec(valorfinal, false); 
}

Colocando para funcionar

Entendendo a fundo

Software

Neste ponto, serão demonstrados todos os passos para o desenvolvimento do código que deve ser inserido no Arduino UNO para que seja possível a realização da apresentação de algarismos em nosso display 4 dígitos com o módulo TM1637.

– Incluindo a biblioteca que será utilizada

O primeiro passo que devemos realizar para atingir o objetivo proposto consiste na inclusão das bibliotecas adequadas para permitir a interação do módulo TM1637 com o  Arduino UNO. Neste tutorial, nós vamos utilizar a biblioteca TM1637Display.h, que por sua vez, pode ser obtida neste link.

#include <TM1637Display.h>

– Criando o objeto da classe TM1637Display

Na parte de criação de objetos, nós devemos declarar dois parâmetros da implementação do objeto necessário para a manipulação do módulo, de modo que, o primeiro deles diz respeito ao clock, enquanto o segundo refere-se ao pino que será utilizado para a transmissão de dados.

TM1637Display display(6,7);

– Declarando a variável global do projeto

Posteriormente, nós declaramos a variável global valorfinal para armazenar o número inteiro que irá ser apresentado no display.

int valorfinal;

– Definindo as configurações iniciais

Na função setup() nós vamos iniciar a comunicação serial através da sentença Serial.begin() com uma taxa de 9600 bps.

void setup() 
{
  Serial.begin(9600);
  display.setBrightness(0x0f);
}

– Realizando as medidas de temperatura

Dentro da função loop(), nós criamos primeiramente duas variáveis que serão utilizadas para armazenar os valores que serão enviados para o Arduino através da porta serial. A variável comando receberá cada caractere presente na porta serial e a variável numero será responsável por conter o resultado da concatenação dos caracteres que chegarem na variável comando.

O procedimento de escrita dos valores no display tem seu início com a verificação da existência de caracteres para serem lidos no buffer da porta serial através da sentença Serial.available(). Caso exista algo para ser lido, utilizamos uma estrutura de repetição for para realizarmos a leitura de 4 caracteres e em seguida armazená-los na variável numero. Em seguida, convertemos o valor em questão de string para inteiro, que por sua vez, será utilizado como o primeiro argumento da sentença display.showNumberDec() (apenas como curiosidade, o segundo argumento da sentença em questão corresponde a opção de fazer com que o display apresente zeros para completar os 4 algarismos.

void loop()
{
  char comando;
  String numero;
  if(Serial.available()>0)
    {
      for( int i = 0; i<4; i++)
      {
        comando = Serial.read();
        numero = numero + comando;
      }
        valorfinal = numero.toInt();  
    }
  display.showNumberDec(valorfinal, false); 
}

Hardware

Alguns pontos importantes sobre este tutorial

Normalmente, além do que já foi dito, quando falamos em displays de 7 segmentos, nós também abordamos 2 pontos muito pertinentes quanto à manipulação dos mesmos, de modo que, o primeiro deles refere-se à maneira de como os segmentos estão interligados, que por sua vez, caracteriza os displays em questão como displays catodo comum ou anodo comum. Essa característica está ligada . Neste momento nós não vamos abordar este assunto, pois, como veremos posteriormente, a utilização do módulo TM1637 faz com que não seja necessário nos preocuparmos com configuração dos segmentos do display embutido no mesmo, portanto, este assunto será trazido à tona em um outro tutorial mais oportuno.

Além disso, o segundo ponto importante que citamos diz respeito ao procedimento utilizado quando queremos associar dois ou mais displays (utilizando os mesmos pinos de um Arduino para cada um) para mostrarem simultaneamente os diversos algarismos de um mesmo número. Geralmente, nestes casos, utiliza-se uma forma de multiplexar os displays, fazendo acionamentos e desligamentos dos mesmos, em instantes definidos e muito rápidos, porém, da mesma maneira, este assunto não será abordado neste tutorial, pois, a utilização do módulo TM1637 torna a representação de números de mais de um algarismo com mais de um display muito mais fácil.

Considerações finais

Neste tutorial, demonstramos como você deve proceder para utilizar o módulo TM1637 para controlar 4 displays de 7 segmentos. Esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira

Controle remoto e módulo receptor Infravermelho com Arduino

Controle remoto IR com Arduino

Ao longo dos nossos tutoriais nós apresentamos uma infinidade de soluções para que você pudesse desenvolver sistemas de acionamento com botões, com comandos através da IDE do Arduino, com elementos criados a partir de códigos HTML, entre outros. Neste tutorial, nós vamos aprender a realizar acionamentos com mais um elemento, ou melhor, um conjunto de elementos, o kit controle remoto IR + receptor IR.

[toc]

O kit Controle remoto IR + Receptor IR

O kit controle remoto IR + Receptor IR consiste em um conjunto composto por um controle remoto dotado de uma bateria, um módulo receptor de infravermelho, um led infravermelho e alguns jumpers para que o usuário utilize caso seja necessário.

Como funciona o controle remoto infravermelho

Um controle remoto IR é composto por um teclado com diversos botões, um microcontrolador e um LED emissor infravermelho, que em geral ficar em sua parte superior.

Seu princípio de funcionamento é bem simples. No momento em que um dos seus botões é pressionado, uma sequência de pulsos luminosos é emitida através do LED infravermelho. Esta sequência corresponde a um número em hexadecimal, que por sua vez, diz respeito ao código em questão.

Os equipamentos a serem controlados possuem um módulo receptor de infravermelho que recebe os pulsos luminosos e traduz os mesmos em uma sequência de pulsos elétricos.

Sabendo disso, quando vamos implementar alguma aplicação com um controle remoto, nós devemos primeiramente mapear o controle, pois, nós não sabemos o código proveniente de cada botão logo de início. Após conhecermos o resultado de cada um dos comandos de um determinado controle, já podemos partir para o desenvolvimento de alguma solução de automação utilizando o mesmo.

- Modulação Infravermelha

A luz infravermelha é um tipo de radiação emitida pelo sol, lâmpadas e qualquer outra coisa que emane calor. Para que estes outras fontes de radiação infravermelha não interfiram no sinal transmitido entre controle e receptor, é utilizada a técnica de modulação de sinal.

Nessa técnica, inserimos a informação transmitida dentro de outra frequência, que no nosso caso será de 38kHz. Para isso precisamos de um modulador e um demodulador.

O modulador existente dentro do controle remoto transforma o código em hexadecimal que representa o botão pressionado em um sinal dentro da frequência de 38kHz. Posteriormente, o sinal em questão é enviado pelo LED IR.

O demodulador fará parte do módulo receptor, o qual, recebe a informação modulada e faz a demodulação para recuperar a informação original.

A seguir é possível comparar o sinal transmitido e o modulado no osciloscópio.

Em cima vemos o sinal modulado em 38Khz e em baixo vemos o sinal desmodulado.

Mãos à obra - Acionando saídas digitais com o kit Controle remoto IR + Receptor IR

Componentes necessários

Para desenvolver este projeto, precisaremos dos seguintes componentes:

• 1 x Arduino UNO
• 1 x Kit controle remoto IR + Receptor IR
• 1 x Protoboard 830 pontos
• 1 x Led difuso verde
• 1 x Resistor 330 Ω

Montando o projeto

Programando

Neste momento nós iremos apresentar o primeiro código que deve ser utilizado. O programa em questão serve para ajudar o usuário a mapear os botões do controle, ou seja, serve para que o operador do sistema saiba qual será o dado que chegará para a nossa placa Arduino quando um determinado botão for acionado.

#include <IRremote.h>
 
IRrecv receptor(10);
 
decode_results resultado;
 
void setup()
{
  Serial.begin(9600);
  receptor.enableIRIn(); 
}
void loop() 
{
  if (receptor.decode(&resultado)) 
  {
    Serial.println(resultado.value, HEX);
    receptor.resume(); 
  }
  delay(100);
}

Após compilarmos o código apresentado, basta pressionarmos os botões do controle, um a um, para então anotarmos os códigos relacionados a cada um dos mesmos.

Em seguida, nós vamos utilizar um outro código, que por sua vez, será o responsável pelo desenvolvimento da aplicação propriamente dita.

#include <IRremote.h>  
    
IRrecv receptor(10);  
decode_results resultado; 
int codigo; 
  
void setup()  
{  
  pinMode(5, OUTPUT);    
  receptor.enableIRIn(); 
  Serial.begin(9600);
}  
   
void loop()  
{  
  if (receptor.decode(&resultado))  
  {  
    Serial.print("Codigo do botao: ");  
    Serial.println(resultado.value, HEX);  
    codigo = resultado.value; 
    switch (codigo)  
    {  
      case (0xFF6987):   
      digitalWrite (5,HIGH);    
      break;   

      case (0xFF9867): 
      digitalWrite (5,LOW); 
      break;  
    }  
  receptor.resume();  
  }
  delay(100);  
}

Colocando para funcionar

[ Vou incluir uma foto do hardware montado aqui Allan, o que acha?]

Entendendo a fundo

Software - Mapeamento dos botões

Neste ponto, serão demonstrados todos os passos para o desenvolvimento do código que deve ser inserido no Arduino UNO para que seja possível mapearmos os botões do nosso controle IR.

– Incluindo as bibliotecas que serão utilizadas

O primeiro passo que devemos realizar para atingir o objetivo proposto consiste na inclusão da biblioteca adequada para permitir a interação do receptor IR com o Arduino UNO. Neste tutorial, nós vamos utilizar uma biblioteca chamada IRremote.h, que por sua vez, pode ser obtida aqui.

#include <IRremote.h>

– Criando o objeto da classe IRrecv

Na parte de criação de objetos, nós devemos criar um objeto chamado receptor, que por sua vez, está atrelado ao pino que será utilizado para o recebimento de dados por meio do receptor IR.

IRrecv receptor(10);

decode_results resultado;

– Definindo as configurações iniciais

Na função setup() nós vamos iniciar a comunicação serial através da sentença Serial.begin() e em seguida vamos iniciar o funcionamento do nosso receptor IR por meio da sentença receptor.enableIRIn().

void setup()
{
  Serial.begin(9600);
  receptor.enableIRIn(); 
}

void loop() 
{
  if (receptor.decode(&resultado)) 
  {
    Serial.println(resultado.value, HEX);
    receptor.resume(); 
  }
  delay(100);
}

#include <IRremote.h>

– Criando o objeto da classe IRrecv

Na parte de criação de objetos, nós devemos criar um objeto chamado receptor, que por sua vez, está atrelado ao pino que será utilizado para o recebimento de dados por meio do receptor IR.

IRrecv receptor(10);

decode_results resultado;

– Declarando uma variável para armazenar o valor dos botões

Após a criação dos objetos nós devemos declarar um variável do tipo inteiro, cuja função será armazenar o valor recebido pelo receptor IR, para que este possa ser posteriormente utilizado no acionamento de uma saída digital.

int codigo;

– Definindo as configurações iniciais

Na função setup() nós vamos iniciar a comunicação serial através da sentença Serial.begin() e em seguida vamos iniciar o funcionamento do nosso receptor IR por meio da sentença receptor.enableIRIn(). Por último, nós definimos o modo de operação do pino 5 do Arduino UNO para que este atue como uma saída digital.

void setup()
{
  Serial.begin(9600);
  receptor.enableIRIn();
  pinMode(5, OUTPUT);  
}

– Acionando saídas digitais

void loop()  
{  
  if (receptor.decode(&resultado))  
  {  
    Serial.print("Codigo do botao: ");  
    Serial.println(resultado.value, HEX);  
    codigo = resultado.value; 
    switch (codigo)  
    {  
      case (0xFF6987):   
      digitalWrite (5,HIGH);    
      break;   

      case (0xFF9867): 
      digitalWrite (5,LOW); 
      break;  
    }  
  receptor.resume();  
  }
  delay(100);  
}

Considerações finais

Neste tutorial, demonstramos como você deve proceder para realizar acionamentos com o kit controle remoto IR + Receptor IR. Esperamos que você continue nos acompanhando e sinta-se à vontade para nos dar sugestões. Lembre-se de deixar suas dúvidas nos comentários abaixo.

by Daniel Madeira