quinta-feira, 1 de junho de 2017

Selecionando LED na sequência usando um botão - CCS

Selecionando LED na sequência usando um botão


lista de peças para montagem em bancada:

- matriz de contatos pequena
- pic16F628A, microcontrolador da Microchip
- 4 resistor de 220 ohm para limitar a corrente do LED
- 4 LED de 3 ou 5 mm vermelho
- Botão de contato
- cabinhos para ligações dos componentes
- fonte de 5V, pode ser um carregador de celular ou suporte de 3 pilhas(4,5V)

O código fonte:

///////////////////////////////////////////////////////////////////////
//              Projeto: Selecionar LED na sequência usando um botão //
//                 Nome: Renato Lôbo Rodrigues                       //
//                 Data: 18/05/17                                    //
//                Email: lobosoft@oi.com.br                          //
///////////////////////////////////////////////////////////////////////
#include <16F628A.h>
#use delay (clock = 4Mhz)
//Configure os fusíveis em acordo com o pic selecionado
#fuses NOWDT
#fuses PUT
#fuses NOBROWNOUT
#fuses NOMCLR
#fuses INTRC_IO
#fuses PROTECT

//Estes registros encontra-se nas funções especiais de cada modelo de pic.
#byte tris_portA = 0x85   //direção do portA
#byte tris_portB = 0x86   //direção do portB
#bit bot1        = 0x06.3 //pino B3

#bit RBPU        = 0x81.7 //Registro pullup do portB 

#bit led1        = 0x05.0 //pino A0
#bit led2        = 0x05.1 //pino A1
#bit led3        = 0x05.2 //pino A2
#bit led4        = 0x05.3 //pino A3

//___________________________________________
//Rotina principal
void main()
{
   int1 st1 = true;  //status do botão
   int8 ponteiro = 0;//seleciona um LED de cada vez
   
   tris_portB = 0b11111111; //todos os pinos como entrada
   RBPU = 0;                //pull-up portB ativados
   
   tris_portA = 0b11110000; //pino A0,A1,A2,A3 como saída
   led1 = 1;         //liga led1
   led2 = 0;         //desliga led2   
   led3 = 0;         //desliga led3   
   led4 = 0;         //desliga led4   
   
   while(true)       //laço infinito
   {
      //funciona quando solta o botão (KeyUp)
      if (!bot1)   st1=false;
      delay_ms(50);           //um tempo para anular repique da chave
      if ( bot1 && st1==false)
      {
           st1=true;
           ponteiro++;
           if(ponteiro>3)ponteiro=0;
           led1 = 0 ;led2 = 0 ;led3 = 0 ;led4 = 0 ; //Apaga todos os LEDs
           switch (ponteiro)
           {
            case 0:led1 = 1 ; //Acende o led1
                  break;
            case 1:led2 = 1 ; //Acende o led2
                  break;
            case 2:led3 = 1 ; //Acende o led3
                  break;
            case 3:led4 = 1 ; //Acende o led4
                  break;
           }
           delay_ms(200); //um tempo para anular repique da chave
      }//fim do if
   }//fim do while
} //fim do main

quinta-feira, 11 de maio de 2017

Usando timer 0 com o CSS (por: Renato Lôbo Rodrigues)

           Olá pessoal que acompanha o blog, temos mais uma postagem do senhor Renato Lôbo,um programa escrito em C para compilador CCS, que faz piscar um LED usando o timer0 configurado pelos registradores, usando como referência o datasheet do PIC6F628A da Microchip.
http://ww1.microchip.com/downloads/en/DeviceDoc/40044G.pdf

lista de peças para montagem em bancada:
- matriz de contatos pequena
- pic16F628A, microcontrolador da Microchip
- resistor de 220 ohm para limitar a corrente do LED
- LED 3 ou 5 mm vermelho
- cabinhos para ligações dos componentes
- fonte de 5V, pode ser um carregador de celular ou suporte de 3 pilhas(4,5V)
A simulação:




foto do projeto:


O código fonte :

///////////////////////////////////////////////////////////////////////
//              Projeto: pisca-pisca usando timer0                   //
//                 Nome: Renato Lôbo Rodrigues                       //
//                 Data: 11/05/17                                    //
//                Email: lobosoft@oi.com.br                          //
///////////////////////////////////////////////////////////////////////
#include <16F628A.h>
#use delay (clock = 4Mhz)
//Configure os fusíveis em acordo com o pic selecionado
#fuses NOWDT
#fuses PUT
#fuses NOBROWNOUT
#fuses NOMCLR
#fuses INTRC_IO
#fuses PROTECT

#byte tris_portA = 0x85 //direção dos pinos do portA
#byte tris_portB = 0x86 //direção dos pinos do portB

#bit led1      = 0x05.0 //pino A0

//##############################################################################
#bit GIE           = 0x0b.7 //interrupção blobal
#bit TOIE          = 0x0b.5 //interrupção timer0
#bit TMR1ON        = 0x10.0 //interrupção timer1
#bit TMR2ON        = 0x12.2 //interrupção timer2

#byte tmr0         = 0x01   //preload do timer0

#byte OPTION_REG = 0x81    //registro no endereço 0x81 do banco1

//___________________________________________
//Rotina de interrupção do timer0
#int_rtcc
void rotina_t0()
{
   static int8 conta;
   conta++;               // conta 125 vezes o tempo do timer0(4ms) para completar 500 miliseguundos
   if (conta==125)      //125*4ms = 500ms => ciclo de 1 segundo
   {
      led1=~led1;       //inverte a saída ligando ou desligando o LED.
      conta = 0;
   }
   tmr0 = 6;            //inicia a contagem em 6 e vai até 256(onde estoura)
}
//___________________________________________
//Rotina principal
void main()
{
   //pinos configurado como entrada por segurança  (alta impedância)
   tris_portA = 0b11111110; //todos os pinos do portA como entrada exceto pino A0 como saída
   tris_portB = 0b11111111; //todos os pinos do portB como entrada
   
   led1 = 1;       //Acende o led1

   //registro configurado para 4 milisegundos(veja pagina 25 do datasheet)
   OPTION_REG = 0b10000011;//1   = pull-up desabilitado
                           //0000= deixe tudo zero como padrão
                           //011 =prescaler dividido por 16

   tmr0 = 6;                        //preload do timer0 para 4ms
   GIE = 1;                         //interrupção global ativa
   TOIE = 1;                        //interrupção timer0 ativa
   TMR1ON = 0;                      //desabilita timer1
   TMR2ON = 0;                      //desabilita timer2
  

   while(true)     //laço infinito
   {
     
   }
}

sexta-feira, 5 de maio de 2017

Acionando led pelo CCS (por:Renato Lôbo Rodrigues).


Olá pessoal que acompanha o blog, está é uma contribuição do nosso colega Renato Lôbo Rodrigues e ele deixou o seguinte programa no qual liga e desliga um LED através de um botão.
Programa indicado para iniciantes e quem mais se interessar pelo método de programação no CCS, sem usar  funções próprias do CCS.Há recursos onde o datasheet deve ser consultado para eventuais dúvidas dos registradores usados.


O código fonte:
 
lista de peças para montagem em bancada:
- matriz de contatos pequena
- pic16F628A, microcontrolador da Microchip
- resitor de 220 ohm para limitar a corrente do LED
- resitor de 10k ohm como pu-up da entrada do pino RA3
- LED 3 ou 5 mm vermelho
- botão de contato
- cabinhos para ligações dos componentes
- fonte de 5V, pode ser um carregador de celular ou suporte de 3 pilhas(4,5V)

///////////////////////////////////////////////////////////////////////
// Projeto: Ligar e desligar um led através de um botão //
// Nome: Renato Lôbo Rodrigues //
// Data: 10/03/17 //
// Email: lobosoft@oi.com.br //
///////////////////////////////////////////////////////////////////////
#include <16F628A.h>
#use delay (clock = 4Mhz)
//Configure os fusíveis em acordo com o pic selecionado, consultar o arquivo <16F628.h> e datasheet.
#fuses NOWDT
#fuses PUT
#fuses NOBROWNOUT
#fuses NOMCLR
#fuses INTRC_IO
#fuses PROTECT
//Estes registros encontra-se nas funções especiais de cada modelo de pic, 
//pag 16 do datashet no mapa de memória.
#bit tris_bot1 = 0x85.3 //direção do pino A3
#bit bot1 = 0x05.3 //pino A3
#bit tris_led1 = 0x85.0 //direção do pino A0
#bit led1 = 0x05.0 //pino A0
//___________________________________________
//Rotina principal
void main()
{
int1 st1 = false; //status do botão
tris_bot1 = 1; //pino A3 em "um" como entrada
tris_led1 = 0; //pino A0 em "zero" como saída
led1 = 0; //inicia com "zero" apagando o led1
while(true) //laço infinito
{
//funciona quando aperta o botão (KeyDown)
if ( bot1) st1=false;    //
if (!bot1 && st1==false)
{
st1=true;
led1 = !led1 ; //inverte, acende ou apaga o led1
delay_ms(100); //um tempo para deboulce
}//fim do if
}//fim do while
} //fim do main

Muito obrigado Renato Lôbo Rodrigues por contribuir com o blog!

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 :




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