Der Wi-Fi-Transceiver ESP8266 bietet die Möglichkeit, einen Mikrocontroller mit dem Netzwerk zu verbinden. Es wird häufig in IoT-Projekten verwendet, da es billig, winzig und einfach zu bedienen ist. Wir haben es zuvor verwendet, um einen Webserver mit dem Raspberry-Webserver und dem Arduino-Webserver zu erstellen.

In diesem Tutorial werden wir ein ESP8266-Wi-Fi-Modul mit dem ARM7-LPC2148-Mikrocontroller verbinden und einen Webserver zur Steuerung der an LPC2148 angeschlossenen LED erstellen. Der Workflow sieht folgendermaßen aus:

Senden Sie AT-Befehle von LPC2148 an ESP8266, um ESP8266 im AP-Modus zu konfigurieren
Verbinden Sie das WLAN des Laptops oder Computers mit dem ESP8266 Access Point
Erstellen Sie eine HTML-Webseite auf dem PC mit der Access Point-IP-Adresse des ESP8266-Webservers
Erstellen Sie ein Programm für LPC2148, um die LED gemäß dem vom ESP8266 empfangenen Wert zu steuern

Wenn Sie mit dem ESP8266-WLAN-Modul völlig neu sind, besuchen Sie die folgenden Links, um sich mit dem ESP8266-WLAN-Modul vertraut zu machen.

Erste Schritte mit dem ESP8266 Wi-Fi Transceiver (Teil 1)
Erste Schritte mit ESP8266 (Teil 2): Verwenden von AT-Befehlen
Erste Schritte mit ESP8266 (Teil 3): Programmieren von ESP8266 mit Arduino IDE und Flashen des Speichers

Erforderliche Komponenten

Hardware:

ARM7-LPC2148
ESP8266 Wi-Fi-Modul
FTDI (USB zu UART TTL)
LED
3,3 V Spannungsregler-IC
Steckbrett

Software:

KEIL uVision
Flash Magic Tool
Kitt

ESP8266 Wi-Fi-Modul

ESP8266 ist ein kostengünstiges, weit verbreitetes Wi-Fi-Modul für eingebettete Projekte, das eine geringe Leistung von 3,3 V erfordert. Es werden nur zwei Drähte TX und RX für die serielle Kommunikation und Datenübertragung zwischen dem ESP8266 und einem Mikrocontroller mit UART-Anschluss verwendet.

Pin-Diagramm für das Wi-Fi-Modul ESP8266

GND, Masse (0 V)
TX, Datenbit X übertragen
GPIO 2, Allzweck-Ein- / Ausgang Nr. 2
CH_PD, Chip- Abschaltung
GPIO 0, Allzweck-Ein- / Ausgang Nr. 0
RST, Zurücksetzen
RX, Datenbit X empfangen
VCC, Spannung (+3,3 V)

Einrichten der ESP8266-Leiterplatte

ESP8266 benötigt eine konstante Versorgung von 3,3 V und ist nicht Steckbrett-freundlich. In unserem vorherigen Tutorial zu ESP8266 haben wir eine Leiterplatte für ESP8266 mit einem 3,3-V-Spannungsregler, einem RESET-Druckknopf und einem Jumper-Setup für Schaltmodi (AT-Befehl oder Flash-Modus) erstellt. Es kann auch ohne Verwendung eines Perf-Boards auf einem Steckbrett eingerichtet werden.

Hier haben wir alle Komponenten auf das Steckbrett gelötet, um unser eigenes ESP8266-WLAN-Board herzustellen

Erfahren Sie, wie Sie den ESP8266 mit verschiedenen Mikrocontrollern verbinden, indem Sie den folgenden Links folgen:

Erste Schritte mit ESP8266 (Teil 3): Programmieren von ESP8266 mit Arduino IDE und Flashen des Speichers
ESP8266 mit STM32F103C8 verbinden: Webserver erstellen
Senden von E-Mails mit MSP430 Launchpad und ESP8266
Schnittstelle zwischen ESP8266 und PIC16F877A-Mikrocontroller
IOT-basierte Müllcontainerüberwachung mit Arduino & ESP8266

Alle ESP8266-basierten Projekte finden Sie hier.

Verbinden von LPC2148 mit ESP8266 für die serielle Kommunikation

Um ESP8266 mit LPC2148 zu verbinden, müssen wir eine serielle UART-Kommunikation zwischen diesen beiden Geräten herstellen, um AT-Befehle von LPC2148 an ESP8266 zu senden und das ESP8266-Wi-Fi-Modul zu konfigurieren. Um mehr über ESP8266 AT-Befehle zu erfahren, folgen Sie dem Link.

Um die UART-Kommunikation in LPC2148 verwenden zu können, müssen wir den UART-Port in LPC2148 initialisieren. LPC2148 verfügt über zwei integrierte UART-Ports (UART0 und UART1).

UART-Pins in LPC2148

UART_Port	TX_PIN	RX_PIN
UART0	P0.0	P0.1
UART1	P0.8	P0.9

UART0 in LPC2148 initialisieren

Da wir wissen, dass die Pins von LPC2148 Allzweck-Pins sind, müssen wir das PINSEL0-Register für die Verwendung von UART0 verwenden. Bevor Sie UART0 initialisieren, informieren Sie sich über diese UART-Register, die in LPC2148 für die Verwendung der UART-Funktion verwendet werden.

UART-Register in LPC2148

Die folgende Tabelle zeigt einige wichtige Register, die bei der Programmierung verwendet werden. In unseren zukünftigen Tutorials werden wir kurz auf andere Register eingehen, die für UART in LPC2148 verwendet werden.

x-0 für UART0 & x-1 für UART1:

REGISTRIEREN	NAME REGISTRIEREN	VERWENDEN
UxRBR	Pufferregister empfangen	Enthält den kürzlich erhaltenen Wert
UxTHR	Halteregister übertragen	Enthält zu übertragende Daten
UxLCR	Leitungssteuerungsregister	Enthält das UART-Frame-Format (Anzahl der Datenbits, Stoppbit)
UxDLL	Divisor Latch LSB	LSB des UART-Baudratengeneratorwerts
UxDLM	Divisor Latch MSB	MSB des UART-Baudratengeneratorwerts
UxIER	Interrupt Enable Register	Es wird verwendet, um UART0- oder UART1-Interruptquellen zu aktivieren
UxIIR	Interrupt Identification Register	Es enthält den Statuscode, der Priorität und Quelle für ausstehende Interrupts hat

Schaltplan und Anschlüsse

Die Verbindungen zwischen LPC2148, ESP8266 und FTDI sind unten dargestellt

LPC2148	ESP8266	FTDI
TX (P0.0)	RX	NC
RX (P0.1)	TX	RX

Der ESP8266 wird über einen 3,3-V-Spannungsregler mit Strom versorgt, und FTDI und LPC2148 werden über USB mit Strom versorgt.

Warum ist FTDI hier?

In diesem Tutorial haben wir den RX-Pin von FTDI (USB zu UART TTL) mit dem ESP8266 TX-Pin verbunden, der weiter mit dem LPC2148 RX-Pin verbunden ist, sodass wir die Reaktion des ESP8266-Moduls mit einer beliebigen Terminalsoftware wie Putty, Arduino IDE sehen können. Stellen Sie dafür jedoch die Baudrate entsprechend der Baudrate des ESP8266 Wi-Fi-Moduls ein. (Meine Baudrate beträgt 9600).

Schritte zur Programmierung von UART0 in LPC2148 für die Schnittstelle von ESP8266

Im Folgenden finden Sie die Programmierschritte zum Verbinden von ESP8266 mit LPC2148, wodurch es IoT-kompatibel wird.

Schritt 1: - Zuerst müssen wir die UART0 TX & RX-Pins im PINSEL0-Register initialisieren.

(P0.0 als TX und P0.1 als RX) PINSEL0 = PINSEL0 - 0x00000005;

Schritt 2: - Setzen Sie als nächstes in U0LCR (Line Control Register) das DLAB (Divisor Latch Access Bit) auf 1, wenn es diese aktiviert, und setzen Sie dann die Anzahl der Stoppbits auf 1 und die Datenrahmenlänge auf 8 Bit.

U0LCR = 0x83;

Schritt 3: - Jetzt ist es wichtig, die Werte von U0DLL & U0DLM in Abhängigkeit vom PCLK-Wert und der gewünschten Baudrate einzustellen. Normalerweise verwenden wir für ESP8266 eine Baudrate von 9600. Schauen wir uns also an, wie die Baudrate von 9600 für UART0 eingestellt wird.

Formel zur Berechnung der Baudrate:

Wo, PLCK: Peripherietakt in Frequenz (MHz)

U0DLM, U0DLL: Baudratengenerator-Teilerregister

MULVAL, DIVADDVAL: Diese Register sind Bruchgeneratorwerte

Für Baudrate 9600 mit PCLK = 15 MHz

MULVAL = 1 & DIVADDVAL = 0

256 * U0DLM + U0DLL = 97,65

Also U0DLM = 0 und wir bekommen U0DLL = 97 (Bruch nicht erlaubt)

Wir verwenden also folgenden Code:

U0DLM = 0x00; U0DLL = 0x61; (Hexadezimalwert von 97)

Schritt 4: - Schließlich müssen wir DLA (Divisor Latch Access) deaktivieren und in LCR auf 0 setzen.

Also haben wir

U0LCR & = 0x0F;

Schritt 5: - Laden Sie zum Senden eines Zeichens das zu sendende Byte in U0THR und warten Sie, bis das Byte übertragen wird. Dies wird dadurch angezeigt, dass THRE HIGH wird.

void UART0_TxChar (char ch) { U0THR = ch; while ((U0LSR & 0x40) == 0); }}

Schritt 6: - Zum Übertragen eines Strings wird die folgende Funktion verwendet. Um Zeichenfolgendaten einzeln zu senden, haben wir die Zeichenfunktion aus dem obigen Schritt verwendet.

void UART0_SendString (char * str) { uint8_t i = 0; while (str! = '\ 0') { UART0_TxChar (str); i ++; } }

Schritt 7: - Zum Empfangen eines Strings wird hier die Interrupt-Service-Routinefunktion verwendet, da ein ESP8266-Wi-Fi-Modul Daten an den RX-Pin von LPC2148 zurücksendet, wenn wir einen AT-Befehl senden oder wenn ein ESP8266 Daten an LPC2148 sendet, wie wir senden Daten an einen Webserver von ESP8266.

Beispiel: Wenn wir einen AT-Befehl von LPC2148 an ESP8266 senden („AT \ r \ n“), erhalten wir vom Wi-Fi-Modul die Antwort „OK“.

Daher verwenden wir hier einen Interrupt, um den vom Wi-Fi-Modul ESP8266 empfangenen Wert zu überprüfen, da die ISR-Interrupt-Serviceroutine die höchste Priorität hat.

Wenn also ein ESP8266 Daten an den RX-Pin von LPC2148 sendet, wird der Interrupt gesetzt und die ISR-Funktion ausgeführt.

Schritt 8: - Um Interrupts für UART0 zu aktivieren, verwenden Sie den folgenden Code

Das VICintEnable ist ein vektorisiertes Interrupt-Aktivierungsregister, das zum Aktivieren des Interrupts für UART0 verwendet wird.

VICIntEnable - = (1 << 6);

Das VICVecCnt10 ist ein vektorisiertes Interrupt-Steuerregister, das den Steckplatz für UART0 zuweist.

VICVectCntl0 = (1 << 5) - 6;

Als nächstes ist das VICVectaddr0 ein vektorisiertes Interrupt-Adressregister, das die ISR-Adresse der Interrupt-Serviceroutine hat.

VICVectAddr0 = (ohne Vorzeichen) UART0_ISR;

Dann müssen wir den Interrupt für das RBR-Empfangspufferregister zuweisen. Also setzen wir im Interrupt Enable Register (U0IER) auf RBR. Diese Interrupt Service Routine (ISR) wird aufgerufen, wenn wir Daten empfangen.

U0IER = IER_RBR;

Schließlich haben wir die ISR-Funktion, die bestimmte Aufgaben ausführen muss, wenn wir Daten vom ESP8266-Wi-Fi-Modul empfangen. Hier lesen wir einfach den empfangenen Wert vom ESP8266, der im U0RBR vorhanden ist, und speichern diesen Wert im UART0_BUFFER. Schließlich sollte am Ende der ISR der VICVectAddr auf Null oder einen Dummy-Wert gesetzt werden.

void UART0_ISR () __irq { unsigned char IIRValue; IIRValue = U0IIR; IIRValue >> = 1; IIRValue & = 0x02; if (IIRValue == IIR_RDA) { UART_BUFFER = U0RBR; uart0_count ++; if (uart0_count == BUFFER_SIZE) { uart0_count = 0; } } VICVectAddr = 0x0; }}

Schritt 9: - Da das ESP8266-WLAN-Modul im AP-Modus eingestellt sein soll, müssen wir die entsprechenden AT-Befehle von LPC2148 mithilfe der Funktion UART0_SendString () senden.

Die AT-Befehle, die von LPC2148 an ESP8266 gesendet werden, sind unten aufgeführt. Nach dem Senden jedes AT-Befehls antwortet ESP8266 mit "OK".

1. Sendet AT an ESP8266

UART0_SendString ("AT \ r \ n"); delay_ms (3000);

2. Sendet AT + CWMODE = 2 (Einstellung von ESP8266 im AP-Modus).

UART0_SendString ("AT + CWMODE = 2 \ r \ n"); delay_ms (3000);

3. Sendet AT + CIFSR (um die IP von AP zu erhalten)

UART0_SendString ("AT + CIFSR \ r \ n"); delay_ms (3000);

4. Sendet AT + CIPMUX = 1 (für mehrere Verbindungen)

UART0_SendString ("AT + CIPMUX = 1 \ r \ n"); delay_ms (3000);

5. Sendet AT + CIPSERVER = 1,80 (zum Aktivieren des ESP8266-Servers mit geöffnetem Port)

UART0_SendString ("AT + CIPSERVER = 1,80 \ r \ n"); delay_ms (3000);

Programmieren und Flashen der Hex-Datei auf LPC2148

Um ARM7-LPC2148 zu programmieren, benötigen wir das keil uVision & Flash Magic Tool. Hier wird ein USB-Kabel verwendet, um den ARM7 Stick über einen Micro-USB-Anschluss zu programmieren. Wir schreiben Code mit Keil und erstellen eine Hex-Datei. Anschließend wird die HEX-Datei mit Flash Magic auf den ARM7-Stick geflasht. Um mehr über die Installation von keil uVision und Flash Magic und deren Verwendung zu erfahren, folgen Sie dem Link Erste Schritte mit dem ARM7 LPC2148-Mikrocontroller und programmieren Sie ihn mit Keil uVision.

Das vollständige Programm finden Sie am Ende des Tutorials.

Hinweis: Während des Hochladens einer HEX-Datei auf LPC2148 dürfen Sie das ESP8266-WLAN-Modul und das mit LPC2148 verbundene FTDI-Modul nicht mit Strom versorgen.

Steuerung der LED mit ESP8266 IoT Webserver mit LPC2148

Schritt 1: - Schließen Sie nach dem Hochladen der HEX-Datei auf LPC2148 das FTDI-Modul über ein USB-Kabel an den PC an und öffnen Sie die Kitt-Terminal-Software.

Wählen Sie Seriell und dann den COM-Anschluss entsprechend Ihrem PC oder LAPTOP (COM3). Die Baudrate beträgt 9600.

Schritt 2: - Setzen Sie nun das ESP8266-WLAN-Modul zurück oder schalten Sie es einfach aus und wieder ein. Das Kitt-Terminal zeigt die Reaktion des ESP8266-WLAN-Moduls wie unten gezeigt an. \

Schritt 3: - Drücken Sie nun die RESET-Taste am LPC2148. Danach beginnt LPC2148, AT-Befehle an ESP8266 zu senden. Wir können die Reaktion davon im Kittterminal sehen.

Schritt 4: - Wie Sie in der Abbildung oben sehen können, ist der ESP8266 in MODE 2 eingestellt, dh im AP-Modus, und die Adresse von APIP lautet 192.168.4.1. Notieren Sie sich diese Adresse, da diese Adresse im HTML-Code der Webseite fest codiert ist, um die an LPC2148 angeschlossene LED zu steuern.

Wichtig : Wenn sich der ESP8266 im AP-Modus befindet, müssen Sie Ihren PC mit dem ESP8266-AP verbinden. Das Bild unten zeigt, dass mein ESP8266-Modul AP im Namen von ESP_06217B zeigt (es ist offen und hat kein Passwort).

Schritt 5: - Nachdem Sie den PC an den ESP8266 AP angeschlossen haben, öffnen Sie einen Notizblock und kopieren Sie die folgende HTML-Programm-Webseite. Stellen Sie sicher, dass Sie die APIP-Adresse entsprechend Ihrem ESP8266-WLAN-Modul ändern

Willkommen bei Circuit Digest

ESP8266 Schnittstelle mit LPC2148: Erstellen eines Webservers zur Steuerung einer LED
LED EIN LED AUS

Auf dieser HTML-Seite haben wir zwei mit Hyperlinks versehene Schaltflächen zum Ein- und Ausschalten der LED auf der Webseite erstellt.

Schließlich speichern Sie die Notizblock - Dokument als HTML - Erweiterung

Die Webseite wird im Webbrowser wie folgt angezeigt.

Hier ist die Adresse die AP-IP-Adresse 192.168.4.1 und wir senden Werte @ und%, um die LED mithilfe dieser Logik in LPC2148 ein- und auszuschalten.

while (1) { if (uart0_count! = 0) { COMMAND = UART0_BUFFER; if (COMMAND == LEDON) // Logik zum Ein- oder Ausschalten der LED in Abhängigkeit vom empfangenen Wert von ESP8266 { IOSET1 = (1 << 20); // Setzt OUTPUT HIGH delay_ms (100); } else if (COMMAND == LEDOFF) { IOCLR1 = (1 << 20); // Setzt OUTPUT LOW delay_ms (100); } } }

Auf diese Weise kann ein Gerät mit dem ESP8266- und ARM7-Mikrocontroller LPC2148 ferngesteuert werden. Das vollständige Code- und Erklärungsvideo finden Sie unten.

Esp8266-Schnittstelle mit arm7-lpc2148