L'émetteur-récepteur Wi-Fi ESP8266 permet de connecter un microcontrôleur au réseau. Il est largement utilisé dans les projets IoT car il est bon marché, petit et facile à utiliser. Nous l'avons précédemment utilisé pour créer un serveur Web à l'aide du serveur Web Raspberry et du serveur Web Arduino.

Dans ce tutoriel, nous allons interfacer un module Wi-Fi ESP8266 avec le microcontrôleur ARM7-LPC2148 et créer un serveur Web pour contrôler la LED connectée au LPC2148. Le flux de travail se déroulera comme suit:

Envoyez des commandes AT de LPC2148 à ESP8266 pour configurer ESP8266 en mode AP
Connectez l'ordinateur portable ou l'ordinateur Wi-Fi au point d'accès ESP8266
Créer une page Web HTML sur PC avec l'adresse IP du point d'accès du serveur Web ESP8266
Créez un programme pour LPC2148 pour contrôler la LED en fonction de la valeur reçue de ESP8266

Si votre module Wi-Fi ESP8266 est complètement nouveau, visitez les liens ci-dessous pour vous familiariser avec le module Wi-Fi ESP8266.

Prise en main de l'émetteur-récepteur Wi-Fi ESP8266 (partie 1)
Premiers pas avec ESP8266 (partie 2): utilisation des commandes AT
Premiers pas avec ESP8266 (Partie 3): Programmation de l'ESP8266 avec Arduino IDE et flashage de sa mémoire

Composants requis

Matériel:

ARM7-LPC2148
Module Wi-Fi ESP8266
FTDI (USB vers UART TTL)
LED
IC régulateur de tension 3.3V
Planche à pain

Logiciel:

KEIL uVision
Outil magique Flash
Mastic

Module Wi-Fi ESP8266

ESP8266 est un module Wi-Fi à faible coût largement utilisé pour les projets embarqués qui nécessite une faible puissance de 3,3V. Il n'utilise que deux fils TX et RX pour la communication série et le transfert de données entre l'ESP8266 et tout microcontrôleur ayant un port UART.

Schéma des broches du module Wi-Fi ESP8266

GND, terre (0 V)
TX, transmettre le bit de données X
GPIO 2, entrée / sortie polyvalente n ° 2
CH_PD, mise hors tension de la puce
GPIO 0, entrée / sortie à usage général n ° 0
RST, réinitialiser
RX, recevoir le bit de données X
VCC, tension (+3,3 V)

Configuration du circuit imprimé ESP8266

L'ESP8266 nécessite une alimentation constante de 3,3 V et n'est pas compatible avec la maquette. Ainsi, dans notre précédent tutoriel sur ESP8266, nous avons réalisé une carte de circuit imprimé pour ESP8266 avec un régulateur de tension 3.3V, un bouton poussoir RESET et une configuration de cavalier pour les modes de commutation (commande AT ou mode flash). Il peut également être configuré sur une maquette sans utiliser de carte de performance.

Ici, nous avons soudé tous les composants de la plaque d'essai pour créer notre propre carte Wi-Fi ESP8266

Découvrez l'interfaçage de l'ESP8266 avec divers microcontrôleurs en suivant les liens ci-dessous:

Premiers pas avec ESP8266 (Partie 3): Programmation de l'ESP8266 avec Arduino IDE et flashage de sa mémoire
Connexion de l'ESP8266 à STM32F103C8: création d'un serveur Web
Envoi d'e-mails à l'aide du Launchpad MSP430 et de l'ESP8266
Interfaçage de l'ESP8266 avec le microcontrôleur PIC16F877A
Surveillance de benne à ordures basée sur l'IOT à l'aide d'Arduino et ESP8266

Tous les projets basés sur ESP8266 peuvent être trouvés ici.

Connexion du LPC2148 à l'ESP8266 pour la communication série

Afin d' interfacer ESP8266 avec LPC2148, nous devons établir une communication série UART entre ces deux appareils pour envoyer des commandes AT de LPC2148 à ESP8266 pour configurer le module Wi-Fi ESP8266. Pour en savoir plus sur les commandes ESP8266 AT, suivez le lien.

Donc, pour utiliser la communication UART dans LPC2148, nous devons initialiser le port UART dans LPC2148. LPC2148 a deux ports UART intégrés (UART0 et UART1).

Broches UART dans LPC2148

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

Initialisation de UART0 dans LPC2148

Comme nous savons que les broches de LPC2148 sont des broches à usage général, nous devons utiliser le registre PINSEL0 pour utiliser UART0. Avant d'initialiser UART0, informez-vous sur ces registres UART utilisés dans LPC2148 pour utiliser la fonction UART.

Registres UART dans LPC2148

Le tableau ci-dessous montre quelques registres importants utilisés en programmation. Dans nos futurs didacticiels, nous verrons brièvement d'autres registres utilisés pour UART dans LPC2148.

x-0 pour UART0 et x-1 pour UART1:

S'INSCRIRE	ENREGISTRER LE NOM	UTILISATION
UxRBR	Recevoir le registre du tampon	Contient la valeur récemment reçue
UxTHR	Transmettre le registre de maintien	Contient des données à transmettre
UxLCR	Registre de contrôle de ligne	Contient le format de trame UART (nombre de bits de données, bit d'arrêt)
UxDLL	Verrou de diviseur LSB	LSB de la valeur du générateur de débit en bauds UART
UxDLM	Loquet de diviseur MSB	MSB de la valeur du générateur de débit en bauds UART
UxIER	Registre d'activation d'interruption	Il est utilisé pour activer les sources d'interruption UART0 ou UART1
UxIIR	Registre d'identification des interruptions	Il contient le code d'état qui a la priorité et la source des interruptions en attente

Schéma de circuit et connexions

Les connexions entre LPC2148, ESP8266 et FTDI sont illustrées ci-dessous

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

L'ESP8266 est alimenté via un régulateur de tension de 3,3 V et le FTDI et le LPC2148 sont alimentés par USB.

Pourquoi FTDI est là?

Dans ce tutoriel, nous avons connecté la broche RX de FTDI (USB vers UART TTL) à la broche ESP8266 TX qui est en outre connectée à la broche LPC2148 RX, afin que nous puissions voir la réponse du module ESP8266 en utilisant n'importe quel logiciel de terminal comme putty, Arduino IDE. Mais pour cela, définissez le débit en bauds en fonction du débit en bauds du module Wi-Fi ESP8266. (Mon débit en bauds est de 9600).

Étapes impliquées dans la programmation UART0 dans LPC2148 pour l'interfaçage ESP8266

Vous trouverez ci-dessous les étapes de programmation pour connecter l'ESP8266 au LPC2148, ce qui le rendra compatible avec l'IoT.

Étape 1: - Nous devons d'abord initialiser les broches UART0 TX & RX dans le registre PINSEL0.

(P0.0 comme TX et P0.1 comme RX) PINSEL0 = PINSEL0 - 0x00000005;

Étape 2: - Ensuite, dans U0LCR (registre de contrôle de ligne), définissez le DLAB (Divisor Latch Access Bit) sur 1 car il les active, puis définissez le nombre de bits d'arrêt sur 1 et la longueur de la trame de données de 8 bits.

U0LCR = 0x83;

Étape 3: - Maintenant, une étape importante à noter est de définir les valeurs de U0DLL et U0DLM en fonction de la valeur PCLK et de la vitesse de transmission souhaitée. Normalement, pour ESP8266, nous utilisons une vitesse de transmission de 9600. Voyons donc comment définir une vitesse de transmission de 9600 pour UART0.

Formule pour le calcul de la vitesse de transmission:

Où, PLCK: horloge périphérique en fréquence (MHz)

U0DLM, U0DLL: registres diviseurs du générateur de vitesse

MULVAL, DIVADDVAL: ces registres sont des valeurs de générateur de fraction

Pour le débit en bauds 9600 avec PCLK = 15 MHZ

MULVAL = 1 & DIVADDVAL = 0

256 * U0DLM + U0DLL = 97,65

Donc U0DLM = 0 et nous obtenons U0DLL = 97 (Fraction non autorisée)

Nous utilisons donc le code suivant:

U0DLM = 0x00; U0DLL = 0x61; (Valeur hexadécimale de 97)

Étape 4: - Enfin, nous devons rendre DLA (Divisor Latch Access) désactivé à 0 dans LCR.

Nous avons donc

U0LCR & = 0x0F;

Etape 5: - Pour transmettre un caractère, chargez l'octet à envoyer dans U0THR et attendez que l'octet soit transmis, ce qui est indiqué par le TROIS passant à HAUT.

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

Étape 6: - Pour transmettre une chaîne, la fonction ci - dessous est utilisée. Pour envoyer des données de chaîne une par une, nous avons utilisé la fonction de caractère de l'étape ci-dessus.

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

Étape 7: - Pour recevoir une chaîne, la fonction de routine de service d'interruption est utilisée ici car un module Wi-Fi ESP8266 transmettra des données à la broche RX de LPC2148 chaque fois que nous envoyons une commande AT ou chaque fois qu'un ESP8266 envoie des données à LPC2148, comme nous envoyons données sur un serveur Web de ESP8266.

Exemple: Lorsque nous envoyons la commande AT à ESP8266 depuis LPC2148 («AT \ r \ n»), nous obtenons une réponse «OK» du module Wi-Fi.

Nous utilisons donc une interruption ici pour vérifier la valeur reçue du module Wi-Fi ESP8266 car la routine de service d'interruption ISR a la priorité la plus élevée.

Ainsi, chaque fois qu'un ESP8266 envoie des données à la broche RX du LPC2148, l'interruption est définie et la fonction ISR est exécutée.

Étape 8: - Pour activer les interruptions pour UART0, utilisez le code suivant

Le VICintEnable est un registre d'activation d'interruption vectorisé utilisé pour activer l'interruption pour UART0.

VICIntEnable - = (1 << 6);

Le VICVecCnt10 est un registre de contrôle d'interruption vectorisé qui alloue un emplacement pour UART0.

VICVectCntl0 = (1 << 5) - 6;

Ensuite, le VICVectaddr0 est un registre d'adresse d'interruption vectorisé qui a l'adresse ISR de routine de service d'interruption.

VICVectAddr0 = (non signé) UART0_ISR;

Ensuite, nous devons affecter l'interruption pour le registre tampon de réception RBR. Ainsi, dans le registre d'activation d'interruption (U0IER), nous définissons RBR. Ainsi, cette routine de service d'interruption (ISR) est appelée lorsque nous recevons des données.

U0IER = IER_RBR;

Enfin, nous avons la fonction ISR qui doit effectuer certaines tâches lorsque nous recevons des données du module Wi-Fi ESP8266. Ici, nous lisons simplement la valeur reçue de l'ESP8266 qui est présente dans le U0RBR et stockons ces valeurs dans le UART0_BUFFER. Enfin, à la fin de l'ISR, le VICVectAddr doit être défini avec zéro ou une valeur fictive.

void UART0_ISR () __irq {caractère non signé IIRValue; IIRValue = U0IIR; IIRValue >> = 1; IIRValue & = 0x02; si (IIRValue == IIR_RDA) { UART_BUFFER = U0RBR; uart0_count ++; if (uart0_count == BUFFER_SIZE) { uart0_count = 0; } } VICVectAddr = 0x0; }

Étape 9: - Comme le module Wi-Fi ESP8266 doit être défini en mode AP, nous devons envoyer les commandes AT respectées à partir de LPC2148 en utilisant la fonction UART0_SendString () .

Les commandes AT qui sont envoyées à ESP8266 à partir de LPC2148 sont mentionnées ci-dessous. Après l'envoi de chaque commande AT, l'ESP8266 répond par «OK»

1. Envoie AT à ESP8266

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

2. Envoie AT + CWMODE = 2 (réglage ESP8266 en mode AP).

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

3. Envoie AT + CIFSR (pour obtenir l'IP d'AP)

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

4. Envoie AT + CIPMUX = 1 (pour plusieurs connexions)

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

5. Envoie AT + CIPSERVER = 1,80 (pour ACTIVER ESP8266 SERVER avec OPEN PORT)

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

Programmation et flashage du fichier hexadécimal vers LPC2148

Pour programmer ARM7-LPC2148, nous avons besoin de l'outil keil uVision & Flash Magic. Un câble USB est utilisé ici pour programmer la clé ARM7 via le port micro USB. Nous écrivons du code en utilisant Keil et créons un fichier hexadécimal, puis le fichier HEX est flashé sur le bâton ARM7 à l'aide de Flash Magic. Pour en savoir plus sur l'installation de keil uVision et Flash Magic et comment les utiliser, suivez le lien Premiers pas avec le microcontrôleur ARM7 LPC2148 et programmez-le à l'aide de Keil uVision.

Le programme complet est donné à la fin du tutoriel.

Remarque: lors du téléchargement du fichier HEX vers le LPC2148, vous ne devez pas alimenter le module Wi-Fi ESP8266 et le module FTDI connecté au LPC2148.

Contrôle de la LED à l'aide du serveur Web IoT ESP8266 avec LPC2148

Étape 1: - Après avoir téléchargé le fichier HEX sur LPC2148, connectez le module FTDI au PC via un câble USB et ouvrez le logiciel du terminal putty.

Sélectionnez Série, puis sélectionnez le port COM en fonction de votre PC ou de votre ordinateur portable était (COM3). Le débit en bauds est de 9600.

Étape 2: - Réinitialisez maintenant le module Wi-Fi ESP8266 ou éteignez-le et rallumez-le, le terminal putty affichera la réponse du module Wi-Fi ESP8266 comme indiqué ci-dessous. \

Étape 3: - Appuyez maintenant sur le bouton RESET du LPC2148. Après cela, LPC2148 commence à envoyer des commandes AT à ESP8266. Nous pouvons voir la réponse de cela dans le terminal putty.

Étape 4: - Comme vous pouvez le voir dans l'image ci-dessus, l'ESP8266 est réglé en MODE 2 qui est le mode AP et l'adresse de l'APIP est 192.168.4.1. Notez cette adresse car cette adresse sera codée en dur dans le code HTML de la page Web pour contrôler la LED connectée au LPC2148.

Important : lorsque l'ESP8266 est en mode AP, vous devez connecter votre PC au point d'accès ESP8266. Voir l'image ci-dessous mon module ESP8266 montre AP au nom de ESP_06217B (il est ouvert et n'a pas de mot de passe).

Étape 5: - Après avoir connecté le PC à l'AP ESP8266, ouvrez un bloc-notes et copiez-collez la page Web du programme HTML suivante. Assurez-vous de changer l'adresse APIP en fonction de votre module Wi-Fi ESP8266

Bienvenue sur Circuit Digest

ESP8266 Interfaçage avec LPC2148: création d'un serveur Web pour contrôler une LED
LED ON LED OFF

Dans cette page HTML, nous avons créé deux boutons hyperliens pour activer et désactiver la LED à partir de la page Web.

Enfin, enregistrez le document du bloc-notes sous l' extension .html

La page Web sera affichée comme ci-dessous dans le navigateur Web.

Ici, l'adresse est l'adresse IP AP 192.168.4.1 et nous envoyons les valeurs @ et% pour allumer et éteindre la LED en utilisant cette logique ci-dessous dans LPC2148.

while (1) { if (uart0_count! = 0) { COMMAND = UART0_BUFFER; if (COMMAND == LEDON) // Logique pour activer ou désactiver la LED en fonction de la valeur reçue de ESP8266 { IOSET1 = (1 << 20); // Définit OUTPUT HIGH delay_ms (100); } else if (COMMANDE == LEDOFF) { IOCLR1 = (1 << 20); // Définit OUTPUT LOW delay_ms (100); } } }

C'est ainsi qu'un appareil peut être contrôlé à distance à l'aide du microcontrôleur ESP8266 et ARM7 LPC2148. Le code complet et la vidéo d'explication sont donnés ci-dessous.

ESP8266 interface avec arm7-lpc2148