Menu
Blog Smart Kits
  • Home
  • Arduino
  • ESP32
  • IoT
  • Raspberry Pi
  • Loja Virtual
Blog Smart Kits

Primeiros passos com o Arduino Mega WiFi

Início » Primeiros passos com o Arduino Mega WiFi

Posted on 04/08/2020

No post apresentamos o Arduino Mega e algumas de seus recursos. Agora imagine que legal seria conectá-lo à rede internet e controlá-lo remotamente. Pois é, já inventaram um Arduino desses! O Arduino Mega WiFi . O Arduino Mega Wifi é uma versão não oficial do Arduino Mega que vem com um chip Esp8266 integrado na placa adicionando o recurso de conexão WiFi a placa. Possui a mesma pinagem e algumas melhorias em relação ao seu primo Arduino Mega. Neste post veremos algumas dessas melhorias, e um exemplo simples de um servidor web que controla um pino especifico da placa Mega WiFi.

Comparação entre Mega e o Mega WiFi

Na imagem abaixo podemos ver as duas placas lado a lado.

Figura 1 – Arduino Mega com WiFi e Arduino Mega2560.

Apesar de serem semelhantes o Mega WiFi possui alguns detalhes adicionais de hardware a observar:

Figura 2 – Visão em detalhes do Arduino Mega WiFi.

  • Utiliza entrada micro-USB ao invés de USB tipo B do Arduino Mega comum;
  • Drive USB-Serial CH340G;
  • Uma chave que faz a seleção de um modo de operação, vide seção Montando o Projeto para mais detalhes
  • Uma chave para selecionar qual UART (Serial) do Atmega2560 será conectada ao ESP8266;
  • Um conector Pigtail para conectar uma antena e aumentar a distância que a placa pode ficar do ponto de acesso WiFi.

Na tabela abaixo vemos um comparativo entre algumas especificações dos Arduinos Uno, Mega e Mega WiFi

Figura 3 – Comparativo entre Arduinos Uno, Mega e Mega WiFi.

O Arduino Mega WiFi além da óbvia vantagem sobre o Mega simples que é a conexão WiFi possui alguns recursos que valem a pena serem destacados.

  • Possui memória flash conectada ao ESP8266, de 4MB. (125 vezes a do Mega e 1000 vezes a do Uno);
  • Tensão de entrada recomendada 7~16V. O Mega comum tem faixa de 7~12V;
  • Corrente de saída. Em casos onde é usada alimentação externa os pinos de tensão de saída podem fornecer 1.6A para 5V e 1A para 3.3V. O Arduino Mega comum só pode fornecer 500mA e 50mA para 5V e 3.3V respectivamente.

Figura 4 – Pinos de tensão de saída da placa Mega com WiFi.

Instalação do Arduino Mega WiFi no Arduino IDE

Nessa etapa iremos incluir as placas da família do esp8266 na Arduino IDE. Com a IDE aberta clique em Arquivo -> Preferências:

Figura 5 – Acessando as preferências da Arduino IDE.

Na tela seguinte, digite o link abaixo no campo URLs adicionais de Gerenciadores de Placas:

Figura 6 – Adicionando URLs para o Gerenciador de placas.

https://arduino.esp8266.com/stable/package_esp8266com_index.json

Clique em OK para retornar à tela principal da IDE.

Agora clique em Ferramentas -> Placa -> Gerenciador de Placas:

Figura 7 – Acessando o Gerenciador de placas.

Digite no campo de buscas por esp8266 e selecione o esp8266 by ESP8266 Community e clique em INSTALAR.

Figura 8 – Instalando placas esp8266 na Arduino IDE.

Aguarde alguns minutos até que a instalação seja concluída. As placas da linha ESP8266 já estarão disponíveis na lista de placas da IDE do Arduino.

Exemplo – Servidor Web para controlar pinos

Nesta sessão vamos construir um pequeno servidor para controlar o pino 13 da placa Mega WiFi. O servidor irá nos servir uma página html simples com um botão que irá controlar o estado do pino. Este pino está conectado a um Led já incluso na placa facilitando nosso pequeno teste.Aqui utilizamos um Led mas você pode alterar e utiliza-lo para travar ou destravar uma fechadura, acionar uma lampada, um motor e etc.

Componentes Necessários

  • Arduino Mega WiFi.

Montando o Projeto

Neste exemplo em específico não utilizarei nenhum componente além do próprio Arduino Mega WiFi. Além disso precisaremos de uma rede WiFi na qual a placa Mega irá se conectar.

Antes de fazer a programação devemos observar a posição dos DIP-switches, temos combinações diferentes para gravar o ESP8266 ou o ATmega2560.

Figura 9 – DIP-switches de seleção do modo de gravação.

Logo abaixo temos a tabela com as combinações DIP Switches. Preste bastante atenção antes de fazer a gravação.

Figura 10 – Tabela de modos de gravação.

Também temos uma chave para selecionar a UART que o Mega irá utilizar para se comunicar com o ESP8266. 

Figura 11 – Chave de seleção UART.

Temos a opção de usar a UART3 ou a UART0. Neste post usaremo a UART3.

Programando – ESP8266

Configure a placa Mega WiFi no modo onde o CH340G se conecta ao ESP8266 para upload, conforme a figura 10.

Depois vá até o menu de placas e verifique se a placa ESPDuino (ESP-13 Module) está selecionada. Compile e carregue seguinte código para o ESP8266.

Arduino
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
#include <ESP8266WiFi.h>
 
// Substitua pelas suas credenciais de rede.
const char* ssid     = "sua-rede";
const char* password = "sua-senha";
 
// Defina um servidor com a porta 80.
WiFiServer server(80);
 
// Variável para armazenar a solicitação HTTP.
String header;
 
// Variável para armazenar o estado de saída atual.
String outputState = "Desligado";
 
unsigned long currentTime = millis();
unsigned long previousTime = 0;
// Defina um timeout de 2000 milisegundos.
const long timeoutTime = 2000;
 
void setup() {
  Serial.begin(115200);
  delay(5000);
  // Conecte com a rede Wi-Fi com SSID e senha.
  //Serial.print("Conectando a rede ");
  //Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  // Print local IP address and start web server
  Serial.println("");
  Serial.println("WiFi conectado.");
  Serial.println("IP: ");
  Serial.println(WiFi.localIP());
  //Inicie o servidor.
  server.begin();
}
 
void loop() {
  WiFiClient client = server.available();   // Escute os clientes conectados
  if (client) {                             // Se um novo cliente se conectar
    String currentLine = "";                // Faça uma String para armazenar dados recebidos do cliente
    currentTime = millis();
    previousTime = currentTime;
    while (client.connected() && currentTime - previousTime <= timeoutTime) { // loop enquanto cliente estiver conectado.
      currentTime = millis();
      if (client.available()) {             // Se holver bytes para ler do cliente,
        char c = client.read();             // faça a leitura.
        header += c;
        if (c == '\n') {                    // Se o byte é um caractere de nova linha,
                                            // é o fim da solicitação HTML,entao envie uma resposta.
          if (currentLine.length() == 0) {  
            //Envie um cabeçalho HTTP de resposta.
            client.println("HTTP/1.1 200 OK");
            client.println("Content-type:text/html");
            client.println("Connection: close");
            client.println();
 
            // Procure o trecho "GET /13/on" dentro da solicitação do recebida do cliente.
            if (header.indexOf("GET /13/on") >= 0) {
              //Envie um comando para Mega2560 via serial.
              Serial.println("LED_ON");
              //Altere a variavel de estado.
              outputState = "Ligado";
            } else if (header.indexOf("GET /13/off") >= 0) {
              //Envie um comando para Mega2560 via serial.
              Serial.println("LED_OFF");
              //Altere a variavel de estado.
              outputState = "Desligado";
            }
              // Pagina HTML
              client.println("<!DOCTYPE html><html>");
              client.println("<head><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">");
              client.println("<link rel=\"icon\" href=\"data:,\">");
              // CSS para estilizar a pagina
              client.println("<style>html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}");
              client.println("h1,p {font-weight: bold;color: #126e54; font-size: 32px;}");
              client.println("p {font-size: 16px;}");
              client.println(".button { background-color: #1BAE85; border: none; color: white; padding: 16px 40px;");
              client.println("text-decoration: none; font-size: 30px; margin: 2px; cursor: pointer;}");
              client.println("</style></head>");
 
              client.println("<body><h1>Arduino Mega WiFi Web Server</h1>");
 
              // Mostre o estado atual do pino 13, aqui representado pela variavel de estado outputState.
              client.println("<p>Pino 13 - Estado " + outputState + "</p>");
              // Se outputState estiver como Desligado, crie um botao com texto Ligar.
              if (outputState == "Desligado") {
                client.println("<p><a href=\"/13/on\"><button class=\"button\">Ligar</button></a></p>");
              } else {
                // Se outputState estiver como Ligado, crie um botao com texto Desligar.
                client.println("<p><a href=\"/13/off\"><button class=\"button button2\">Desligar</button></a></p>");
              }
              client.println("</body></html>");
              // A resposta HTTP termina com outra linha em branco.
              client.println();
              break;
            } else { // Se você recebeu uma nova linha, limpe currentLine
              currentLine = "";
            }
          } else if (c != '\r') {  // Se você tiver mais alguma coisa além de um caractere de retorno de carro,
            currentLine += c;      // Adicione-o ao final do currentLine.
          }
        }
      }
      // Limpe a variável de cabeçalho
      header = "";
      // Feche a conexão.
      client.stop();
    }
  }

Programando – Mega2560

Configure a placa Mega WiFi no modo em que o CH340G se conecta ao ATmega2560 para upload, conforme a figura 10.

Após a mudança na sequência de chaves vá até o menu de placas e troque para Mega2560. Compile e carregue seguinte código para o Mega2560.

Arduino
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
String msg;//String para armazenar a mensagem recebida pela porta serial 3.
 
void setup() {
  //Defina o pino LED_BUILTIN (13), como saida.
  pinMode(LED_BUILTIN, OUTPUT);
  //Defina as porta serial para comunicação usb.
  Serial.begin(115200);
  //Defina as porta serial para comunicação com ESP8266.
  Serial3.begin(115200);
}
 
void loop() {
  //Aguarde dados vindos do ESP8266.
  if (Serial3.available()) {
    //Leitura de um byte.
    char data = Serial3.read();
    //Imprima o mesmo dado pela porta usb.
    Serial.print(data);
    //Acrescente o caractere recebido a string de mensagem.
    msg += data;
 
    if (data == 13) {//Limpa a string ao receber caractere CR(Carriage return).
      msg = "";
    }
    if (msg.indexOf("LED_ON") > 0) {//Verifica a ocorrencia do trecho "LED_ON" na mensagem recebida.
      //Ative a saida.
      digitalWrite(LED_BUILTIN, HIGH);
    }
    else if (msg.indexOf("LED_OFF")> 0) {//Verifica a ocorrencia do trecho "LED_OFF" na mensagem recebida.
      //Desligue a saida.
      digitalWrite(LED_BUILTIN, LOW);
    }
  }
  delay(50);
}

Colocando para Funcionar

Primeiramente abra o Monitor Serial e observe qual ip atribuído ao Mega WiFi, reset a placa caso não tenha aparecido nenhuma mensagem.

Figura 12 – Mensagens enviadas pelo Arduino Mega WiFi.

Abra o seu navegador com o ip informado no Serial Monitor. Se tudo estiver funcionando corretamente, uma página semelhante a da imagem abaixo será exibida.

Figura 13 – Pagina HTML gerada pelo Arduino Mega WiFi .

Entendendo o código

Primeiramente vamos analisar as partes mais importantes do código carregado no ESP8266.

A primeira coisa que você precisa fazer é incluir o ESP8266WiFi biblioteca.

Arduino
1
#include <ESP8266WiFi.h>

Troque o conteúdo das variáveis ssid e password pelas respectivas ssid e senha da sua rede WiFi.

Arduino
1
2
3
// Substitua pelas suas credenciais de rede.
const char* ssid     = "sua-rede";
const char* password = "sua-senha";

Em seguida, você define seu servidor da Web para a porta 80.

1
2
// Defina um servidor com a porta 80.
WiFiServer server(80);

Dentro da função setup() configure a porta serial para 115200 de baudrate,que será utilizada para enviar informações para o ATmega2560, como o IP por exemplo.

1
Serial.begin(115200);

Em seguida o ESP8266 irá tenta se conectar a rede com as credenciais definidas acima. E enviará as informações  via serial ao ATmega2560.

1
2
3
4
5
6
7
8
9
10
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
// Print local IP address and start web server
Serial.println("");
Serial.println("WiFi conectado.");
Serial.print("IP: ");
Serial.println(WiFi.localIP());

Inicie o servidor web.

1
2
 //Inicie o servidor.
server.begin();

Na função loop() serão tratadas as solicitações dos clientes que se conectarem ao nosso servidor web.

O ESP8266 está sempre ouvindo os clientes conectados com esta linha:

1
WiFiClient client = server.available(); // Escute os clientes conectados

Quando uma solicitação é recebida de um cliente, salvaremos os dados recebidos. O loop while a seguir estará em execução enquanto o cliente permanecer conectado.

1
2
3
4
5
6
7
while (client.connected() && currentTime - previousTime <= timeoutTime) { // loop enquanto cliente estiver conectado.
      currentTime = millis();
      if (client.available()) {             // Se holver bytes para ler do cliente,
        char c = client.read();             // faça a leitura.
        header += c;
      //Outras tarefas ...
}

Após fazer a leitura de toda solicitação recebida do cliente, podemos verificar qual URL está sendo recebida, pois ela irá mudar dependendo do comando que usamos. Arbitrei que “/13/on” será usada para ativar e “/13/off” para desativar. Após verificar qual dessas opções foi recebida, envie uma mensagem correspondente via serial ao ATmega2560.

1
2
3
4
5
6
7
8
9
10
11
12
// Procure o trecho "GET /13/on" dentro da solicitação do recebida do cliente.
            if (header.indexOf("GET /13/on") >= 0) {
              //Envie um comando para Mega2560 via serial.
              Serial.println("LED_ON");
              //Altere a variavel de estado.
              outputState = "Ligado";
            } else if (header.indexOf("GET /13/off") >= 0) {
              //Envie um comando para Mega2560 via serial.
              Serial.println("LED_OFF");
              //Altere a variavel de estado.
              outputState = "Desligado";
            }

Logo após enviaremos uma página de resposta ao cliente.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// Pagina HTML
              client.println("<!DOCTYPE html><html>");
              client.println("<head><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">");
              client.println("<link rel=\"icon\" href=\"data:,\">");
              // CSS para estilizar a pagina
              client.println("<style>html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}");
              client.println("h1,p {font-weight: bold;color: #126e54; font-size: 32px;}");
              client.println("p {font-size: 16px;}");
              client.println(".button { background-color: #1BAE85; border: none; color: white; padding: 16px 40px;");
              client.println("text-decoration: none; font-size: 30px; margin: 2px; cursor: pointer;}");
              client.println("</style></head>");
 
              client.println("<body><h1>Arduino Mega WiFi Web Server</h1>");
 
              // Mostre o estado atual do pino 13, aqui representado pela variavel de estado outputState.
              client.println("<p>Pino 13 - Estado " + outputState + "</p>");
              // Se outputState estiver como Desligado, crie um botao com texto Ligar.
              if (outputState == "Desligado") {
                client.println("<p><a href=\"/13/on\"><button class=\"button\">Ligar</button></a></p>");
              } else {
                // Se outputState estiver como Ligado, crie um botao com texto Desligar.
                client.println("<p><a href=\"/13/off\"><button class=\"button button2\">Desligar</button></a></p>");
              }
              client.println("</body></html>");
              // A resposta HTTP termina com outra linha em branco.
              client.println();
              break;
            } else { // Se você recebeu uma nova linha, limpe currentLine
              currentLine = "";
            }
          } else if (c != '\r') {  // Se você tiver mais alguma coisa além de um caractere de retorno de carro,
            currentLine += c;      // Adicione-o ao final do currentLine.
          }
        }
      }
      // Limpe a variável de cabeçalho
      header = "";
      // Fece a conexao.
      client.stop();

Vale destacar que a página será ligeiramente diferente dependendo da solicitação do cliente.Por exemplo se o cliente mandou o comando para ativar a saída do Arduino, enviaremos uma página com um botão escrito “Desligar” com um link para “/13/off” para que o cliente tenha somente a opção de desligar.

1
2
3
4
5
6
7
8
9
// Mostre o estado atual do pino 13, aqui representado pela variavel de estado outputState.
              client.println("<p>Pino 13 - Estado " + outputState + "</p>");
              // Se outputState estiver como Desligado, crie um botao com texto Ligar.
              if (outputState == "Desligado") {
                client.println("<p><a href=\"/13/on\"><button class=\"button\">Ligar</button></a></p>");
              } else {
                // Se outputState estiver como Ligado, crie um botao com texto Desligar.
                client.println("<p><a href=\"/13/off\"><button class=\"button button2\">Desligar</button></a></p>");
              }

Agora vamos dar uma olhada no código para o ATmega2560. Primeiramente definimos uma string que irá armazenar as mensagens recebidas do ESP8266.

1
String msg;//String para armazenar a mensagem recebida pela porta serial 3.

Configuramos o pino 13 como saída digital, aqui usamos a definição LED_BUILTIN pois faz referência ao pino que controla o LED integrado da placa, geralmente o 13. 

1
2
//Defina o pino LED_BUILTIN (13), como saida.
  pinMode(LED_BUILTIN, OUTPUT);

Definimos as duas portas seriais que serão utilizadas, a Serial3 está conectada ao ESP8266 e a Serial simples está conectada ao CH340G.

1
2
3
4
//Defina as porta serial para comunicação usb.
  Serial.begin(115200);
  //Defina as porta serial para comunicação com ESP8266.
  Serial3.begin(115200);

Dentro da função loop() o Mega2560 ficará sempre verificando o buffer da UART3, se existir algum dado, este será lido e replicado para a UART0 e enviado via USB para o usuário.

1
2
3
4
//Leitura de um byte.
char data = Serial3.read();
//Imprima o mesmo dado pela porta usb.
Serial.print(data);

Acrescente cada caracter recebido a nossa string msg.

1
2
//Acrescente o caractere recebido a string de mensagem.
msg += data;

Faça uma busca pelas palavras LED_ON ou LED_OFF. Dependendo do resultado ative ou desative a saida 13.

1
2
3
4
5
6
7
8
if (msg.indexOf("LED_ON") > 0) {//Verifica a ocorrencia do trecho "LED_ON" na mensagem recebida.
      //Ative a saida.
      digitalWrite(LED_BUILTIN, HIGH);
    }
    else if (msg.indexOf("LED_OFF")> 0) {//Verifica a ocorrencia do trecho "LED_OFF" na mensagem recebida.
      //Desligue a saida.
      digitalWrite(LED_BUILTIN, LOW);
    }

Funcionamento

Bom por hoje é tudo. Se interessou pelo modelo Mega WiFi? Visite o site da loja e adquira o seu Arduino Mega WiFi hoje mesmo.

Yure Albuquerque

Graduando em Tecnologia Mecatrônica Industrial. Tenho experiência com Arduino e Raspberry Pi. Atualmente experimentando novas tecnologias como ESP32 e compartilhando no blog da Smart Kits.

See author's posts

Twittar
Compartilhar
Pin
Compartilhar

6 comentários em “Primeiros passos com o Arduino Mega WiFi”

  1. iradj nahal moghaddam disse:
    13/10/2020 às 20:24

    muito obrigado , e parabéns pelo belíssimo trabalho

    Responder
  2. Manassés Batista De Oliveira disse:
    21/10/2020 às 21:25

    Muito bom sua explicação. uma das melhores que já vi. parabens. Gostaria que você fizesse uma com portas analógicas. lendo sensor de voltagem e mostrando na web.

    Responder
    1. Yure Albuquerque disse:
      23/10/2020 às 10:57

      Bom dia Manassés!
      Agradeço pelo comentário e fico feliz que o post tenha ajudado. Também achei sua sugestão um excelente tema para postagens futuras, em breve traremos um post sobre o assunto.
      Abraço.

      Responder
  3. Sergio disse:
    23/11/2020 às 08:39

    Bom dia, existe a possibilidade de usar o Mega wi-fi para montar a impressora 3D e qual o custo benefício ???

    Responder
    1. Yure Albuquerque disse:
      27/11/2020 às 09:57

      Bom dia Sergio, existem projetos de impressoras que usam o Arduino Mega, o Mega WiFi serviria perfeitamente e em acréscimo você teria possibilidade de conecta-lo a rede de local e/ou internet para enviar um aviso remoto sobre o progresso da impressão, ou criar uma interface web de configuração da sua impressora ou até mesmo carregar um arquivo de impressão de forma remota.
      Abraço.

      Responder
      1. Yure Albuquerque disse:
        27/11/2020 às 10:28

        Bom dia Sergio!
        Agradeço pelo comentário, estamos sempre buscando trazer um conteúdo relevante para nossos leitores.
        Abraço.

        Responder

Deixe uma resposta Cancelar resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Postagens recentes

  • Como duplicar a Raspberry Pi
  • Blynk – Medição de temperatura com DS18B20
  • ESP8266 – Cadastro RFID (MFRC522) com webserver
  • ESP8266/32 – Programação sem fio (OTA)
  • Primeiros passos com o Arduino Mega WiFi

Comentários

  • Yure Albuquerque em Primeiros passos com o Arduino Mega WiFi
  • Yure Albuquerque em Primeiros passos com o Arduino Mega WiFi
  • Matheus em Blynk – Medição de temperatura com DS18B20
  • Sergio em Primeiros passos com o Arduino Mega WiFi
  • Maria em ESP8266 – Cadastro RFID (MFRC522) com webserver

Categorias

  • Arduino
  • Embarcados
  • ESP32
  • ESP8266
  • IoT
  • Raspberry Pi

Quem somos

A Smart Kits é uma loja virtual que atua no comércio de componentes eletrônicos, com foco na venda de Arduinos, módulos Shields arduinos, sensores eletrônicos, componentes para automação e robótica. Temos uma grande variedade de componentes e excelentes preços.

Acesse nossa loja

Redes Sociais

Todos os direitos reservados à Blog Smart Kits ©2020 | CNPJ: 20.228.852/0001-48