Gränssnitt esp8266 med pic16f877a mikrokontroller

I den här artikeln, låt oss diskutera hur man gränssnitt WIFI-modul ESP8266 med en PIC-mikrokontroller. Hittills har du kanske använt ESP8266-modulen som en fristående mikrokontroller eller kanske använt den med Arduino-biblioteket. Men när det gäller hardcore-inbäddade systemprojekt borde vi också veta hur man använder det med PIC-mikrokontroller. Detta hjälper dig att anpassa dina projekt i designperspektiv och samtidigt göra det billigt.

ESP8266-modulerna levereras med en standard firmware laddad i den, därför kan vi programmera modulen med AT-kommandon. Dessa kommandon måste skickas via en seriell kommunikationskanal. Denna kanal upprättas mellan PIC och ESP8266-modulen med hjälp av USART-modulen i PIC-mikrokontrollern . Hela arbetet kommer att övervakas och rapporteras till användaren med en 16x2 LCD-skärm. Därför antar denna handledning att du har grundläggande kunskaper om USART-modulen i PIC, gränssnitt LCD med PIC och användning av AT-kommandon i ESP8266. Om du inte gör det kan du falla tillbaka till de länkade handledningarna för att lära dig dem i förväg.

Material som krävs:

Du behöver följande hårdvara för att slutföra denna handledning

PIC16F877A
20MHz kristalloscillator
7805
LM317
ESP8266
16 * 2 LCD-skärm
PicKit3 programmerare
Motstånd (1K, 220ohm, 360ohm)
Kondensatorer (1uF, 0.1uF, 33pF)
Bygeltrådar
12V-adapter för att driva PIC- och ESP-modulen

Hårdvara:

Den fullständiga schemat för projektet visas nedan

Schemat består av två spänningsregulatorkretsar, den ena är en + 5V-regulator som används för att driva PIC-mikrokontrollern och den andra är en 3,3V-regulator som driver ESP8266-modulen. + 5V regleras med en 7805 (linjär spänningsregulator IC). 3.3V regleras med LM317 (Variable Voltage Regulator). ESP8266-modulen förbrukar mycket ström (~ 800mA), så se till att den kan få så hög ström om du utformar din egen strömförsörjning. Se också till att jordstiften på PIC och ESP8266-modulen är anslutna.

Så nu vet vi att PIC fungerar på + 5V och ESP8266 arbetar på 3,3V volt. För att upprätta en USART-kommunikation mellan dessa två moduler behöver vi en 5V - 3,3V logisk omvandlarkrets som visas i figuren ovan. Denna krets är inget annat än en potentialdelare som helt enkelt omvandlar inkommande + 5V till 3,3V. Detta förhindrar att den 3,3 V tolererbara RX-stiftet på ESP8266 får + 5V.

Jag har gjort PIC- och ESP-modulerna på två separata perf-kort, som visas i dessa självstudier. På så sätt kan jag använda dem universellt för fler liknande projekt

LED-hårdvara med PIC
Komma igång med ESP8266

Du kan följa detsamma eller bygga ditt eget bräde i din stil eller helt enkelt ansluta kretsen ovan till en bräda.

Programmering av PIC-mikrokontrollern:

För att programmera PIC-mikrokontrollern att skicka “AT-kommandon” seriellt med USART till ESP8266-modulen måste vi använda ett bibliotek. Detta bibliotek sparar mycket krångel, som att använda ESP8266-instruktionsmodulerna för att söka efter varje AT-kommando och sedan hitta ett sätt att överföra dem till ESP-modulen. Detta bibliotek är gratis programvara som ursprungligen utvecklades av Camil Staps och senare förbättrades och modifierades det av Circuit Digest så att det kan användas med vår PIC16F877A Microcontroller. Du kan ladda ner den här

Biblioteket är fortfarande under utveckling, men du kan använda de flesta viktiga AT-kommandon i ESP8266-firmware. Om du hittar något av kommandot du behöver saknas, låt mig veta det i kommentarsektionen så försöker jag lägga till det åt dig. Denna handledning kommer att förklara alla kommandon (hittills) som kan användas av via detta bibliotek. Vidare kommer du också att guida dig att lägga till dina egna funktioner i biblioteket.

Funktioner i ESP8266-biblioteket:

Initialisera_ESP8266 (): Denna funktion initialiserar USART-modulen i PIC för att kommunicera med ESP8266-modulen. Den sätter baudhastigheten till 115200 och förbereder Rx- och Tx-stift på PIC för USART-kommunikation.
_esp8266_putch (): Denna funktion används för att skicka ett tecken i serie till ESP8266-modulen. Till exempel skickar _esp8266_putch ('a') karaktären a seriellt till ESPmodulen.
_esp8266_getch (): Denna funktion används för att få ett enda tecken från ESP-modulen. Till exempel om ESP skriver ut “OK” och vi använder char a = _esp8266_getch (). Då lagras char 'o' i variabeln a.
ESP8266_send_string (): Den här funktionen är strängversionen av _esp8266_putch (). Den kan skicka en komplett sträng till ESP8266-modulen. Till exempel kommer ESP8266_send_string (“AT / r / n”) att skicka kommandot “AT” till ESP8266-modulen.
esp8266_isStarted (): Den används för att kontrollera om PIC kan kommunicera med ESP-modulen. Det skickar kommandot "AT" och väntar på "OK" om det tas emot returnerar det sant annars returnerar det falskt.
esp8266_restart (): Återställer ESP8266-modulen och returnerar true är återställningen lyckad och returnerar falsk om den inte lyckades.
esp8266_mode (): Används för att ställa in arbetsläget för ESP8266-modulen. Som vi vet kan det fungera i tre olika lägen.

	Stationsläge
	Mjukt AP-läge
	Både Station och AP-läge

esp8266_connect (): Låter dig ansluta till en wifi-signal. Till exempel esp8266_connect ("hem", "12345678") , tillåter din modul att ansluta till den wifi-signal som heter hem vars lösenord är 12345678.
esp8266_disconnect (): Denna funktion kopplar bort din modul från alla wifi-anslutningar som tidigare var anslutna
esp8266_ip (): Hämtar IP-adressen och returnerar den. Använd den här funktionen om du vill veta IP-adressen till ESP8266-modulen.
esp8266_start (): Denna funktion används för att starta en TCP- eller UDP-kommunikation. Till exempel esp8266_start ( "TCP", "192.168.101.110", 80) . Kommer att starta ett TCP-nätverk i denna IP och port 80.
esp8266_send (): Denna funktion används för att skicka information till TCP / UDP-nätverket. HTML-skriptet skickas med detta kommando. Då kommer detta skript att visas i den IP-adress där kommunikationen upprättades tidigare.
esp8266_config_softAP (): Den här funktionen används för att konfigurera softAP. Till exempel esp8266_config_softAP (“office”, ”12345678”); skapar en Wifi-signal med namnet office och lösenordet 12345678 ska användas för att komma åt det.
esp8266_get_stationIP (): Denna funktion ger dig IP / MAC-adressen för de klienter som är anslutna till din softAP.

Provprogram:

Nu när vi har förstått funktionerna för varje kommando i biblioteket, låt oss titta på ett litet exempelprogram. I detta program kommer vi att kontrollera om anslutningen mellan ESP8266 och PIC lyckas och sedan skapa ett WIFI-nätverk (SoftAP) med önskat namn och lösenord. Hela programmet och simuleringen av detsamma kommer att förklaras för din förståelse.

Återigen, om du inte har läst vår PIC-gränssnitt med LCD- och PIC USART-handledning, vänligen läs, innan du fortsätter, för först då är det vettigt för dig.

Eftersom vi precis börjat koppla PIC med ESP8266 har jag använt en LCD-skärm för att se till att saker och ting fungerar ordentligt.

gör {Lcd_Set_Cursor (1,1); Lcd_Print_String ("ESP hittades inte"); } medan (! esp8266_isStarted ()); // vänta tills ESP skickar tillbaka "OK" Lcd_Set_Cursor (1,1); Lcd_Print_String ("ESP är ansluten"); __fördröja_ms (1500); Lcd_Clear ();

När vi skickar "AT" till ESP8266-modulen svarar den tillbaka med "OK". Detta garanterar oss att ESP8266-modulen är ansluten framgångsrikt. Funktionen esp8266_isStarted () används för samma. Vi skickar signalen AT från PIC och vi väntar tills ESP-modulen blir levande och skickar oss ett OK. Om vi får ett OK visar vi att "ESP är ansluten" på LCD-skärmen.

esp8266_mode (2); Lcd_Set_Cursor (1,1); Lcd_Print_String ("ESP inställt som AP"); __fördröja_ms (1500); Lcd_Clear ();

Ovanstående kodrader används för att ställa in ESP-modulen att fungera i “mjukt AP” -läge. Funktionen esp8266_mode (2); skickar AT-kommandona "AT + CWMODE = 3" till modulen och väntar på att modulen ska svara med "OK"

/ * Konfigurera AP-namn och lösenord * / esp8266_config_softAP ("CircuitDigest", "619007123"); Lcd_Set_Cursor (1,1); Lcd_Print_String ("AP konfigurerad"); __fördröja_ms (1500); Lcd_Clear (); / * AP konfigurerad * /

Detta segment av koden används för att konfigurera softAP. Här har vi kallat SSID som “CircuitDigest” och lösenordet som “619007123”. För att indikera att processen är klar väntar vi på att modulen svarar med “OK” och skriver sedan ut AP konfigurerad på LCD-skärmen.

Det är nu vi har gränssnitt ESP8266-modulen med PIC MCU och har konfigurerat softAP med ett namn och lösenord som vi väljer. Som vanligt kan vi simulera den här koden och se hur den fungerar.

Simuleringsutgång:

Vi använder Proteus-programvaran för att simulera utdata. Designfilen för densamma finns i bilagan.

Eftersom vi inte har en ESP8266-modul i Proteus-biblioteket har vi använt Serial-terminalen och svarar tillbaka som användare på PIC-modulen. Simuleringen när skärmen är klar kommer att se ut nedan

Utgången från vår kod visas i den virtuella terminalen. Hela arbetet med simuleringen kommer att förklaras i videon nedan.

Utmatningsverifiering:

När programmet har verifierats med simuleringen, dumpa det i din PIC-mikrokontroller. Gör anslutningarna enligt schemat ovan (Maskinvarusektionen). Du bör kunna spåra dina framsteg genom LCD-skärmen.

När LCD-skärmen säger att AP är konfigurerad kan vi kontrollera det med WIFI-inställningarna i telefon eller bärbar dator. Min bärbara dator visar följande signal enligt vårt program.

Det är det vi har lyckats koppla in ESP8266-modulen med PIC Microcontroller. Detta är ett mycket grundläggande gränssnitt och om du vill göra komplicerade projekt med ESP8266 kan du behöva lägga till dina egna bibliotek eller åtminstone lägga till dina egna funktioner. Lita på mig det är väldigt enkelt att göra det, jag kommer att ge en kort inblick för detsamma.

Lägga till funktioner i ESP8266-biblioteket:

Att lägga till din egen funktion hjälper dig att skicka alla “AT” -kommandon till ESP8266-modulen. För att fortsätta med detta måste du läsa instruktionsdokumentationen för ESP8266-modulen. Du kan skicka alla AT-kommandon som du hittar i instruktionshandboken direkt. Men kom alltid ihåg att lägga till “/ r / n” i slutet av varje AT-kommando. Till exempel om du vill upprätta flera anslutningar med din ESP-modul. Öppna sedan instruktionsuppsättningsdokumentationen och hitta vårt AT-kommando som gör det här jobbet åt dig. Här kommer kommandot “AT + CIPMUX = 1” att låta dig skapa flera anslutningar med din ESP-modul.

Allt du behöver göra är att skicka den här "AP + CIPMUX = 1" till din ESP8266-modul med hjälp av den seriella porten. Det hardcore sättet att göra detta är att helt enkelt använda kommandot

_esp8266_print ("AT + CIPMUX = 1 \ r \ n" ")

Detta fungerar men är inte det bästa sättet att göra det. Du måste läsa tillbaka vad din ESP8266 svarar på ditt kommando. I vårt fall kommer det att svara med “OK”. Så du måste läsa inkommande data från ESP8266-modulen och bekräfta att det är ”OK”. Du kan också göra denna funktion där "1" eller "0" kan skickas som argument.

Fortsätt och försök skapa egna funktioner för biblioteket. Men om du behöver hjälp var du välkommen att använda kommentarsektionen så hjälper jag dig.