Mostrando postagens com marcador Módulo ESP8266. Mostrar todas as postagens
Mostrando postagens com marcador Módulo ESP8266. Mostrar todas as postagens

terça-feira, 7 de setembro de 2021

Controle remoto via WIFI - nodemcu (ESP8266) - Modo cliente e servidor

 Olá pessoal que acompanha este blog!

    Vou demonstrar aqui como fazer um controle remoto de 3 canais usando o modulo wifi ESP8266 pela interface do Arduino, um das placas estará rodando como servidor web e a outra como cliente web. 

    Para reduzir o tempo de resposta optei por não envia pagina nenhuma apenas o comando para informar o estado dos 3 botões que foram colocados na placa do nodemcu, por ser muito simples e basico não vou colocar o esquemático apenas a imagem da protoboard, creio que seja o suficiente para que vcs entendam o circuito.


    A placa é alimentada com 5V da usb ou 5V de uma fonte externa pelo pino Vin e GND, os leds são ligados a resistores de 220R ao GND e aos pinos D1,D2 e D3.Os botões São ligado ao GND e ao pinos D1,D2,D3 diretamente pois não precisam de resistores externos de pull up´s. Coloquei as placas uma ao lado da outra pra facilitar a visualização e o vídeo veja abaixo ( https://youtu.be/KVtNlUg0EF0):


O código fonte:

Código do servidor (lê os botões):

//desenvolvedor: Aguivone M. Fogia
//Data : 07/09/2021                        // Deu certo
//Blog: Microcontroladores-C 
//exemplo com NodeMCU - modo servidor
#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>//caso use o modo servidor

//------------------------------------------------------------------------------------
// definição dos pinos
//------------------------------------------------------------------------------------
#define       LED         2        // led do modulo wifi
#define       BOT_1        D1         // botão 1
#define       BOT_2        D2         // botão 2
#define       BOT_3        D3         // botão 3

WiFiServer server(80);//usa porta 80

void setup() 
{
  pinMode(LED, OUTPUT);        // inicializa o led da placa
  pinMode(BOT_1, INPUT_PULLUP);  // habilita pull up interno do pino
  pinMode(BOT_2, INPUT_PULLUP);  // habilita pull up interno do pino
  pinMode(BOT_3, INPUT_PULLUP);  /// habilita pull up interno do pino
  setupWiFi();  
}

void loop() 
{
  // checa se tem algum dispositivo conectado!
  WiFiClient client = server.available();
  if (!client) 
      { 
       digitalWrite(LED, LOW);
       delay(100); 
       digitalWrite(LED, HIGH);
       delay(100); //espera conexão   
       return;
       }

  // Lê a primeir linha dos dados recebidos pelo pacote ethernet
  String req = client.readStringUntil('\r');
  client.flush(); 

  // prepara pagina ehtenet
  String s = "S-";
  if (digitalRead(BOT_1) == LOW)                         //botão pressionado
  {
    s += "1";
  }
  else
  {
    s += "0"; 
  } 
  if (digitalRead(BOT_2) == LOW)                         //botão pressionado
  {
    s += "1";
  }
  else
  {
    s += "0"; 
  } 
  if (digitalRead(BOT_3) == LOW)                         //botão pressionado
  {
    s += "1";
  }
  else
  {
    s += "0"; 
  }
  s += "*\n";
  // envia dados
  client.print(s);
  delay(100); //tempo de tratamento por parte do cliente
  //cliente desconectado
  // a cada requisição a pagina é enviada e o cliente é desconectado
}

void setupWiFi()
{
    //////////////////////
    // definições da WiFi  //
    //////////////////////
  const char*  WiFi_Senha = "123456789";//senha que você quer usar(deve ser em branco(aberta) ou maior que 8 caráteres,senão não funciona e não troca o nome da wifi)

  const char*  WiFi_Nome = "MICROCONTROLADORES-C";//nome que você quer dar a sua rede 
  IPAddress ip(192,168,50,4);//ok
  IPAddress gateway(192,168,50,1);//ok
  IPAddress subnet(255,255,255,0);//ok
  //////inicializa a wifi//////////////////////////////////////////////  
  uint8_t mac[WL_MAC_ADDR_LENGTH];
  WiFi.softAPmacAddress(mac);//mac qualquer pra testar
  WiFi.softAPConfig(ip, gateway, subnet);
  WiFi.mode(WIFI_STA);//modo acess point e servidor
  //  WiFi.mode(WIFI_AP_STA);//modo acess point e servidor
  WiFi.softAP(WiFi_Nome, WiFi_Senha); 
  WiFi.begin(); 
  server.begin();
}

Código do cliente(aciona os leds):

//desenvolvedor: Aguivone M. Fogia
//Data : 07/09/2021                        // Deu certo
//Blog: Microcontroladores-C 
//exemplo com NodeMCU - modo cliente
#include <ESP8266WiFi.h>

#define       LED       2        // led do modulo wifi
#define       LED1      D1        
#define       LED2      D2        
#define       LED3      D3        

char nome_wifi[] = "MICROCONTROLADORES-C";                // nome da rede wifi
char senha[] = "123456789";                          // senha deve ter no minimo 8 caracteres 

const char* host = "192.168.50.4";


void setup()
{
  Serial.begin(115200);
  pinMode(LED, OUTPUT);        // inicializa o led da placa
  pinMode(LED1, OUTPUT); 
  pinMode(LED2, OUTPUT); 
  pinMode(LED3, OUTPUT); 
  digitalWrite(LED1, LOW);
  digitalWrite(LED2, LOW);
  digitalWrite(LED3, LOW);
  Serial.println();

  Serial.printf("Connecting to %s ", nome_wifi);
  WiFi.begin(nome_wifi,senha);
  while (WiFi.status() != WL_CONNECTED)
  {
       digitalWrite(LED, LOW);//sem conexão pisca led da placa do node
       delay(300); 
       digitalWrite(LED, HIGH);
       delay(300); //espera conexão
  }
  Serial.println(" connected");
}


void loop()
{
  WiFiClient client;

  Serial.printf("\n[Connecting to %s ... ", host);
  if (client.connect(host, 80))
  {
    Serial.println("connected]");
    Serial.println("[Sending a request]");
    client.print(String("GET /") + " HTTP/1.1\r\n" +
                 "Host: " + host + "\r\n" +
                 "Connection: close\r\n" +
                 "\r\n"
                );

    Serial.println("[Response:]");
    while (client.connected() || client.available())
    {
      if (client.available())
      {
        String pacote = client.readStringUntil('\n');
        Serial.println(pacote);          
          if(pacote.indexOf("*")> 0) 
          {
             int pos = pacote.indexOf("*");
             if(pacote[pos-1]=='1')
             {
               digitalWrite(LED1,HIGH); 
             }
             else
             {
              digitalWrite(LED1,LOW);
             }
             if(pacote[pos-2]=='1')
             {
               digitalWrite(LED2,HIGH); 
             }
             else
             {
              digitalWrite(LED2,LOW);
             }
             if(pacote[pos-3]=='1')
             {
               digitalWrite(LED3,HIGH); 
             }
             else
             {
              digitalWrite(LED3,LOW);
             }
          }
          else
          {
            digitalWrite(LED1,LOW);
            digitalWrite(LED2,LOW);
            digitalWrite(LED3,LOW); 
          }

          client.flush();        
      }
    }
    client.stop();
    Serial.println("\n[Disconnected]");
  }
  else
  {
    Serial.println("connection failed!]");   
  }
  delay(200);
}

formatado por http://hilite.me/  07/09/2021

Até a próxima! Que a paz de cristo esteja com vcs.

segunda-feira, 5 de fevereiro de 2018

NodeMcu + MQTT + ANDROID = IOT.

            Olá pessoal que acompanha o blog! nos últimos anos temos ouvido falar muito de "internet das coisas" (IOT = internet of things) , uma arquitetura pensada na interação entre dispositivos via internet e estes com o usuário. Este será o primeiro post sobre o assunto e vamos começar com algo simples, vamos colocar 2 leds para representar o acionamento de 2 lâmpadas , e mais 2 leds para representar o acionamento de 2 relés que podem estar ligados a qualquer carga.Isto será feito através de um servidor nas nuvens dedicado a IOT(geralmente chamado de "BROKER"),dentro do conceito do  BROKER existe 2 tipos de informação o publish e o subscribe  que se refere ao envio e o recebimento de dados respectivamente,veja a figura a seguir.
          Apesar do NodeMcu ser o dispositivo a ser acionado e portanto deveria apenas receber dados (subscribe) mas ele também informa quais os tópicos(tipo de dispositivo acionado) que será usado naquela conexão, alem de poder enviar status de controle, sendo por este motivo representado como uma comunicação de envio e recepção.O  protocolo usado para fazer tudo funcionar é chamado de MQTT(Message Queue Telemetry Transport) que será o responsavel por fazer as máquinas conversarem entre si M2M(Machine to Machine).
         Para fazer toda a "mágica" acontecer é preciso ter instalado o software do Arduino com as libs do ESP8266,Abra a janela de preferências na interface Arduino e digite no campo “Additional Board Manager URLs” o seguinte endereço:  http://arduino.esp8266.com/stable/package_esp8266com_index.json , depois é só instalar as bibliotecas indo na aba do gerenciador de placas do Arduino, para usar o MQTT será necessario adicionar a biblioteca "PubSubClient" que pode ser baixada(aqui) e colocada dentro da pasta "libraries" nos arquivos de instalação do Arduino, deve ficar em algo assim "C:\Arduino\arduino-1.8.5\Sketchbook\libraries\PubSubClient" eu preferi deixar a pasta do executável fora da pasta padrão do windows para não ter problemas de acesso a arquivos por parte do programa arduino. Estando com tudo corretamente preparado é só rodar o código fonte que estará anexado a este post.
        Para usar o servidor MQTT vc deve criar seu cadastro(existem vários destes procure o que achar melhor),no meu caso usei o "cloudMQTT", apenas uma obrsevação no video errei ao dizer que os servidores estavam localizados nos EUA, na verdade um fica lá(na Virginia) e o outro na Europa(Irlanda), no  vídeo de demostração vou dar mais detalhes das configurações dele.
       Para usar o Android ou qualquer outro Sistema operacional para Smartphone pode se usar uma solução pronta(existem diversas opções) para gerenciar seu dispositivo, eu usei o "MQTT Dash", no vídeo de demostração abaixo vou dar mais detalhes.
       Para melhor acompanhamento do que está acontecendo com o modulo tudo que é feito é também enviado via porta serial (emulada), ou seja através de um terminal serial RS232 podemos acompanhar todos os passos do circuito.Observe que no codigo o comando para ligar e desligar tanto os reles quanto as lâmpadas(led) é o mesmo, ou seja posso padronizar os mesmos comandos para dispositivos diversos não necessitando ter vários comandos(um pra cada dispositivo).
       O circuito elétrico  de testes da protoboard ficou assim:
        Mas você deve estar se perguntando por que usar um BROKER(servidor nas nuvens) se poderia usar uma simples pagina HTTP?A resposta é devido a 2 fatores, o primeiro é que usando um webservidor você pode acessar seu dispositivo de qualquer ponto do planeta sem a necessidade de fazer muitas configurações(caso contrario precisaria de liberar a porta de seu modem e usar um serviço de DDNS ou VPN).O segundo motivo é que usando um protocolo como o MQTT que foi pensado,preparado e padronizado para o uso de IOT a comunicação é muito mais rápido do que usar uma pagina HTTP.
O código fonte:

//Autor: Aguivone    -  microcontroladores-C
//Descricao: Placa para acionar 4 leds usado um servidor MQTT.
//Data: 18/01/18
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <ESP8266WiFi.h>
#include <PubSubClient.h> // essa lib deve ser adicionada em seu programa do arduino
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//variaveis usadas na inicialização da wifi
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const char* ssid = "nome da wifi"; //Aqui o nome da sua rede local wifi
const char* password =  "senha"; // Aqui a senha da sua rede local wifi
const char* mqttServer = "algumacoisa.cloudmqtt.com"; // Aqui o endereço do seu servidor fornecido pelo site 
const int mqttPort =16000; // Aqui mude para sua porta fornecida pelo site
const char* mqttUser = "xxxxxx"; //  Aqui o nome de usuario fornecido pelo site
const char* mqttPassword = "hfjuytsgeh"; //  Aqui sua senha fornecida pelo site

WiFiClient espClient;
PubSubClient client(espClient);
/*
Equivalencia das saidas Digitais entre nodeMCU e ESP8266 (na IDE do Arduino)
-------------------------------------------------
NodeMCU / ESP8266  |  NodeMCU / ESP8266  |
D0 = 16            |  D6 = 12            |
D1 = 5             |  D7 = 13            |
D2 = 4             |  D8 = 15            |
D3 = 0             |  D9 = 3             |
D4 = 2             |  D10 = 1            |
D5 = 14            |                     |
-------------------------------------------------
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Definindo o nome dos pinos
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const int  LED_STATUS = 2; // led de status(estou usando o led que já vem no modulo esp. 
const int  ANALOGICA = A0; // porta analogica
//////////////configura os pinos dos reles/////////////////////////////
const int RELE1 = 0; 
const int RELE2 = 4;
const int LED1 = 5;
const int LED2 = 14;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//variaveis globais
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void mqtt_callback(char* topic, byte* dados_tcp, unsigned int length);///dados_tcp = payload


void setup() { 
  pinMode(RELE1, OUTPUT);
  pinMode(RELE2, OUTPUT);
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  digitalWrite(RELE1,LOW);//desliga todos os reles
  digitalWrite(RELE2,LOW);
  digitalWrite(LED1,LOW);
  digitalWrite(LED2,LOW);
 
  Serial.begin(115200);
 
  WiFi.begin(ssid, password);
 
  while (WiFi.status() != WL_CONNECTED) 
  {    //inicialmente pisca o led da placa do nodemcu(é a mesma do ESP8266).
     delay(100);
    Serial.println("Conectando a WiFi..");
  }
  Serial.println("Conectado!"); 
  client.setServer(mqttServer, mqttPort);//configura servidor com as informações passadas
  client.setCallback(callback);
 
  while (!client.connected()) {
    Serial.println("Conectando ao servidor MQTT...");
    
    if (client.connect("Placa_leds", mqttUser, mqttPassword ))//colocar aqui o nome do dispositivo cliente("Placa_leds")
    {
 
      Serial.println("Conectado ao servidor MQTT!");  
      digitalWrite(LED_STATUS,HIGH); 
 
    } else {
 
      Serial.print("Falha ao conectar ");
      digitalWrite(LED_STATUS,LOW);
      Serial.print(client.state());
      delay(2000);
 
    }
  }
  
  client.publish("Status - placa_rele","Reiniciado!");
  client.publish("Placa_reles","Em funcionamento!");
  client.subscribe("RELE"); ///envia autorização para trabalhar com os topicos led e relé
  client.subscribe("LED"); 
}
 //////////////////
void callback(char* topic, byte* dados_tcp, unsigned int length) 
{
   String msg ; // cria variavel que será responsavel pelo tratamento das informações
   for(int i = 0; i < length; i++) //converte array de bytes em string
    {  char c = (char)dados_tcp[i];
       msg += c;
    } 
   digitalWrite(LED_STATUS,LOW);
   delay(100);   
   digitalWrite(LED_STATUS,HIGH); //só pra indicar que houve recepção 
   Serial.print("\n\r topico:");//sempre será o escolhido no subscribe
   Serial.print(topic);   
   Serial.print("\n\r Pacote recebido:");
   Serial.print(msg);
   if (strcmp(topic, "RELE") == 0)//recebeu comando para trabalhar com o dispositivo relé
   {
    for (int i = 0; i < length; i++) // Varre o vetor(array) inteiro do pacote recebido 
        {         
          //toma ação dependendo da string recebida:      
      
          if (msg.equals("L1"))
          {
              digitalWrite(RELE1, HIGH);
             
          }
          if (msg.equals("D1"))
          {
              digitalWrite(RELE1, LOW);
             
          }
          if (msg.equals("L2"))
          {
              digitalWrite(RELE2, HIGH);
              
          }
          if (msg.equals("D2"))
          {
              digitalWrite(RELE2, LOW);
              
          }
        }
   }
   if (strcmp(topic, "LED") == 0)//recebeu comando para trabalhar com o dispositivo led
   {
       for (int i = 0; i < length; i++) // Varre o vetor(array) inteiro do pacote recebido 
        {         
          //toma ação dependendo da string recebida:      
      
          if (msg.equals("L1"))
          {
              digitalWrite(LED1, HIGH);
              
          }
          if (msg.equals("D1"))
          {
              digitalWrite(LED1, LOW);
             
          }
          if (msg.equals("L2"))
          {
              digitalWrite(LED2, HIGH);
              
          }
          if (msg.equals("D2"))
          {
              digitalWrite(LED2, LOW);
             
          }
        }
   }
 
}
 
void loop() {        
     client.loop();
}

Vídeo de demonstração e algumas explicações:




            Espero ter ajudado a quem está iniciando neste fantástico mundo da tecnologia da internet das coisas(IOT).espero postar outros exemplos de uso em breve.

terça-feira, 9 de janeiro de 2018

Implementando um temporizador WIFI, com o NodeMcu.

Olá, hoje resolvi demonstrar como gravar o NodeMcu pela interface do arduino, para isto criei um servidor web que mantém um um led aceso conforme um tempo configurado na pagina web que está rodando dentro do próprio modulo, veja que do mesmo modo que é gravado o modulo ESP8266 também é gravado o NodeMcu(o que muda é fisicamente,pois o NodeMcu já vem com todo o hardware necessário para seu funcionamento o que reduz custos e facilita a montagem, principalmente para leigos em eletrônica ),veja que o tempo não é muito preciso pois usa delay de rotinas.
       Este é só o começo da serie de projetos que virão a partir do NodeMcu, em breve postarei novos códigos com mais recursos,por hora fiquem com este exemplo.

O código fonte:

#include <dummy.h>
#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>//caso use o modo servidor
#include "FS.h"
WiFiServer server(80);//usa porta 80
const int  LED_STATUS = 2; // led de status(estou usando o led que já vem no modulo esp. 
const int  ANALOGICA = A0; // porta analogica

//////////////reles/////////////////////////////
const int RELE1 = 5; // neste exemplo vou usar apenas o rele 1
const int RELE2 = 4;
const int RELE3 = 10;
const int RELE4 = 15;

int tempo_pisca_led=500;
long liga_timer=0;
int tempo = 1;//padrão 1s

///////////////////////////////////////////////////////////////////
//////////configurações principais
///////////////////////////////////////////////////////////////////
void setup() 
{
  Serial.begin(115200);
  conf_pinos();  
  setupWiFi();
}
/////////////////////////////////////////////////////////////////////
///rotina prinicpal
/////////////////////////////////////////////////////////////////////
void loop() 
{
  rot_geral();
 // checa se tem algum dispositivo conectado!
  WiFiClient client = server.available();
  if (!client) 
  {return;}

  // Lê a primeir linha dos dados recebidos pelo pacote ethernet
  String req = client.readStringUntil('\r');
  client.flush(); //limpa buffer de recepção
  Serial.println("recebeu pag.");
  // prepara pagina ethenet
  String buf = "";//cria uma string para colocar a pagina web
  //vai adicionando linhas a string criada
  buf += "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html>\r\n";
  buf += "<h1> Servidor Web com ESP8266 </h1>";
  buf += "<h3> Temporizador - configure um tempo de 00 a 60 segundos.</h3>";
  buf += "<h3> coloque os numero no formato XX(por exemplo 1 = 01..</h3>";
  buf += "<h3><p>Iniciar: <a href=\"?b1_on\"><button>ON</button></a> <a href=\"?b1_off\"><button>OFF</button></a></p><br></h3>"; 
  buf += "<form><h3>Segundos: <input type=text name=\"tempo\"\"value=\"mm\"size=3 maxlength=2></h3>";  
  buf += "<h3><input type=\"submit\"  value=\"Configurar. \"></h3>"; 
  buf += "</form><marquee direction=\"right\"> Microcontroladores-c - Temporizador Web </marquee></html>\n";
  client.print(buf);//envia os dados pela wifi
  client.flush();  
  ///avalia o retorno da pagina HTTP
  if (req.indexOf("b1_on") != -1)
    {
      liga_timer=tempo*5;//pois como o pisca é mais rapido e leva 200 ms por incremento deve multiplicar por 5
      Serial.println("Acionou timer tempo:");
      Serial.print(liga_timer,DEC);
    }
  if (req.indexOf("b1_off") != -1)
    {
      liga_timer=0;
      digitalWrite(RELE1, LOW);
      Serial.println("rele desligado!");
    }  
  if(req.indexOf("tempo=") != -1)
  {
    int pos = req.lastIndexOf("tempo=");
    Serial.println("tempo");
    Serial.print('=');
    Serial.print(req[pos+6]);
    Serial.print(req[pos+7]);    
    if((char_to_int(req[pos+6]))*10 + char_to_int(req[pos+7])<61) 
    { tempo = (char_to_int(req[pos+6]))*10 + char_to_int(req[pos+7]) ; 
      Serial.println("foi gravado :");    
      Serial.print(tempo,DEC);
    } //se tempo menor que 60 atualiza valor   
  } 
  //cliente desconectado
  // a cada requisição a pagina é enviada e o cliente é desconectado
}   
 
unsigned int char_to_int(char val)
 {
    int valor =0;
    if((val>47)||(val<58))
    {
      valor = val-48;
    }    
    return(valor);
 }
 
void rot_geral()
{
      if(liga_timer>0)
      {          
          liga_timer--;
          if(liga_timer == 0)
          {
            // fim do tempo
            digitalWrite(RELE1, LOW);
            Serial.println("rele desligado!");
          }
          else
          {
            digitalWrite(RELE1, HIGH);// liga rele 
          }
          digitalWrite(LED_STATUS,HIGH);      
          delay(100);
          digitalWrite(LED_STATUS,LOW);
          delay(100);
      }
      else
      {
          digitalWrite(LED_STATUS,HIGH);      
          delay(tempo_pisca_led);
          digitalWrite(LED_STATUS,LOW);
          delay(tempo_pisca_led);
      }
     return;
}

 
  ////////////////////////////////////////////////////////////////////
//configura os pinos
////////////////////////////////////////////////////////////////////
void conf_pinos()
{  
  pinMode(9, INPUT);//sempre será entrada
  pinMode(LED_STATUS, OUTPUT);
  digitalWrite(LED_STATUS, LOW);
  pinMode(RELE1, OUTPUT);
  digitalWrite(RELE1, LOW);
  pinMode(RELE2, OUTPUT);
  digitalWrite(RELE2, LOW);
  pinMode(RELE3, OUTPUT);
  digitalWrite(RELE3, LOW);
  pinMode(RELE4, OUTPUT);
  digitalWrite(RELE4, LOW);
   return;
}

/////////////////////////////////////////////////////////////////////////
// Parâmetros da WiFi  //
////////////////////////////////////////////////////////////////////////
void setupWiFi()
{
    //////////////////////
    // definições da WiFi  //
    //////////////////////
  const char* WiFi_Senha = "123456789";//senha que você quer usar(deve ser em branco(aberta) ou maior que 8 caráteres,senão não funciona e não troca o nome da wifi)
  const char*  WiFi_Nome = "Microcontroladores-c";//nome que você quer dar a sua rede 
  IPAddress ip(192,168,50,4);//ok
  IPAddress gateway(192,168,50,1);//ok
  IPAddress subnet(255,255,255,0);//ok
  //////inicializa a wifi//////////////////////////////////////////////    
  uint8_t mac[WL_MAC_ADDR_LENGTH];
  WiFi.softAPmacAddress(mac);//mac qualquer pra testar
  WiFi.softAPConfig(ip, gateway, subnet);
  WiFi.softAP(WiFi_Nome, WiFi_Senha); 
 // WiFi.mode(WIFI_AP);//modo acess point(cliente)   
   WiFi.mode(WIFI_AP_STA);//modo acess point e servidor  
   WiFi.begin();  
   server.begin();   
}

A demonstração do código funcionando pode ser visto no vídeo abaixo :

Até a próxima!



quinta-feira, 16 de março de 2017

Acessando a memoria EEprom do chip ESP8266

Olá, neste exemplo vou demostrar como escrever na memória do ESP8266, para isto usei o  mesmo exemplo do ultimo post, somente adaptei uma função que irá escrever e depois ler o que foi escrito na memória rom do chip.
         Veja que a forma de colocar dados na memoria é por identificadores e não por posição de memoria como é feito nos microcontroladores.As informações serão retornadas pela porta serial(rs-232) do chip.

O código fonte:
#include <ESP8266WiFi.h>
#include "FS.h"
const int  LED_STATUS = 2; // led de status 
const int  ANALOGICA = A0; // porta analogica

///emulando uma porta SPI generica - aqui se configura quais pinos se quer usar ////////////////
const int  SPI_CLK = 14; //ligue no sinal de clock
const int  SPI_IN  = 13; //ligue no Mosi 
const int  SPI_OUT = 12; //ligue no Miso
const int  SPI_CS  = 16; //ligue no chip select 


//***********************************************************************************************************
// Registradores do chip DS3234 - endereço de leitura,para escrever basta somar 0X80 ao valor hexadecimal
//***********************************************************************************************************
#define DS3234_SEG               0X00 // registrador de segundos
#define DS3234_MIN               0X01 // registrador de minutos
#define DS3234_HORA              0X02 // registrador de horas
#define DS3234_DIA_SEMANA        0X03 // registrador de dia da semana
#define DS3234_DIA               0X04 // registrador de dia
#define DS3234_MES               0X05 // registrador de Mes
#define DS3234_ANO               0X06 // registrador de ano

#define DS3234_ALM1_SEG          0X07 // registrador Alarme 1 de segundos
#define DS3234_ALM1_MIN          0X08 // registrador Alarme 1 de minutos
#define DS3234_ALM1_HORA         0X09 // registrador Alarme 1 de horas
#define DS3234_ALM1_DIA_SEMANA   0X0A // registrador Alarme 1 de dia e dia da semana

#define DS3234_ALM2_MIN          0X0B // registrador Alarme 2 de minutos
#define DS3234_ALM2_HORA         0X0C // registrador Alarme 2 de horas
#define DS3234_ALM2_DIA_SEMANA   0X0D // registrador Alarme 2 de dia e dia da semana

#define DS3234_CONTROLE          0X0E // registrador de controle(config)
#define DS3234_STAT_CONTROLE     0X0F // registrador de controle e status
#define DS3234_CONF_CRISTAL      0X10 // registrador do cristal interno

#define DS3234_TEMP_H            0X11 // registrador do sensor de temperatura parte alta(msb)) 
#define DS3234_TEMP_L            0X12 // registrador do sensor de temperatura parte baixa(lsb)

#define DS3234_S_RAM             0X18 // registrador da memoria S_RAM
#define DS3234_S_RAM_DADOS       0X18 // registrador da memoria S_RAM dados


void setup() {
  Serial.begin(115200);
  conf_pinos();  
  inicializa_spi();
  inicializa_DS3234(); 
  ler_memo_rom();
}
void loop() {
  digitalWrite(LED_STATUS,HIGH);
  Serial.print("DATA:");
  Serial.print(DS3234_ler_spi(DS3234_DIA), HEX);
  Serial.print("/"); 
  Serial.print(DS3234_ler_spi(DS3234_MES), HEX);
  Serial.print("/");
  Serial.print(DS3234_ler_spi(DS3234_ANO), HEX);
  Serial.print(" -> ");
  Serial.print(DS3234_ler_spi(DS3234_HORA), HEX);
  Serial.print(":");
  Serial.print(DS3234_ler_spi(DS3234_MIN), HEX);
  Serial.print(":");
  Serial.println(DS3234_ler_spi(DS3234_SEG), HEX);
  delay(300);//1s
  digitalWrite(LED_STATUS,LOW);
  delay(300);//1s
}
/*
 * Funções usadas no laço principal
 * eu poderia ter montado uma lib - mas a ideia é compartilhar como se faz 
 * uma comunicação spi com o DS3234 que sirva em qualquer dispositivo.
 */
  ////////////////////////////////////////////////////////////////////
//configura os pinos
////////////////////////////////////////////////////////////////////
void conf_pinos()
{  
  pinMode(9, INPUT);//sempre será entrada
  pinMode(LED_STATUS, OUTPUT);
  digitalWrite(LED_STATUS, LOW);  
   return;
}
 ////////////////////////////////////////////////////////////////////
//lendo a memoria rom do ESP8266
////////////////////////////////////////////////////////////////////
void ler_memo_rom()
{  
  bool result = SPIFFS.begin();
  Serial.println("abrindo SPIFFS : " + result);  
  File f = SPIFFS.open("/f.alame1", "r");  
  if (!f) {  // tenta abrir o arquivo com nome "f.alame1"  
    Serial.println("Arquivo não existe");
    // abre o arquivo em modo escrita
    File f = SPIFFS.open("/f.alame1", "w");//cria ao arquivo 
          if (!f) 
            {
            Serial.println("não foi possivel cria o arquivo!");
            }
    // escreve 2 linhas já colocando o caracter de fim de linha
    f.println("hora=12");
    f.println("minutos=00");
  }
  else 
  {//o arquivo já existe
    Serial.println("Dados da memoria :");
    while(f.available()) //enquanto tiver dados ele lê
    {//cria string para ler um linha a linha do arquivo
      String line = f.readStringUntil('\n');
      Serial.println(line);
    }

  }
  f.close();
}
 ////////////////////////////////////////////////////////////////////
//cria estado padrão dos pinos spi
////////////////////////////////////////////////////////////////////
void inicializa_spi()
{ 
  pinMode(SPI_CLK, OUTPUT);
  digitalWrite(SPI_CLK, HIGH);
  pinMode(SPI_IN, INPUT);
  pinMode(SPI_OUT, OUTPUT);
  digitalWrite(SPI_OUT, LOW);
  pinMode(SPI_CS, OUTPUT);
  digitalWrite(SPI_CS,HIGH);
  return;
}
////////////////////////////////////////////////////////////////////
//inicializa o chip
////////////////////////////////////////////////////////////////////
void inicializa_DS3234()
{
    DS3234_escr_spi(DS3234_CONTROLE,0X80);//80= desliga saida do oscilador , SQ wave @1hz, Alarme desabilitados
    DS3234_escr_spi(DS3234_ANO,0X17);//configura data para 25/08/2017 - 15:05
    DS3234_escr_spi(DS3234_MES,0X02);//colocar os valores sempre em hexadecimal
    DS3234_escr_spi(DS3234_DIA,0X25);
    DS3234_escr_spi(DS3234_HORA,0X15);
    DS3234_escr_spi(DS3234_MIN,0X05);
    return;
}
////////////////////////////////////////////////////////////////////
//essa rotina serve tanto para escrever quanto para ler 
////////////////////////////////////////////////////////////////////
int DS3234_ler_spi_byte(int valor,int liga_cs)
{//já escreve e já lê
  int dados = 0;
  int pos=128;
  digitalWrite(SPI_CS, LOW);
  delayMicroseconds(1); 
  while(pos>0)///bit mais significativo primeiro
  {
      if((valor&pos)>0)//faz uma operaçao and e checa se é 1
        {digitalWrite(SPI_OUT,HIGH);}
      else
        {digitalWrite(SPI_OUT,LOW);}
        digitalWrite(SPI_CLK,LOW);
        delayMicroseconds(1); ///tempo em nivel baixo do clock
        if(digitalRead(SPI_IN)==HIGH)
        {dados = dados|pos;}      
        digitalWrite(SPI_CLK,HIGH);
        delayMicroseconds(1); ///tempo em nivel baixo do clock//tempo em nivel alto do clock
    pos=pos/2;//rotaciona 1 bit
  }
  if(liga_cs == 1)
  {digitalWrite(SPI_CS, HIGH);}
   return(dados);
}
////////////////////////////////////////////////////////////////////
//essa rotina lê um byte do registrador colocado em endereço
////////////////////////////////////////////////////////////////////
int DS3234_ler_spi(int endereco)
{
  int dados;
  DS3234_ler_spi_byte(endereco,0);
  dados = DS3234_ler_spi_byte(0X00,1);//não envia nada somente para pegar os dados
  return(dados);
}
////////////////////////////////////////////////////////////////////
//essa rotina escreve um byte no registrador  em endereço
////////////////////////////////////////////////////////////////////
void DS3234_escr_spi(int endereco,int dados)
{
  endereco = endereco|0X80;//pronto pra escrever
  DS3234_ler_spi_byte(endereco,0);
  DS3234_ler_spi_byte(dados,1);  
}

Até a próxima pessoal!

quarta-feira, 22 de fevereiro de 2017

Cuidados que se deve ter com o ESP8266 12E gravado pela interface Arduíno.

       Olá, hoje vou trazer umas dicas para quem quer se aventurar pelo mundo do ESP8266 12E gravando diretamente pela interface Arduíno.O chip que estou usando é este da foto abaixo:

      além das adaptações físicas para fazer a interface com um PC é preciso cuidado ao usar alguns pinos como I/O(GPIO) pela interface Arduíno, pessoal pode crer essas dicas aqui poderão poupar tempo e evitar dores de cabeça, vamos então as dicas:
-> Usando as portas como saídas.
* Os GPIO'S  4,5,10,12,13,14,16 = funcionam sem restrição
* O GPIO 9 não funciona se colocar ele como saída o chip pode nem funcionar(fica resetado!).
* O GPIO 2 funciona, mas está ligado ao led da placa.dependendo do projeto deve ser colocado um resistor de pull_up para que seja possível uma gravação posterior pela serial rs232 (pois os pinos de GPIO'S  15,0,2 que configuram como deve ser a gravação).
* O GPIO 15 funciona, porém deve ser colocado um resitor de pull down de forma que uma gravação posterior pela serial seja possível(pois os GPIO'S 15,0,2 configuram como deve ser a gravação).
* O GPIO 0 funciona, porém no nodemcu a placa pode ficar travada se ele for ligado a base de um transistor(uso comum pra acionar reles) - cautela ao usar este pino.

-> Usando as portas como Entradas:
* Os GPIO'S  0,2,4,5,10,12,13,14,15,16 funcionam, apenas o GPIO 9 não deve ser usado pois reseta o chip quando entra em nível baixo.O pino 2 apesar de funciona está ligado ao led.
* Os cuidados para os pinos de configuração(os GPIO'S  15,0,2) devem ser observado caso queira programa o chip posteriormente, conforme já mencionado quando tratamos do uso das portas como saídas.
* a porta analógica funcionou perfeitamente.
->  As comunicações:
* A comunicação serial RS232 funcionou bem com as lib's do arduino.
* Usando os pinos que já vem no chip e que teoricamente é preparado para comunicação SPI não deu certo com as lib's nativas do Arduino (não sei o por que?)foi preciso emular uma SPI para que comunicasse com outros chips SPI.(veja um exemplo clicando aqui )
*A comunicação WIFI funciona bem, sendo muito estável,porém a senha da wifi deve ser obrigatoriamente maior que 8 caracteres ou em branco(aberta), caso contrario não troca o nome da wifi e nem aceita a senha(dá erro).

Um exemplo simples, para mostrar como o pino 9 pode "empacar" seu desenvolvimento é mostrado na imagem a seguir. Este simples código roda perfeitamente mas basta tirar as barras de  comentário para perceber que  seu programa ficara travado e não faz nada! o pior é que o software do Arduíno nem te alerta para este problema.
Espero ter ajudado alguém com essas dicas.
deixe seu comentário abaixo ou no Facebook.
Até a próxima!

terça-feira, 14 de fevereiro de 2017

Usando o RTC DS3234 com o ESP8266 pela interface do Arduino.

           Olá, hoje vou demonstrar como comunicar com o RTC DS3234 e o modulo ESP8266(gravado pela IDE arduino) com uma SPI emulada,pois a lib do Arduíno não deu certo com este modulo, tentei de varias formas usar a lib do Arduino e não deu certo, até que em um dos blogs e sites que pesquisei(chegou a afirmar) que os pinos de SPI que vem no moduloESP8266 só servem para gravação do chip(achei isso estranho), mas como não estava dando certo a comunicação e já havia passado horas de tentativa resolvi implementar uma comunicação SPI na "unha", como esse tipo de comunicação é relativamente simples aceitei o desafio de fazê-lo funcionar assim.Uma vantagem disso é que vc fica livre pra escolher os pinos que quiser, podendo inclusive usar esta ideia para microcontroladores que não possui uma SPI. Veja como ficou as conexões entre os dois chips:
           Uma das vantagens de usar este RTC é que não precisa de nenhum hardware adicional, assim como o ESP8266,basicamente  só é necessário esses 2 chips,mas dai ainda coloquei um led para piscar, só mesmo pra saber que o programa está rodando.
           O ESP8266 irá inicialmente setar uma data qualquer no chip e depois ira ler qual a data e a hora que está no chip a cada 2s, imprimindo na porta serial RS232 e usando um conversor usb serial isso chega ao PC.O programa que usei no pc foi este, mas pode ser usado qualquer outro terminal serial inclusive o do Arduíno.

O código fonte:

#include <ESP8266WiFi.h>

const int  LED_STATUS = 5; // led de status 
///emulando uma porta SPI generica - aqui se configura quais pinos se quer usar ////////////////
const int  SPI_CLK = 14; //ligue no sinal de clock
const int  SPI_IN  = 13; //ligue no Mosi 
const int  SPI_OUT = 12; //ligue no Miso
const int  SPI_CS  = 16; //ligue no chip select 


//***********************************************************************************************************
// Registradores do chip DS3234 - endereço de leitura,para escrever basta somar 0X80 ao valor hexadecimal
//***********************************************************************************************************
#define DS3234_SEG               0X00 // registrador de segundos
#define DS3234_MIN               0X01 // registrador de minutos
#define DS3234_HORA              0X02 // registrador de horas
#define DS3234_DIA_SEMANA        0X03 // registrador de dia da semana
#define DS3234_DIA               0X04 // registrador de dia
#define DS3234_MES               0X05 // registrador de Mes
#define DS3234_ANO               0X06 // registrador de ano

#define DS3234_ALM1_SEG          0X07 // registrador Alarme 1 de segundos
#define DS3234_ALM1_MIN          0X08 // registrador Alarme 1 de minutos
#define DS3234_ALM1_HORA         0X09 // registrador Alarme 1 de horas
#define DS3234_ALM1_DIA_SEMANA   0X0A // registrador Alarme 1 de dia e dia da semana

#define DS3234_ALM2_MIN          0X0B // registrador Alarme 2 de minutos
#define DS3234_ALM2_HORA         0X0C // registrador Alarme 2 de horas
#define DS3234_ALM2_DIA_SEMANA   0X0D // registrador Alarme 2 de dia e dia da semana

#define DS3234_CONTROLE          0X0E // registrador de controle(config)
#define DS3234_STAT_CONTROLE     0X0F // registrador de controle e status
#define DS3234_CONF_CRISTAL      0X10 // registrador do cristal interno

#define DS3234_TEMP_H            0X11 // registrador do sensor de temperatura parte alta(msb))
#define DS3234_TEMP_L            0X12 // registrador do sensor de temperatura parte baixa(lsb)

#define DS3234_S_RAM             0X18 // registrador da memoria S_RAM
#define DS3234_S_RAM_DADOS       0X18 // registrador da memoria S_RAM dados


void setup() {
  Serial.begin(115200); 
  pinMode(LED_STATUS, OUTPUT);
  digitalWrite(LED_STATUS, LOW);
  inicializa_spi();
  inicializa_DS3234(); 
}
void loop() {
  digitalWrite(LED_STATUS,HIGH);
  Serial.print("DATA:");
  Serial.print(DS3234_ler_spi(DS3234_DIA), HEX);
  Serial.print("/"); 
  Serial.print(DS3234_ler_spi(DS3234_MES), HEX);
  Serial.print("/");
  Serial.print(DS3234_ler_spi(DS3234_ANO), HEX);
  Serial.print(" -> ");
  Serial.print(DS3234_ler_spi(DS3234_HORA), HEX);
  Serial.print(":");
  Serial.print(DS3234_ler_spi(DS3234_MIN), HEX);
  Serial.print(":");
  Serial.println(DS3234_ler_spi(DS3234_SEG), HEX);
  delay(1000);//1s
  digitalWrite(LED_STATUS,LOW);
  delay(1000);//1s
}
/*
 * Funções usadas no laço principal
 * eu poderia ter montado uma lib - mas a ideia é compartilhar como se faz 
 * uma comunicação spi com o DS3234 que sirva em qualquer dispositivo.
 */
 ////////////////////////////////////////////////////////////////////
//cria estado padrão dos pinos spi
////////////////////////////////////////////////////////////////////
void inicializa_spi()
{ 
  pinMode(SPI_CLK, OUTPUT);
  digitalWrite(SPI_CLK, HIGH);
  pinMode(SPI_IN, INPUT);
  pinMode(SPI_OUT, OUTPUT);
  digitalWrite(SPI_OUT, LOW);
  pinMode(SPI_CS, OUTPUT);
  digitalWrite(SPI_CS,HIGH);
  return;
}
////////////////////////////////////////////////////////////////////
//inicializa o chip
////////////////////////////////////////////////////////////////////
void inicializa_DS3234()
{
    DS3234_escr_spi(DS3234_CONTROLE,0X80);//80= desliga saida do oscilador , SQ wave @1hz, Alarme desabilitados
    DS3234_escr_spi(DS3234_ANO,0X17);//configura data para 25/08/2017 - 15:05
    DS3234_escr_spi(DS3234_MES,0X08);//colocar os valores sempre em hexadecimal
    DS3234_escr_spi(DS3234_DIA,0X25);
    DS3234_escr_spi(DS3234_HORA,0X15);
    DS3234_escr_spi(DS3234_MIN,0X05);
    return;
}
////////////////////////////////////////////////////////////////////
//essa rotina serve tanto para escrever quanto para ler 
////////////////////////////////////////////////////////////////////
int DS3234_ler_spi_byte(int valor,int liga_cs)
{//já escreve e já lê
  int dados = 0;
  int pos=128;
  digitalWrite(SPI_CS, LOW);
  delayMicroseconds(1); 
  while(pos>0)///bit mais significativo primeiro
  {
      if((valor&pos)>0)//faz uma operaçao and e checa se é 1
        {digitalWrite(SPI_OUT,HIGH);}
      else
        {digitalWrite(SPI_OUT,LOW);}
        digitalWrite(SPI_CLK,LOW);
        delayMicroseconds(1); ///tempo em nivel baixo do clock
        if(digitalRead(SPI_IN)==HIGH)
        {dados = dados|pos;}      
        digitalWrite(SPI_CLK,HIGH);
        delayMicroseconds(1); ///tempo em nivel baixo do clock//tempo em nivel alto do clock
    pos=pos/2;//rotaciona 1 bit
  }
  if(liga_cs == 1)
  {digitalWrite(SPI_CS, HIGH);}
   return(dados);
}
////////////////////////////////////////////////////////////////////
//essa rotina lê um byte do registrador colocado em endereço
////////////////////////////////////////////////////////////////////
int DS3234_ler_spi(int endereco)
{
  int dados;
  DS3234_ler_spi_byte(endereco,0);
  dados = DS3234_ler_spi_byte(0X00,1);//não envia nada somente para pegar os dados
  return(dados);
}
////////////////////////////////////////////////////////////////////
//essa rotina escreve um byte no registrador  em endereço
////////////////////////////////////////////////////////////////////
void DS3234_escr_spi(int endereco,int dados)
{
  endereco = endereco|0X80;//pronto pra escrever
  DS3234_ler_spi_byte(endereco,0);
  DS3234_ler_spi_byte(dados,1);  
}


Veja o vídeo de demonstração :




sexta-feira, 10 de fevereiro de 2017

Usando o ESP8266 como cliente(acess point) - IP fixo via WIFI - Parte2

        Olá, as vezes não queremos configurar um dispositivo a ser conectado no modulo ESP8266, então a solução é colocar como um ponto de acesso("client server"), assim basta conectar a rede WIFI criada pelo modulo e digitar seu ip para ter acesso ao dispositivo.
        No código abaixo feito na IDE do Arduíno a conexão funcionou muito bem e o IP fixo também, porém ao colocar a senha e o nome do dispositivo "não funcionou",  apesar da documentação da lib do arduino dizer para usar estas funções, na pratica isso não foi verdade("ainda não sei o por que?mas quando eu tiver a resposta vou postar nos comentários", se alguém souber por favor dê um help ai), o nome do WIFI não mudou e nem pediu senha.Foi resolvido este problema do nome da wifi e da senha apenas colocando uma senha maior que 8 caracteres.

O código fonte:


#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>//caso use o modo servidor

WiFiServer server(80);//usa porta 80

void setup() 
{
  setupWiFi();  
}

void loop() 
{
  // checa se tem algum dispositivo conectado!
  WiFiClient client = server.available();
  if (!client) 
  {return;}

  // Lê a primeir linha dos dados recebidos pelo pacote ethernet
  String req = client.readStringUntil('\r');
  client.flush(); 

  // prepara pagina ehtenet
  String s = "HTTP/1.1 200 OK\r\n";
  s += "Content-Type: text/html\r\n\r\n";
  s += "<!DOCTYPE HTML>\r\n<html>\r\n";
  s += "<br> você está conectado 2 <br>";
  s += "</html>\n";
  // envia a pagina
  client.print(s);
  delay(1);
  //cliente desconectado
  // a cada requisição a pagina é enviada e o cliente é desconectado
}

void setupWiFi()
{
    //////////////////////
    // definições da WiFi  //
    //////////////////////
  const char*  WiFi_Senha = "123456789";//senha que você quer usar(deve ser em branco(aberta) ou maior que 8 caráteres,senão não funciona e não troca o nome da wifi)

  const char*  WiFi_Nome = "Microcontroladores-c";//nome que você quer dar a sua rede 
  IPAddress ip(192,168,50,4);//ok
  IPAddress gateway(192,168,50,1);//ok
  IPAddress subnet(255,255,255,0);//ok
  //////inicializa a wifi//////////////////////////////////////////////  
  uint8_t mac[WL_MAC_ADDR_LENGTH];
  WiFi.softAPmacAddress(mac);//mac qualquer pra testar
  WiFi.softAPConfig(ip, gateway, subnet);
 // WiFi.mode(WIFI_AP);//modo acess point(cliente)  
   WiFi.mode(WIFI_AP_STA);//modo acess point e servidor
  WiFi.softAP(WiFi_Nome, WiFi_Senha); 
  WiFi.begin(); 
  server.begin();
}

    Como estamos usando a porta 80 não precisa digitar a porta, apenas IP no dispositivo
que está sendo conectado a placa.veja na foto a imagem da tela de meu smartphone.




quinta-feira, 2 de fevereiro de 2017

Usando o modulo ESP8266 12+ via interface Arduíno - WIFI - Parte1

         Olá, hoje vou mostrar um exemplo simples de como criar um servidor web WIFI sem usar arduino,PIC,ATmega ou qualquer outro microcontrolador exceto o que já vem na placa do modulo.Vou dividir a experiencia desse modulo em 2 ou 3 artigos.
         Recentemente comprei uns módulos  ESP8266 12+ por incrível que pareça paguei 15 reais(ou seja o mesmo preço de um microcontrolador porem com a wifi já integrada), a "cara" da placa é esta:
         De cara o primeiro desafio é soldar essa placa num soquete para que se possa colocar na protoboard, para isto tive que fazer essa "aranha"! veja :


         Dentre as complicações estão:
->  Pinos com furos pequenos(não dá pra por barra de pinos nele).
->  Os pinos traseiros impede de se colocar na protoboard.
->  E por ultimo o nomes das portas não seguem um padrão sequencial.
-> necessidade de configurar 2 modos de operação, um pra gravação e outro para funcionamento.
         Mas esses destalhes não ofuscam em nada as vantagem deste "pequeno notável", com ele é possível fazer leituras analogicas de tensão , leitura digital, acionar os pinos para integrar com outros dispositivo, comunicação serial(rs232) e Spi (com essas comunicações pode se implementar seu próprio protocolo de comunicação com outros microcontroladores,se necessario, o que substituem os "pobres" e "massantes " comandos AT's).
        Para programar diretamente o chip pode-se usar o software LUA(com desenvolvimento inclusive no Brasil) , interface do Arduino e por ultimo os comandos AT's(já discutido aqui no blog em um exemplo).Eu particularmente optei pela IDE do arduino por ser mais divulgado e consolidado pela comunidade de hobbystas e iniciantes em programação embarcada.
        A configuração do hardware e explicação de como configurar o ambiente de programação pode ser visto clicando aqui! apesar de que a configuração do hardware lá é para uso com o bootloder deles é possível usar a configuração padrão alterando as ligações conforme esta figura que foi retirado do site "Laboratório de garagem" e ajustado por mim:

         Note que o resistor de 10k é para evitar curto circuito caso se deseje usar aquele pino como saída,claro que minha montagem não ficou bonitinha igual essa da imagem, vê ai o resultado:

        Lembrando que este módulo funciona com 3,3V e a maioria dos conversores usb/serial é de 5V, então devemos montar um divisor resitivo para não queimar o pino rx do modulo, e colocar um resitor de 1,2K(deve ficar parecido com este ).
        Depois de tudo montado o código foi algo simples e rápido uma vez que o arduino tem muitas bibliotecas prontas.A página Web ficou assim :
            Para acessar a página pelo celular primeiro você deve usar o dispositivo como roteador wifi, dai pela porta serial do pc vc pega o ip recebido pelo ESP8266 e digita no buscador de internet, então basta pressionar os botões e ver o resultado.

O Código fonte  :

/*
 * Nesta aplicação o hardware se conecta a uma rede wi fi e envia os staus a um pc pela porta serial(rs232)
 */

#include <ESP8266WiFi.h>
//para conectar a um roteador basta colocar o nome da rede e a senha da wifi do roteador(mas não testei isso!). 
const char* ssid = "AndroidAP"; // para conectar no celular  - nome da rede wifi do celular 
const char* password = "ocno33801";//senha gerada pelo android - senha da rede wifi do celular
//senha que você quer usar(deve ser em branco(aberta) ou maior que 8 caráteres,senão não funciona e não troca o nome da wifi) 
WiFiServer server(80);//escolhe a porta 80
//const int LED_STATUS = 14; // led de status
const int LED_CONEX = 16; // led de conexão
const int LED_1 = 5; 
const int LED_2 = 4; 
unsigned int gui_pisca=0;
 
void setup() {
  Serial.begin(115200);
  delay(10);
 
  // inicializa e configura oas pinos que serão utilizados
  
 // pinMode(LED_STATUS, OUTPUT);//configura como saida 
  //digitalWrite(LED_STATUS, 0);//desliga pino   
  pinMode(LED_CONEX, OUTPUT);
  digitalWrite(LED_CONEX, 0);
  pinMode(LED_1, OUTPUT);//configura como saida 
  digitalWrite(LED_1, 0);//desliga pino   
  pinMode(LED_2, OUTPUT);
  digitalWrite(LED_2, 0);
  
  // Escreve na porta serial
  Serial.println();
  Serial.print("Conectado a rede wifi : ");
  Serial.println(ssid);
  Serial.println();
    
  WiFi.begin(ssid, password);//inicia conexão
  
  while (WiFi.status() != WL_CONNECTED) //fica esperando uma conexão
  {
    delay(500);
    Serial.print(".");
  }
  
  Serial.println("");
  Serial.println("Conexão realizada com sucesso");
  digitalWrite(LED_CONEX, 1);
  // inicia o servidor
  server.begin();
  Serial.println("Servidor iniciado!");
  Serial.println(WiFi.localIP());//mostra qual o ip
}
 //rotina pricipal da aplicação
void loop() 
{
  WiFiClient client = server.available();
  if (!client) { 
      if(WiFi.status() != WL_CONNECTED) //se desconectado da wifi
        {
          digitalWrite(LED_CONEX, 0);
          digitalWrite(LED_1, 0);
          digitalWrite(LED_2, 0);
        }   
    return;
  }  
  //novo pacote chegou!
  while(!client.available()){
    delay(1);//fica esperando chegar dados
  }
  
  String req = client.readStringUntil('\r');//pegas tudo que estiver na string até o caracter de retorno('\r') 
  Serial.println(req); // mostra o conteudo na serial
  client.flush();//limpa buffer de recepção
 
  String buf = "";//cria uma string para colocar a pagina web
  //vai adicionando linhas a string criada
  buf += "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html>\r\n";
  buf += "<h3> Servidor Web com ESP8266 </h3>";
  buf += "<h4> Usando wifi </h4>";
  buf += "<p>Led 1 <a href=\"?function=led1_on\"><button>ON</button></a> <a href=\"?function=led1_off\"><button>OFF</button></a></p>";
  buf += "<p>Led 2 <a href=\"?function=led2_on\"><button>ON</button></a> <a href=\"?function=led2_off\"><button>OFF</button></a></p>";  
  buf += "</html>\n";
  client.print(buf);//envia os dados pela wifi
  client.flush();  
  ///avalia o retorno da pagina HTTP
  if (req.indexOf("led1_on") != -1)
    digitalWrite(LED_1, 1);
  else if (req.indexOf("led1_off") != -1)
    digitalWrite(LED_1, 0);
  else if (req.indexOf("led2_on") != -1)
    digitalWrite(LED_2, 1);
  else if (req.indexOf("led2_off") != -1)
    digitalWrite(LED_2, 0);
  else {
     //fim de recpção de dados
     ///fecha socket e irá voltar ao inicio do loop,ou seja cria uma novo socket e reenvia a pagia web
    client.stop();    
  }  
 
    
}