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 :




segunda-feira, 13 de fevereiro de 2017

Comunicando com o RTC DS3234 (com PIC16F887 )

        Olá, hoje vou demonstrar como usar o RTC(real time clock) DS3234, a maior
vantagem é possuir internamente no chip o cristal oscilador e um sensor de temperatura,
assim não precisa elementos externo para fazer funcionar o chip RTC. Funcionou tanto na
simulação quanto fisicamente.
   

O código fonte :
/*
 *                                   RTC DS3234 com pic - MPlab XC8
 *
 * Compilador : MPlabXC8
 * Microcontrolador: 16F887
 * Autor: Aguivone
 * Versão: 1
 * Data :  13/02/2017
 */
#include <stdio.h>
#include <string.h> //para usar funçoes de string deve se adicionar este header
#include <stdlib.h>
#define _XTAL_FREQ 20000000//usado para rotinas de  delays
#include <xc.h>

/////////////////////////////////////////////////////////configuraçôes//////////////////////////////////////////////////

#pragma config FOSC = HS        // Oscillator Selection bits (HS oscillator)
#pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
#pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
#pragma config BOREN = OFF      // Brown-out Reset Enable bit (BOR disabled)
#pragma config LVP = OFF        // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming)
#pragma config CPD = OFF        // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off)
#pragma config WRT = OFF        // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control)
#pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)
unsigned char gucAlternaPino;
unsigned char gucSPI_lido;
//Defines
#define LED_STATUS                  RD0 
/*#define DS3234_SDO                 TRISCbits.TRISC7
#define DS3234_SDI                 TRISBbits.TRISB0
#define DS3234_SCK                 TRISBbits.TRISB1*/
#define DS3234_SS                  RC2 
//***********************************************************************************************************
// 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_CONTROL           0X0E // registrador de controle
#define DS3234_STAT_CONTROL      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

//***********************************************************************************************************
// FUNÇÕES
//***********************************************************************************************************
//===========================================================================================================
// Função:     _configura_SPI
// Parâmetros: nenhum
// Retorno:    nenhum
// Descrição:  configura a parte de hardware que gerencia a SPI.
//===========================================================================================================
void inicializa_spi() //o timer 2 é usado para controlar a spi
{
    //RTC - DS3234
      SSPSTAT = 0B10000000;//modo metre / clock na borda de decida
      SSPCON = 0B00110010;//habilita os pinos da SPI/config clock como nivel altoe freq osc/64.   
}

/////////////////////////////////funçoes usadas pela uart //////////////////////////////////////////////////////
void inicializa_RS232(void)
{//// por padrão é usado o modo 8 bits e sem paridade, mas se necessario ajuste aqui a configuração desejada.
    //modo alta velocidade
    RCSTA = 0X90;//habilita porta serial,recepção de 8 bit em modo continuo,assincrono.
    TXSTA = 0X24;//modo assincrono,trasmissao 8 bits.
    //somente para cristal de 20Mhz.           
    SPBRG = 129;//9600    
 //   RCIE = 1;//habilita interrupção de recepção
    RCIE = 0;//habilita interrupção de recepção
    TXIE = 0;//deixa interrupção de transmissão desligado(pois corre se o risco de ter uma interrupção escrita e leitura ao mesmo tempo)
}
void escreve(char cValor)
{
     TXIF = 0;//limpa flag que sinaliza envio completo.
     TXREG = cValor;
     __delay_us(1);//1us para evitar problemas de perder caracteres
     while(TXIF == 0);//espera enviar caracter
}
void imprime(const char frase[])
{
     char indice = 0;
     char tamanho = strlen(frase);
      while(indice < tamanho ) ///veja que o programa pode travar se aqui não tiver as duas aspas
       {
           escreve(frase[indice]);
           indice++;
       }
}
void hex_to_int_char(char quant)
{//converte para inteiro e imprime
     unsigned char ucDez='0', ucUn='0';
    if(quant>=100)
    {//imprime centenas
       while(quant>=100)
       {
          quant -= 100;  
           ucDez++;  
       }
       escreve(ucDez);
       ucDez='0';//zera variavel novamente
    }
    while(quant>=10)
    {
      quant -= 10;  
      ucDez++;  
    }
    while(quant>=1)
    {
       quant -= 1; 
       ucUn++;  
    }
     escreve(ucDez);
     escreve(ucUn);
}
void hex_to_char(char quant)
{//converte para char e imprime
   unsigned char ucDez, ucUn;
    
    ucDez = quant/16;
    ucUn = quant%16;
    if(ucDez >= 10)
        ucDez = (ucDez-10) + 'A';
    else
        ucDez += '0';
    if(ucUn >= 10)
        ucUn = (ucUn-10) + 'A';
    else
        ucUn += '0';
          escreve(ucDez);
          escreve(ucUn);

}

unsigned char DS3234_LER_SPI(unsigned char registrador)
{ 
   unsigned char dado  = SSPBUF;//para limpar buffer 
   DS3234_SS  = 0;  // ativa SS(slave select)
   SSPBUF = registrador;//envia endereço
   while(!SSPSTATbits.BF);//espera completar envio de dados
   dado  = SSPBUF;//para limpar buffer e SSPSTATbits.BF
 //  for(unsigned char Cont=0;Cont<10;Cont++);  // Este tempo é necessário para finalizar  primeira transmissão
   SSPBUF = 0X00;//envia um informação qualquer para que os dados do slave chegue(pois ainda precisa de mais 8 clock)
   while(!SSPSTATbits.BF);//espera completar envio de dados
   dado  = SSPBUF;//para limpar buffer e SSPSTATbits.BF
   DS3234_SS  = 1;//desabilita chip   
  return(dado);//retorna valor
}
void DS3234_ESCREVE_SPI(unsigned char endereco,unsigned char valor)
{
    unsigned char dado  = SSPBUF;//para limpar buffer 
    endereco = endereco|0X80;//pronto pra escrever
    DS3234_SS  = 0;  // ativa SS(slave select)
    SSPBUF = endereco;//opcode que sinaliza que quer deixar um dado
    while(!SSPSTATbits.BF);//espera completar envio de dados
    dado  = SSPBUF;//para limpar buffer e SSPSTATbits.BF
 //   for(unsigned char Cont=0;Cont<10;Cont++);  // Este tempo é necessário para finalizar  primeira transmissão
    SSPBUF = valor;//envia os dados que será colocado no registrador
    while(!SSPSTATbits.BF);//espera completar envio de dados
    dado  = SSPBUF;//para limpar buffer e SSPSTATbits.BF
    DS3234_SS  = 1;//desabilita chip
}

void inicializa_RTC()
{    
    DS3234_ESCREVE_SPI(DS3234_CONTROL,0X80);//80= desliga saida do oscilador , SQ wave @1hz, Alarme desabilitados
    DS3234_ESCREVE_SPI(DS3234_ANO,0X17);//25/08/2017 - 15:05
    DS3234_ESCREVE_SPI(DS3234_MES,0X08);//colocar os valores sempre em hexadecimal
    DS3234_ESCREVE_SPI(DS3234_DIA,0X25);
    DS3234_ESCREVE_SPI(DS3234_HORA,0X15);
    DS3234_ESCREVE_SPI(DS3234_MIN,0X05);
    
}
//////////////////////////////////////////////////////Rotina principal///////////////////////////////////////////////////////////////

void main(void)
{
    TRISA = 0XDF;   //somente pino 5 é saida
    TRISB = 0;   //configura como saida
    TRISC = 0X10;   //somete C4 é entrada(SDI))
    TRISD = 0;   //configura como saida
    TRISE = 0XFF;   //configura como entrada
    PORTA = 0;
    PORTB = 0;  // limpar as portas que estão configuradas como saidas
    PORTC = 0;
    PORTD = 0;
    PORTE = 0;
    inicializa_RS232();
    inicializa_spi();
    GIE = 0; //desliga interrupções 
    ADCON0 = 0X00;//desabilita modulo ADC
    ADCON1 = 0X07;//desliga modulo comparador
    ANSEL = 0x00;   // Disable todas as portas analogicas
    CM1CON0 = 0;
    CM2CON0 = 0;
    long Pisca = 200;//tempo qualquer 
    __delay_ms(50);
    imprime("Usando : RTC_DS3234 \r\n");
    inicializa_RTC();
    for(;;)    
    {        
        if(Pisca == 0)
            {
                 if(gucAlternaPino == '0')
                {
                  LED_STATUS=0;
                  gucAlternaPino = '1';
                  gucSPI_lido = DS3234_LER_SPI(DS3234_HORA);                  
                  hex_to_char( gucSPI_lido);
                  escreve(':');
                  gucSPI_lido = DS3234_LER_SPI(DS3234_MIN);
                  hex_to_char( gucSPI_lido);
                  escreve(':');
                  gucSPI_lido = DS3234_LER_SPI(DS3234_SEG);
                  hex_to_char( gucSPI_lido);
                  escreve('-');
                  escreve('>');
                  gucSPI_lido = DS3234_LER_SPI(DS3234_DIA);
                  hex_to_char( gucSPI_lido);
                  escreve('/');
                  gucSPI_lido = DS3234_LER_SPI(DS3234_MES);
                  hex_to_char( gucSPI_lido);
                  escreve('/');
                  gucSPI_lido = DS3234_LER_SPI(DS3234_ANO);
                  hex_to_char( gucSPI_lido);  
                 imprime("\r\n Temperatura :");//para temperatura negativas é preciso fazer 
                  gucSPI_lido = DS3234_LER_SPI(DS3234_TEMP_H);//alguns tratamentos aqui vamos demontrar apena para uma escala acima de 0
                  hex_to_int_char( gucSPI_lido); 
                  // praticamente não vai fazer diferença
                  // gucSPI_lido = DS3234_LER_SPI(DS3234_TEMP_L);
                  //hex_to_int_char( gucSPI_lido);
                  imprime("\r\n");
                }
                else
                {
                  LED_STATUS=1;
                  gucAlternaPino = '0';
                } 
                 Pisca = 200;
            }
        else
        {
           Pisca--;
           __delay_ms(1);
        }
            
    }//loop infinito

}

A simulação ficou assim:


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();    
  }  
 
    
}