Interface ESP8266 com microcontrolador PIC16F877A

Tempo de leitura: 8 minutes

Neste artigo, vamos discutir como interagir com o módulo WIFI ESP8266 com um microcontrolador PIC Até agora, você pode estar usando o módulo ESP8266 como um microcontrolador independente ou pode estar usando-o na biblioteca do Arduino. Porém, quando se trata de projetos de sistemas embarcados hardcore, devemos saber como usá-lo também com microcontroladores PIC. Isso ajudará você a personalizar seus projetos na perspectiva do design e, ao mesmo tempo, também a torná-lo barato.

Os módulos ESP8266 vêm com um firmware padrão carregado nele, portanto, podemos programar o módulo usando comandos AT. Esses comandos devem ser enviados através de um canal de comunicação serial. Este canal é estabelecido entre o PIC e o módulo ESP8266 por. usando o módulo USART no microcontrolador PIC. Todo o trabalho será monitorado e relatado ao usuário usando a Visor LCD de 16×2 Portanto, este tutorial pressupõe que você tenha algum conhecimento básico sobre o módulo USART no PIC, Interfacing LCD with PIC e usando comandos AT no ESP8266. Caso contrário, você poderá voltar aos tutoriais vinculados para aprendê-los com antecedência.

 

Materiais necessários:

Você precisaria do seguinte hardware para concluir este tutorial

  1. PIC16F877A
  2. Oscilador de cristal de 20 MHz
  3. 7805
  4. LM317
  5. ESP8266
  6. Visor LCD de 16 * 2
  7. Programador PicKit3
  8. Resistores (1K.220ohm, 360ohm)
  9. Capacitores (1uF, 0,1uF, 33pF)
  10. Fios de jumper
  11. Adaptador de 12V para alimentar o módulo PIC e ESP

Hardware:

O esquema completo do projeto é mostrado aqui abaixo

Os esquemas consistem em dois circuitos reguladores de tensão, um é um regulador de +5V usado para alimentar o microcontrolador PIC e o outro é um regulador de 3,3V que alimenta o módulo ESP8266. O +5V é regulado usando um 7805 (IC do Regulador de Tensão Linear). O 3.3V é regulado usando o LM317 (Regulador de Tensão Variável). O módulo ESP8266 consome muita corrente (~ 800mA); portanto, se você estiver projetando sua própria fonte de alimentação, verifique se ela pode obter uma corrente tão alta. Verifique também se os pinos de terra do PIC e do módulo ESP8266 estão conectados juntos.

Então agora sabemos que o PIC opera em +5V e o ESP8266 opera em 3,3V volts. Para estabelecer uma comunicação USART entre esses dois módulos, precisamos de um circuito conversor lógico de 5V – 3,3V, conforme mostrado na figura acima. Este circuito não passa de um divisor em potencial que simplesmente converte o +5V recebido em 3,3V. Isso impedirá que o pino RX tolerável de 3,3V do ESP8266 obtenha +5V

 

Programando o microcontrolador PIC :

Para programe o microcontrolador PIC para enviar “comandos AT” usando o USART em série no módulo ESP8266, precisamos usar uma biblioteca. Essa biblioteca economizará muito aborrecimento, como usar os módulos de instrução ESP8266 para verificar cada comando AT e encontrar uma maneira de transmiti-los ao módulo ESP. Esta biblioteca é um software livre desenvolvido originalmente pela Camil Staps e mais tarde foi aprimorada e modificada para que possa ser usada com o nosso microcontrolador PIC16F877A. Você pode baixá-lo aqui

A biblioteca ainda está em desenvolvimento, mas você pode usar a maioria dos comandos AT importantes no firmware ESP8266. Se você encontrar algum comando que precisa, informe-o na seção de comentários e tentarei adicioná-lo a você. Este tutorial explicará todos os comandos (até o momento) que podem ser usados por esta biblioteca. Além disso, você também o guiará a adicionar suas próprias funções à biblioteca.

Funções na Biblioteca ESP8266 :

  • Initialize_ESP8266(): Esta função inicializará o módulo USART do PIC para se comunicar com o módulo ESP8266. Ele define a taxa de transmissão em 115200 e prepara o pino Rx e Tx do PIC para comunicação USART.
  • _esp8266_putch(): Esta função é usada para enviar um único caractere em série para o módulo ESP8266. Por exemplo, _esp8266_putch (‘a’) enviará o caractere em série para o módulo ESP.
  • _esp8266_getch(): Esta função é usada para obter um único caractere do módulo ESP. Por exemplo, se o ESP estiver imprimindo “OK” e usarmos char a = _esp8266_getch (). Em seguida, o caractere ‘o’ será armazenado na variável a.
  • ESP8266_send_string() : Esta função é a versão de string de _esp8266_putch (). Ele pode enviar uma sequência completa para o módulo ESP8266. Por exemplo, ESP8266_send_string (“AT /r/n”) enviará o comando “AT” para o módulo ESP8266.
  • esp8266_isStarted(): É usado para verificar se o PIC pode se comunicar com o módulo ESP. Ele envia o comando “AT” e aguarda “OK” se recebido retornar verdadeiro, caso contrário, retornará falso.
  • esp8266_restart(): Redefine o módulo ESP8266 e retorna true é redefinido com êxito e retorna false se não for bem-sucedido.
  • esp8266_mode (): Usado para definir o modo de trabalho do módulo ESP8266. Como sabemos, pode funcionar em três modos diferentes.
esp8266_mode (1) : Modo de estação
esp8266_mode (2) : Modo AP suave
esp8266_mode (3) : Modo Station e AP
  • esp8266_connect(): Permite conectar-se a um sinal wifi. Por exemplo esp8266_connect (“casa”, “12345678”), permitirá que seu módulo se conecte ao sinal wifi chamado home cuja senha é 12345678.
  • esp8266_disconnect(): Esta função desconecta o módulo de qualquer conexão wifi conectada anteriormente
  • esp8266_ip(): Obtém o endereço IP e o retorna. Use esta função se desejar saber o endereço IP do módulo ESP8266.
  • esp8266_start(): Esta função é usada para iniciar uma comunicação TCP ou UDP. Por exemplo esp8266_start(“TCP”, “192.168.101.110”, 80) Iniciará uma rede TCP nesse IP e porta 80.
  • esp8266_send(): Esta função é usada para enviar informações para a rede TCP/UDP. O script HTML será enviado usando este comando. Em seguida, esse script aparecerá no endereço IP em que a comunicação foi estabelecida anteriormente.
  • esp8266_config_softAP(): Esta função é usada para configurar o softAP. Por exemplo esp8266_config_softAP(“escritório”, “12345678”) ; criará um sinal Wifi chamado office e a senha 12345678 deve ser usada para acessá-lo.
  • esp8266_get_stationIP(): Esta função retornará o endereço IP/MAC dos clientes conectados ao seu softAP

 

Programa de amostra:

Agora que entendemos as funções de cada comando da biblioteca, vamos analisar um pequeno programa de amostra. Neste programa, verificaremos se a conexão entre ESP8266 e PIC é bem-sucedida e, em seguida, criaremos uma rede WIFI (SoftAP) com um nome e senha preferidos. O programa completo e a simulação do mesmo serão explicados para sua compreensão.

Novamente, se você não leu o nosso Interface PIC com LCD e o tutorial do PIC USART, leia o, antes de prosseguir, porque só assim fará sentido para você.

Desde que somos justos começando a interagir com o ESP8266, Usei um LCD para garantir que as coisas estejam funcionando corretamente.

do
    {

    Lcd_Set_Cursor(1,1);

    Lcd_Print_String("ESP não encontrado");

    }while (!esp8266_isStarted()); //espera até que o ESP envie de volta "OK"

    Lcd_Set_Cursor(1,1);

    Lcd_Print_String("ESP está conectado");

    __delay_ms(1500);

    Lcd_Clear();

Quando enviamos o “AT” para o módulo ESP8266, ele responde com um “OK”. Isso nos garante que o módulo ESP8266 esteja conectado com sucesso. A função esp8266_isStarted() é usada para o mesmo. Enviamos o sinal AT do PIC e esperamos até o módulo ESP para ganhar vida e nos enviar um OK. Se obtivermos um OK, exibimos que o “ESP está conectado” no LCD

esp8266_mode(2);

    Lcd_Set_Cursor(1,1);

    Lcd_Print_String("ESP definido como AP");

    __delay_ms(1500);

    Lcd_Clear();

As linhas de código acima são usadas para definir o módulo ESP para funcionar no modo “soft AP”. A função esp8266_mode(2); envia os comandos AT “AT+CWMODE=3” para o módulo e aguarda que o módulo responda com “OK”

/*Configure o nome e a senha do AP*/

    esp8266_config_softAP("TesteProjeto","12345678");

    Lcd_Set_Cursor(1,1);

    Lcd_Print_String("AP configurado");

    __delay_ms(1500);

    Lcd_Clear();

    /*AP configurado/

 

Este segmento do código é usado para configurar o softAP. Aqui, nomeamos o SSID como “ProjetoTeste” e a senha como “12345678”. Para indicar que o processo está concluído, aguardaremos a resposta do módulo com “OK” e, em seguida, imprimiremos o AP configurado na tela LCD.

É isso agora que interferimos o módulo ESP8266 no PIC MCU e configuramos o softAP com um nome e uma senha de nossa escolha.

 

Verificação de saída:

Depois que o programa for verificado usando a simulação, despeje-o em seu microcontrolador PIC. Faça as conexões conforme mostrado nos esquemas acima (seção Hardware). Você deve ser capaz de acompanhar o seu progresso através do visor LCD.

Uma vez que o LCD diz que o AP está configurado, podemos verificar isso usando as configurações de WIFI no telefone ou laptop. Meu laptop mostra o seguinte sinal de acordo com nosso programa.

É isso aí pessoal, conectamos com sucesso o módulo ESP8266 com o microcontrolador PIC. Esta é uma interface muito básica e se você quiser fazer algum projeto complicado usando o ESP8266, talvez seja necessário adicionar suas próprias bibliotecas ou pelo menos adicionar suas próprias funções. Confie em mim, é muito fácil fazê-lo, vou dar uma breve visão para o mesmo.

Adicionando funções à Biblioteca ESP8266:

Adicionar sua própria função ajudará você a enviar qualquer comando “AT” para o módulo ESP8266. Para prosseguir com isso, você precisa ler a documentação do conjunto de instruções do módulo ESP8266. Você pode enviar diretamente qualquer comando AT que encontrar nesse manual do conjunto de instruções. Mas lembre-se sempre de acrescentar “/r/n” no final de cada comando AT. Por exemplo, se você deseja estabelecer várias conexões com seu módulo ESP. Em seguida, abra a documentação do conjunto de instruções e descubra qual comando AT fará esse trabalho para você. Aqui o comando “AT+CIPMUX=1” permitirá que você estabeleça várias conexões com seu módulo ESP. (Library)

Agora tudo que você precisa fazer é enviar este “AP+CIPMUX=1” para o seu módulo ESP8266 usando a porta serial. A maneira hardcore de fazer isso é simplesmente usando o comando

_esp8266_print(“AT+CIPMUX=1\r\n””)

Isso funcionará, mas não é a melhor maneira de fazê-lo. Você precisa ler o que seu ESP8266 responde ao seu comando. No nosso caso, ele responderá com “OK”. Então você tem que ler os dados de entrada do módulo ESP8266 e confirmar que é um “OK”. Além disso, você pode fazer esta função onde o “1” ou o “0” podem ser passados ​​como argumentos.

Vá em frente e tente fazer suas próprias funções para a biblioteca. Mas se você precisar de ajuda, sinta-se à vontade para usar a seção de comentários e eu o ajudarei.

#define _XTAL_FREQ 20000000

#define RS RD2
#define EN RD3
#define D4 RD4
#define D5 RD5
#define D6 RD6
#define D7 RD7

#include <xc.h>
#include "esp8266_functions.h"

#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 enabled)
#pragma config BOREN = ON       // Brown-out Reset Enable bit (BOR enabled)
#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)

//****LCD Functions Developed by Circuit Digest.***///
void Lcd_SetBit(char data_bit) //Based on the Hex value Set the Bits of the Data Lines
{
    if(data_bit& 1) 
        D4 = 1;
    else
        D4 = 0;

    if(data_bit& 2)
        D5 = 1;
    else
        D5 = 0;

    if(data_bit& 4)
        D6 = 1;
    else
        D6 = 0;

    if(data_bit& 8) 
        D7 = 1;
    else
        D7 = 0;
}

void Lcd_Cmd(char a)
{
    RS = 0;           
    Lcd_SetBit(a); //Incoming Hex value
    EN  = 1;         
        __delay_ms(4);
        EN  = 0;         
}

Lcd_Clear()
{
    Lcd_Cmd(0); //Clear the LCD
    Lcd_Cmd(1); //Move the curser to first position
}

void Lcd_Set_Cursor(char a, char b)
{
    char temp,z,y;
    if(a== 1)
    {
      temp = 0x80 + b - 1; //80H is used to move the curser
        z = temp>>4; //Lower 8-bits
        y = temp & 0x0F; //Upper 8-bits
        Lcd_Cmd(z); //Set Row
        Lcd_Cmd(y); //Set Column
    }
    else if(a== 2)
    {
        temp = 0xC0 + b - 1;
        z = temp>>4; //Lower 8-bits
        y = temp & 0x0F; //Upper 8-bits
        Lcd_Cmd(z); //Set Row
        Lcd_Cmd(y); //Set Column
    }
}

void Lcd_Start()
{
  Lcd_SetBit(0x00);
  for(int i=1065244; i<=0; i--)  NOP();  
  Lcd_Cmd(0x03);
    __delay_ms(5);
  Lcd_Cmd(0x03);
    __delay_ms(11);
  Lcd_Cmd(0x03); 
  Lcd_Cmd(0x02); //02H is used for Return home -> Clears the RAM and initializes the LCD
  Lcd_Cmd(0x02); //02H is used for Return home -> Clears the RAM and initializes the LCD
  Lcd_Cmd(0x08); //Select Row 1
  Lcd_Cmd(0x00); //Clear Row 1 Display
  Lcd_Cmd(0x0C); //Select Row 2
  Lcd_Cmd(0x00); //Clear Row 2 Display
  Lcd_Cmd(0x06);
}

void Lcd_Print_Char(char data)  //Send 8-bits through 4-bit mode
{
   char Lower_Nibble,Upper_Nibble;
   Lower_Nibble = data&0x0F;
   Upper_Nibble = data&0xF0;
   RS = 1;             // => RS = 1
   Lcd_SetBit(Upper_Nibble>>4);             //Send upper half by shifting by 4
   EN = 1;
   for(int i=2130483; i<=0; i--)  NOP(); 
   EN = 0;
   Lcd_SetBit(Lower_Nibble); //Send Lower half
   EN = 1;
   for(int i=2130483; i<=0; i--)  NOP();
   EN = 0;
}

void Lcd_Print_String(char *a)
{
    int i;
    for(i=0;a[i]!='\0';i++)
       Lcd_Print_Char(a[i]);  //Split the string using pointers and call the Char function 
}
//***End of LCD functions***//

void main()
{
    TRISD = 0x00;
    Lcd_Start();
    Initialize_ESP8266() ; 
    Lcd_Set_Cursor(1,1);
    Lcd_Print_String("Teste Project");
    Lcd_Set_Cursor(2,1);
    Lcd_Print_String("ESP5266 with PIC");
    __delay_ms(1500);
    Lcd_Clear();
    
    /*Check if the ESP_PIC communication is successful*/
    do
    {
    Lcd_Set_Cursor(1,1);
    Lcd_Print_String("ESP not found");
    }while (!esp8266_isStarted()); //wait till the ESP send back "OK"
    Lcd_Set_Cursor(1,1);
    Lcd_Print_String("ESP is connected");
    __delay_ms(1500);
    Lcd_Clear();
    /*Yes ESP communication successful*/
    
    /*Put the module in Soft AP  mode*/
    esp8266_mode(2);
    Lcd_Set_Cursor(1,1);
    Lcd_Print_String("ESP set as AP");
    __delay_ms(1500);
    Lcd_Clear();
    /*Module set as AP */
    
    /*Configure the AP name and Password*/
    esp8266_config_softAP("TesteProject","12345678");
    Lcd_Set_Cursor(1,1);
    Lcd_Print_String("AP configured");
    __delay_ms(1500);
    /*AP configured*/
    
   
            
    while(1)
    {
        //do nothing 
    }

}

 

Visits: 9 Visits: 1126258