Interface ESP8266 com microcontrolador PIC16F877A
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.
Conteudo
Materiais necessários:
Você precisaria do seguinte hardware para concluir este tutorial
- PIC16F877A
- Oscilador de cristal de 20 MHz
- 7805
- LM317
- ESP8266
- Visor LCD de 16 * 2
- Programador PicKit3
- Resistores (1K.220ohm, 360ohm)
- Capacitores (1uF, 0,1uF, 33pF)
- Fios de jumper
- 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
}
}
