ESP8266 com Arduino

07/05/2015

ÍNDICE DE CONTEÚDO

Este post faz parte da série ESP8266. Leia também os outros posts da série:

Apresentando o módulo ESP8266
ESP8266 com Arduino

Depois do meu primeiro artigo apresentando o módulo ESP8266, muitos me questionaram quando sairia um post tratando exclusivamente da interface deste módulo com Arduino. Pois bem, mãos à obra, vamos ao post de ESP8266 com Arduino!

Com ênfase para o módulo ESP-01, que se destaca pelo fato de ser projetado para operar como ponte Serial-WiFi ou como um simples controle de IO, será então demonstrado um passo a passo de configuração e uso junto com a placa Arduino Mega 2560.

Download e instalação da biblioteca

Para os amantes de Arduino de plantão, nada melhor do que uma biblioteca na mão para fazer uso do módulo, não? Até pouco tempo atrás, a melhor biblioteca era a ITEADLIB Arduino ESP8266, mas que foi descontinuada pela sua sucessora, a WeeESP8266, também feita e mantida pelo pessoal da ITEAD e que está disponível no GitHub.

Embarcados Experience 2024: Evento Presencial

Participe do Embarcados Experience 2024 em São Paulo. Conhecimento técnico, palestras, workshops e oportunidade de networking com profissionais experientes.

Inscreva-se agora

Ao acessar a página da biblioteca ITEADLIB Arduino WeeESP8266, basta clicar no botão “Download ZIP”, tal como mostrado na Figura 1 adiante:

Figura 1 – Download da biblioteca WeeESP8266

Após isso, será dado início ao download do arquivo “ITEADLIB_Arduino_WeeESP8266-master.zip”, que contém os códigos da biblioteca que iremos utilizar, além de alguns bons exemplos para servir de base.

Caso você tenha curiosidade para olhar mais adiante na página do GitHub da WeeESP8266, há uma boa definição de todas as funções disponíveis, que realizam todas as funções agregadas na biblioteca. Além disso, também há detalhes sobre como utilizar a biblioteca com Arduino UNO ou MEGA, e demais informações. Todavia, vou fornecer aqui uma síntese (em português) destes detalhes, com um simples exemplo de utilização.

Concluído o download do arquivo “ITEADLIB_Arduino_WeeESP8266-master.zip”, há duas formas possíveis de proceder. A primeira, é descompactar o diretório compactado pelo arquivo na pasta libraries, do diretório do Arduino IDE, e abrir novamente o programa Arduino IDE. Outra forma, possível desde a versão do Arduino IDE 1.0.5, é adicionar bibliotecas diretamente pela interface do Arduino IDE. Como a minha versão de Arduino é a 1.6.3 (a mais atual na data do presente artigo), irei proceder com a segunda forma, que é adicionar biblioteca diretamente pelo Arduino IDE. Lembro que, dependendo de onde o Arduino estiver instalado é necessário possuir permissões de administrador para realizar modificações na máquina, ok?

Para adicionar uma biblioteca nova no Arduino, primeiramente inicie o programa Arduino IDE, e vá na opção Sketch do Menu superior. Nesta opção, vá em Import Library… e logo depois em Add Library…, conforme exibido na figura 2:

Figura 2 – Adição de nova biblioteca no Arduino 1.6.3

Nesta última opção, será aberta uma janela para seleção do arquivo ZIP que contém a biblioteca a ser adicionada. Navegue até o diretório em que você colocou ou baixou o arquivo da biblioteca WeeESP8266, selecione este arquivo e clique em “Open” na janela em questão. No meu exemplo, selecionei o arquivo no diretório Downloads coforme exibido na figura 3 a seguir:

Figura 3 – Adição de biblioteca em formato ZIP no Arduino IDE

Feito isso, pronto! A biblioteca WeeESP8266 está agora adicionada ao seu Arduino IDE e pode ser usada em futuros projetos. Agora… Vamos colocar a mão em fios!

Conexão do ESP8266 com Arduino

O módulo ESP8266 é projetado para operar em níveis de tensão de 3,3V. Ou seja, se ele receber níveis de tensão acima deste, poderá ser danificado!

Alguns podem levantar a seguinte questão: “Ah, mas e aquele sinal de 3,3V do Arduino?!”
Esse sinal é apenas para alimentação elétrica. Os sinais de PWM, comunicação, digital, e todos os outros do Arduino operam na casa de 5V. Aí que está o problema, em se tratando da interface com módulos e periféricos que operam em 3,3V!

A maioria dos Arduinos comercializados trabalha com lógica de 5V, o que torna perigoso o seu contato direto e sem preparo com o módulo ESP8266. Então… O que fazer? Para conectar as placas exibidas na figura 4:

Figura 4 – Como conectar um Arduino de 5V em um ESP8266 de 3.3V?

Mas, não fique triste, há várias soluções! A primeira e mais barata, mas não 100% confiável, é usar um divisor de tensão, usando um resistor de 10Kohm e outro de 20Kohm. O site iot-playground informa em detalhes sobre o preparo de interface do Arduino em lógica de 5V para o ESP8266, que opera em 3,3V. A figura 5 exibe um modelo de divisor de tensão a ser empregado para os sinais que saem do Arduino rumo ao ESP8266. No caso, é um exemplo de divisor que trabalha o sinal do TX do Arduino, para o sinal RX do módulo. Qual a maior desvantagem dessa solução? É que para cada sinal de entrada no ESP8266 deve receber até no máximo 3.3V, ou seja, você terá que fazer um divisor deste tipo para cada sinal que sair do Arduino para entrar no módulo.

Outra solução, mais confiável, é usar um buffer não-inversor, como por exemplo o CD4050 exibido na figura 6:

A vantagem de usar o buffer CD4050 é que é um CI barato, fácil de encontrar, e fácil de utilizar. Basta alimentar o circuito com 3,3V, como por exemplo aquele 3,3V fornecido pelo Arduino, e as entradas de 5V que ele receber serão então transformadas em 3,3V nas suas respectivas saídas. Para mais detalhes, consulte o datasheet do CD4050. Além disso, usando um único buffer você consegue trabalhar com 6 entradas passíveis de serem modificadas de 5V para 3,3V!

Lembrem-se que o problema é do lado do ESP8266! Não é problema algum o Arduino receber sinais em 3,3V, por exemplo.

Pinagem do ESP8266

Feito isso, devemos também nos ater à pinagem e características de operação do ESP8266, lembrando do meu post apresentando o módulo ESP8266. A figura 7 exibe a pinagem do módulo ESP8266, modelo ESP-01:

Vcc: Tensão de alimentação 3,3V. Módulo consome até 300 mA;
GND: Sinal de Terra GND;
Tx: Sinal de Tx do módulo, a ser conectado no Rx do microcontrolador (Sinal em 3,3V);
Rx: Sinal de Rx do módulo, a ser conectado no Tx do microcontrolador (Cuidado! Sinal em 3,3V!);
RST: Sinal de Reset/Restart acionado em nível baixo (GND);
CH_PD: Sinal de habilitação do chip (chip enable), usado para gravação de firmware ou atualização. Deve ser mantido em nível ALTO para operação normal;
GPIO0: Pode ser controlado pelo firmware, e deve ser colocado em nível baixo (GND) para modo update, ou em nível alto para operação normal;
GPIO2: I/O que pode ser controlada pelo firmware;
LED: Quando está ligado, fica aceso em cor Vermelha, e aciona a cor Azul para indicar atividade. Pisca uma vez para indicar momento de boot.

Ligação do ESP8266 no Arduino

Com base na pinagem mostrada, mostro um exemplo do que temos que fazer, em se tratando do uso conjunto de um Arduino UNO/MEGA ou equivalente, para o ESP8266:

VCC: Ligado no sinal de 3,3V do Arduino;
GND: Ligado no gnd do Arduino;
Tx: Ligado no RX1 do Arduino Mega, ou em um sinal de Serial via Software no UNO;
Rx: Ligado na saída 2 do CD4050 – Entrada de sinal, só pode receber 3,3V;
CH_PD: ligado na saída 4 do CD4050 – Entrada de sinal, só pode receber 3,3V;
RST: ligado na saída 6 do CD4050 – Entrada de sinal, só pode receber 3,3V;
GPIO0: ligado na saída 15 do CD4050 – Entrada de sinal, só pode receber 3,3V.

Já com relação ao Arduino, irei usar o Arduino Mega2560 R3, pelo fato de o mesmo possuir várias interfaces Seriais nativas. No meu Arduino, fiz a seguinte relação de conexões:

ESP8266 Tx –> Ligado no RX1 do Arduino Mega – Cor amarela no esquemático;
Sinal Tx1 do Arduino Mega – Entrada 3 do CD4050 – Ajuste de 5V para 3,3V – Cor verde no esquemático;
Sinal 44 do Arduino Mega – Entrada 5 do CD4050 – Controle do CH_PD do ESP8266 – Cor cinza no esquemático;
Sinal 46 do Arduino Mega – Entrada 7 do CD4050 – Controle de RST do ESP8266 – Cor “marrom” no esquemático;
Sinal 48 do Arduino Mega – Entrada 14 do CD4050 – Controle do status do GPIO0 do ESP8266 – Cor “azul” no esquemático.

Para demonstrar as conexões realizadas, a figura 8 exibe o esquemático de ligações montado no Fritzing:

Figura 8 – Esquemático de Ligação com Arduino Mega 2560 + CD4050 e ESP8266

Agora que a biblioteca está importada e o circuito está montado, é hora de codificar!

Está vivo?

Antes de tudo, é de suma importância verificar se as conexões foram devidamente realizadas, se há comunicação serial entre o ESP8266 e o Arduino Mega2560. Para tal, com base na montagem feita pelo esquemático da Figura 8, segue o código abaixo em que, carregado no Arduino, irá transformá-lo em uma “Ponte Serial”, ou seja, ele irá apenas encaminhar sinais da serial entre o ESP8266 e, no caso, o computador. E como o Arduino está controlando os sinais CH_PD, RST e GPIO0, os mesmos devem ser incluídos no código e acionados em HIGH para o devido funcionamento do módulo.

#define CH_PD 44 //sinal de controle de CH_PD
#define RST 46 //sinal de controle de RST
#define GPIO0 48 //sinal de controle de GPIO0

void setup() {
  pinMode(CH_PD,OUTPUT);
  pinMode(RST,OUTPUT);
  pinMode(GPIO0,OUTPUT);
  digitalWrite(CH_PD,HIGH); //Setado em alto - funcionamento normal
  digitalWrite(RST,HIGH); //RST em alto - funcionamento normal
  digitalWrite(GPIO0,HIGH); //GPIO0 em alto - funcionamento no rmal
  // Inicializa ambas as portas
  Serial.begin(9600);
  Serial1.begin(9600);
}

void loop() {
  // Ve se tem sinal na Serial1 e manda para a Serial
  if (Serial1.available()) {
    int inByte = Serial1.read();
    Serial.write(inByte);
  }

  // Analogamente, ve se tem sinal na Serial, e manda para Serial1
  if (Serial.available()) {
    int inByte = Serial.read();
    Serial1.write(inByte);
  }
}

#define CH_PD 44 //sinal de controle de CH_PD

#define RST 46 //sinal de controle de RST

#define GPIO0 48 //sinal de controle de GPIO0

void setup() {

pinMode(CH_PD,OUTPUT);

pinMode(RST,OUTPUT);

pinMode(GPIO0,OUTPUT);

digitalWrite(CH_PD,HIGH); //Setado em alto - funcionamento normal

digitalWrite(RST,HIGH); //RST em alto - funcionamento normal

digitalWrite(GPIO0,HIGH); //GPIO0 em alto - funcionamento no rmal

// Inicializa ambas as portas

Serial.begin(9600);

Serial1.begin(9600);

}

void loop() {

// Ve se tem sinal na Serial1 e manda para a Serial

if (Serial1.available()) {

int inByte = Serial1.read();

Serial.write(inByte);

}

// Analogamente, ve se tem sinal na Serial, e manda para Serial1

if (Serial.available()) {

int inByte = Serial.read();

Serial1.write(inByte);

}

Após gravar o código, foi aberto o “Serial Monitor” do Arduino IDE, e a velocidade de comunicação foi setada em 9600 baud. Com isso, o módulo já forneceu um retorno, informando versão de firmware como “0.9.2.4”, e respondeu “OK” a um comando “AT” enviado pela serial, indicando então que está tudo ok, como mostrado na Figura 9 adiante:

Figura 9 – Comunicação serial com sucesso!

Seu módulo funcionou com este teste? Caso negativo, pode ser que seu módulo tenha vindo de fábrica com um firmware que opere com serial em velocidade de 115200 baud. Neste caso, basta mudar ambas as velocidades do código, a saber, Serial e da Serial1, para 115200, e lembre-se de alterar também a velocidade do “Serial Monitor” para 115200 baud, uma opção que está no canto inferior direito da janela. E caso não tenha operado nem com 9600 baud nem com 115200 baud, que são as velocidades mais comuns destes módulos, aí seu problema pode ser outro!

Considerações da Biblioteca weeESP8266

Esta biblioteca é muito versátil, e pode considerar o uso de duas vertentes de firmwares do ESP8266, e também pode considerar o uso de Serial via Software ou via Hardware. Entretanto, essas modificações são realizadas no arquivo de cabeçalho da biblioteca “ESP8266.h”. Se você instalou a biblioteca usando o Arduino IDE, a biblioteca está em “Meus Documentos” -> “Arduino” -> “libraries” -> “ITEADLIB_Arduino_WeeESP8266-master”. E neste diretório você encontrará o arquivo “ESP8266.h“, podendo proceder com demais modificações necessárias, conforme apresentado no repositório da ESP8266, para alterar o uso da Serial e o Firmware a ser controlado.

Codificação do primeiro exemplo – ESP8266 e Arduino

Com tudo em ordem, vamos colocar para rodar o exemplo de um servidor de conexão TCP usando o módulo ESP8266.

Poupando demais detalhes, o código está bem comentado em cada parte, e recomendo uma leitura para a compreensão das rotinas e funções.

Novamente, como o Arduino está controlando os sinais CH_PD, RST e GPIO0, os mesmos devem ser incluídos no código e acionados em HIGH para o devido funcionamento do módulo!

#include "ESP8266.h"

#define CH_PD 44
#define RST 46
#define GPIO0 48

//Coloque nos campos indicados o nome e senha da sua rede WiFi
#define SSID        "NOME_DA_SUA_REDE_WIFI"
#define PASSWORD    "senha_da_sua_rede"

//Cria objeto de conexão wifi com o módulo, usando a Serial1 do Mega.
ESP8266 wifi(Serial1);

void setup(void)
{
    pinMode(CH_PD,OUTPUT);
    pinMode(RST,OUTPUT);
    pinMode(GPIO0,OUTPUT);
    digitalWrite(CH_PD,HIGH); //setado em ALTO - operacao normal
    digitalWrite(RST,HIGH); //setado em ALTO - operhttps://embarcados.com.br/arduino-mega-2560/acao normal
    digitalWrite(GPIO0,HIGH); //setado em ALTO - operacao normal

    Serial.begin(9600);
    Serial.println("Iniciando Setup.");
    
    Serial.print("Versao de Firmware ESP8266: ");
    //A funcao wifi.getVersion() retorna a versao de firmware informada pelo modulo no inicio da comunicacao
    Serial.println(wifi.getVersion().c_str());
      
    //Vamos setar o modulo para operar em modo Station (conecta em WiFi) e modo AP (é um ponto de WiFi tambem)
    if (wifi.setOprToStationSoftAP()) {
        Serial.println("Station e AP OK.");
    } else {
        Serial.println("Erro em setar Station e AP.");
    }
 
    //Agora vamos conectar no ponto de WiFi informado no inicio do codigo, e ver se corre tudo certo
    if (wifi.joinAP(SSID, PASSWORD)) {
        Serial.println("Conectado com Sucesso.");
        Serial.println("IP: ");
        //rotina wifi.getLocalIP() retorna o IP usado na conexao com AP conectada.
        Serial.println(wifi.getLocalIP().c_str());    
    } else {
        Serial.println("Falha na conexao AP.");
    }
    
    //Agora vamos habiliar a funcionalidade MUX, que permite a realizacao de varias conexoes TCP/UDP
    if (wifi.enableMUX()) {
        Serial.println("Multiplas conexoes OK.");
    } else {
        Serial.println("Erro ao setar multiplas conexoes.");
    }
    
    //Inicia servidor TCP na porta 8090 (veja depois a funcao "startServer(numero_porta)", que serve para UDP!
    if (wifi.startTCPServer(8090)) {
        Serial.println("Servidor iniciado com sucesso.");
    } else {
        Serial.println("Erro ao iniciar servidor.");
    }    
    Serial.println("Setup finalizado!");
}
 
//Na conexao TCP, basicamente a funcionalidade a ser mostrada sera a de "echo", ou seja, a aplicacao ira retornar todos os //dados enviados para ela via socket TCP.
void loop(void)
{
    //Variavel para buffer de dados de trasmissao
    uint8_t buffer[128] = {0};

    //Como usamos multiplas conexoes, cada conexao tem sua ID, e precisa ser armazenada para referencia no programa. Usamos    //essa variavel para isso.
    uint8_t mux_id;

    //E esta variavel len serve para armazenar o comprimento de dados recebidos por meio da rotina wifi.recv(), que tambem     //associa ao buffer os dados recebidos e ao mux_id a id responsavel pela transmissao
    uint32_t len = wifi.recv(&mux_id, buffer, sizeof(buffer), 100);
    if (len > 0) {
        Serial.print("Status:[");
        Serial.print(wifi.getIPStatus().c_str());
        Serial.println("]");
        
        Serial.print("Recebido de :");
        Serial.print(mux_id);
        Serial.print("[");
        for(uint32_t i = 0; i < len; i++) {
            Serial.print((char)buffer[i]);
        }
        Serial.print("]\r\n");
        
        //Agora envia de volta. A referencia para o socket TCP criado é o mux_id, ou id da conexao, usado aqui na rotina
        //wifi.send, veja abaixo:
        if(wifi.send(mux_id, buffer, len)) {
            Serial.print("Enviado de volta...\r\n");
        } else {
            Serial.print("Erro ao enviar de volta\r\n");
        }
        
        //E, como sempre, liberar a conexao TCP, de modo a permitir que novas conexoes sejam realizadas.
        if (wifi.releaseTCP(mux_id)) {
            Serial.print("Liberando conexao TCP com ID: ");
            Serial.print(mux_id);
            Serial.println(" OK");
        } else {
            Serial.print("Erro ao liberar TCP com ID: ");
            Serial.print(mux_id);
        }
        
        Serial.print("Status:[");
        Serial.print(wifi.getIPStatus().c_str());
        Serial.println("]");
    }
}

100

101

102

103

104

105

106

107

108

109

#include "ESP8266.h"

#define CH_PD 44

#define RST 46

#define GPIO0 48

//Coloque nos campos indicados o nome e senha da sua rede WiFi

#define SSID "NOME_DA_SUA_REDE_WIFI"

#define PASSWORD "senha_da_sua_rede"

//Cria objeto de conexão wifi com o módulo, usando a Serial1 do Mega.

ESP8266 wifi(Serial1);

void setup(void)

{

pinMode(CH_PD,OUTPUT);

pinMode(RST,OUTPUT);

pinMode(GPIO0,OUTPUT);

digitalWrite(CH_PD,HIGH); //setado em ALTO - operacao normal

digitalWrite(RST,HIGH); //setado em ALTO - operhttps://embarcados.com.br/arduino-mega-2560/acao normal

digitalWrite(GPIO0,HIGH); //setado em ALTO - operacao normal

Serial.begin(9600);

Serial.println("Iniciando Setup.");

Serial.print("Versao de Firmware ESP8266: ");

//A funcao wifi.getVersion() retorna a versao de firmware informada pelo modulo no inicio da comunicacao

Serial.println(wifi.getVersion().c_str());

//Vamos setar o modulo para operar em modo Station (conecta em WiFi) e modo AP (é um ponto de WiFi tambem)

if (wifi.setOprToStationSoftAP()) {

Serial.println("Station e AP OK.");

} else {

Serial.println("Erro em setar Station e AP.");

}

//Agora vamos conectar no ponto de WiFi informado no inicio do codigo, e ver se corre tudo certo

if (wifi.joinAP(SSID, PASSWORD)) {

Serial.println("Conectado com Sucesso.");

Serial.println("IP: ");

//rotina wifi.getLocalIP() retorna o IP usado na conexao com AP conectada.

Serial.println(wifi.getLocalIP().c_str());

} else {

Serial.println("Falha na conexao AP.");

}

//Agora vamos habiliar a funcionalidade MUX, que permite a realizacao de varias conexoes TCP/UDP

if (wifi.enableMUX()) {

Serial.println("Multiplas conexoes OK.");

} else {

Serial.println("Erro ao setar multiplas conexoes.");

}

//Inicia servidor TCP na porta 8090 (veja depois a funcao "startServer(numero_porta)", que serve para UDP!

if (wifi.startTCPServer(8090)) {

Serial.println("Servidor iniciado com sucesso.");

} else {

Serial.println("Erro ao iniciar servidor.");

}

Serial.println("Setup finalizado!");

}

//Na conexao TCP, basicamente a funcionalidade a ser mostrada sera a de "echo", ou seja, a aplicacao ira retornar todos os //dados enviados para ela via socket TCP.

void loop(void)

{

//Variavel para buffer de dados de trasmissao

uint8_t buffer[128] = {0};

//Como usamos multiplas conexoes, cada conexao tem sua ID, e precisa ser armazenada para referencia no programa. Usamos //essa variavel para isso.

uint8_t mux_id;

//E esta variavel len serve para armazenar o comprimento de dados recebidos por meio da rotina wifi.recv(), que tambem //associa ao buffer os dados recebidos e ao mux_id a id responsavel pela transmissao

uint32_t len = wifi.recv(&mux_id, buffer, sizeof(buffer), 100);

if (len > 0) {

Serial.print("Status:[");

Serial.print(wifi.getIPStatus().c_str());

Serial.println("]");

Serial.print("Recebido de :");

Serial.print(mux_id);

Serial.print("[");

for(uint32_t i = 0; i < len; i++) {

Serial.print((char)buffer[i]);

}

Serial.print("]\r\n");

//Agora envia de volta. A referencia para o socket TCP criado é o mux_id, ou id da conexao, usado aqui na rotina

//wifi.send, veja abaixo:

if(wifi.send(mux_id, buffer, len)) {

Serial.print("Enviado de volta...\r\n");

} else {

Serial.print("Erro ao enviar de volta\r\n");

}

//E, como sempre, liberar a conexao TCP, de modo a permitir que novas conexoes sejam realizadas.

if (wifi.releaseTCP(mux_id)) {

Serial.print("Liberando conexao TCP com ID: ");

Serial.print(mux_id);

Serial.println(" OK");

} else {

Serial.print("Erro ao liberar TCP com ID: ");

Serial.print(mux_id);

}

Serial.print("Status:[");

Serial.print(wifi.getIPStatus().c_str());

Serial.println("]");

}

Correção: Cuidado com o envio da sequência “!!!” durante a transmissão de mensagens via Serial com o Arduino Mega, operando em velocidade de 115200 baud. O envio dessa sequência faz o Arduino Mega entrar no modo console do bootloader, o que está documentado aqui. Agradecimentos ao usuário Ed Waldo, que destacou o problema nos comentários deste post.

Como o módulo ESP8266 foi configurado como servidor TCP, ele ficará aguardando conexões TCP! Desta forma, a maneira mais indicada para fazer um teste para ver se está tudo OK é usar um programa como o Putty, que é capaz de fazer conexões TCP em formato “raw”, que permite a transmissão direta de dados pelo console terminal.

Com isso, após gravar o código apresentado anteriormente no Arduino Mega2560, configurado para conectar na rede WiFi aqui de casa, é possível ver que tudo correu certo. Começando pelo modo Station e AP, passando pela conexão na minha rede WiFi privada, pela atribuição de IPs, setup de múltiplas conexões e de servidor TCP, como mostrado na Figura 10:

Figura 10 – Módulo ESP8266 configurado com Arduino

Como também pode ser visto na Figura 10, há 2 endereços IP fornecidos pelo módulo, neste exemplo:

192.168.4.1 – Endereço IP do módulo como AP;
192.168.1.21 – Endereço IP do módulo conectado em minha rede privada WiFi.

Qual o motivo de aparecer 2 endereços IP? É porque setamos o módulo como Station e como AP! Assim, ele tanto acessa uma rede WiFi – Modo Station, como também fornece sinal de WiFi – Modo AP, com todas as suas atribuições, como SSID, senha, etc. Como não foi definido nenhum parâmetro para o seu modo AP, ele usa uma atribuição automática e sem senha, e a partir de então fica disponível ao alcance de dispositivos próximos, tal como mostrado na Figura 11:

Figura 11 – Nome do AP criado pelo módulo ESP8266

Neste exemplo, irei conectar ao módulo por meio da minha rede WiFi local, e para testar o projeto usando o Putty, basta abrir o programa, selecionar o tipo de conexão como “Raw“, colocar o IP atribuído ao módulo, que no meu caso foi 192.168.1.21, e a porta correspondente à conexão, 8090 neste exemplo, e clicar em “Open“, como mostrado na Figura 12:

Figura 12 – Configuração do Putty para acesso ao ESP8266 via TCP

Após isso, será aberta uma janela em branco (ou preto, no caso), sem nada à mostra. Vamos digitar um exemplo, “Vai Embarcados!!!“, e apertar ENTER, como mostrado na Figura 13:

Figura 13 – Console do Putty com conexão TCP

Após pressionar ENTER, o que será que aconteceu com o módulo? Vamos conferir na Figura 14:

Figura 14 – Resultado da operação com Putty via TCP

Olha só! Recebeu “Vai Embarcados!!!”

Não estranhem se a janela do Putty fechar. Foi colocado no código para encerrar a conexão TCP ao término do processo. Caso queira mudar o comportamento do programa, basta remover a parte de encerramento da conexão TCP e ver o que acontece!

Então… Pronto! Este foi um simples exemplo de configuração e funcionamento do ESP8266 com Arduino.

Sejam curiosos, vasculhem o GitHub do weeESP8266, vejam as rotinas implementadas em “ESP8266.h”, brinquem! E até a próxima.

Referências

Divisor de tensão de 5V para 3,3V

Buffer não-inversor CD4050

Electrodragon ESP8266

Outros artigos da série

<< Apresentando o módulo ESP8266

André Curvello

60 posts

André Márcio de Lima Curvello é Engenheiro de Computação graduado pela Universidade de São Paulo, campus São Carlos, com ênfase em Sistemas Embarcados. Possui MBA em Gestão de TI pela UNIFRAN, e é Mestre em Processamento de Sinais e Instrumentação pela Escola de Engenharia de São Carlos, USP. Atualmente é Gerente de Desenvolvimento de Firmware na Control iD, empresa líder nos segmentos de Controle de Acesso, Automação Comercial e Relógio de Ponto no Brasil. Também ministra cursos de pós-graduação, extensão e in-company nas áreas de desenvolvimento móvel com Android e Java para Web, Sistemas Embarcados com FPGA, 8051, PIC e ARM, como também Linux Embarcado em sistemas com processadores ARM. Realiza projetos e consultorias com foco no desenvolvimento de sistemas embarcados para internet das coisas, como aplicações em automação de sistemas, domótica, robótica e visão computacional. Ministra palestras, e é articulista do Portal Embarcados.com.br e do Blog FilipeFlop.

Esta obra está licenciada com uma Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.

Comentários:

Notificações

122 Comentários

recentes

antigos mais votados

Inline Feedbacks

View all comments

Celso Roberto Soares Lugo

25/11/2018 12:39

Essa configuração serve para o arduíno uno?

Daniel Fernandaes

24/03/2018 22:33

Cumprimentos André! Gostaria de saber como usar um código feito para o Arduino no ESP8266 NodeMCU; Digo isso pois, o sketch está excedendo a memória do Arduino e eu não sei como diminuí-lo. Sei que estarei desperdiçando muitos benefícios do ESP mas, se não tem outro jeito, prefiro assim. O que está deixando o código muito grande são as 2 fontes mencionadas, DotMatrix_M e SevenSeg_XXXL_Num; Se vc quiser, posso disponibilizá-las aqui. Código: /* UTFT Digital Clock * https://arduino-project.net/chasy-na-arduino-tft01-22sp/ * https://www.youtube.com/watch?v=l2ZvO5DHExo */ #include //inclui a biblioteca DS1307 DS1307 rtc(A4, A5); //inicializa entradas #include //inclui a biblioteca UTFT extern uint8_t DotMatrix_M[]; //Liga… Leia mais »

Antonio Cesario

10/02/2018 22:24

Muito legal seu artigo, mas tenho uma grande problema o meu cliente disponibiliza uma rede wifi excelente só que só é possível fazer a autenticação com um usuário corporativo, ou seja para me conectar ao roteador tenho que colocar nome de usuário senha e ssid como faço nesse caso ?

Ray

20/11/2017 08:58

Olá, tenho uma router CNC controlada por Arduino com grbl. Só que o Arduino se comunica com o PC a todo tempo. Será que tem como trocar a comunicação com fio por esse software? O problema é que o grbl quase enche a memória.

erk 7020

26/03/2016 14:44

ola, estou tendo problemas na hora de compilar linha: Serial1.write(inByte); erro: ”Serial1 was not declaratd in this scope”. Lembrando estou usando o promini.

Diogo Silva

04/02/2016 17:25

Boa tarde pessoal!

Alguém já conseguiu conectar o Arduíno em uma base MySql utilizando o modulo ESP8266 e não o Ethernet Shield ou Shield Wifi ???

Pois estou usando o Arduíno uno com leitor de cartão RFID e mais o modulo Wifi ESP8266, preciso que para cada leitura de um cartão o mesmo se comunique com a base mysql e consulte o usuário do cartão.

Alguém já viu algo assim?

Desde já agradeço a todos pela atenção.

Neto Marin

01/02/2016 16:08

Olá André, parabéns pelo post, é mto útil. Gostaria de uma pequena ajuda, se possível. Comprei o CD4050 hoje para tentar funcionar, e fiz as ligações em um Arduino Uno. Bem parecido como vc falou, a única coisa é que ao invés de ligar os fios da porta CH_PD, RST e GPIO0 também no Arduino, deixei só ligado no CD4050 recebendo 3,3V (medi com multimetro pra ter certeza q estava saindo essa voltagem). A luz vermelha acende e a luz azul pisca quando eu ligo, mas se tento mandar comandos para a serial, não há resposta. Tentei com várias velocidades,… Leia mais »

Bruno T S

23/11/2015 20:10

Ola, montei do jeito certo, ja conferi, e o n tenho problemas na compilação do codigo nem nd, o problema é que quando conecto o TX1 no arduino, a luz azul do modulo desliga, e quando abro o monitor serial, da a msg invalid, o que pode ser?

Letícia Futerko

Reply to Bruno T S

27/07/2022 16:16

Ola, desculpe o incomodo mas gostaria de saber se vc conseguiu arrumar? Pois estou com o mesmo erro e percebi que a data da sua publicação é de 2015, então gostaria de saber se deu certo e como arrumar este erro?