Automazione a basso costo con ESP01: 19 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

Oggi parleremo dell'automazione tramite ESP01 con 16 relè. Questo è un modello di design super economico in cui è possibile moltiplicare i moduli e ottenere fino a 128 relè, poiché è possibile inserire fino a otto port expander in questo microcontrollore.

Nel nostro circuito, avrai un'applicazione su uno smartphone che comunica con l'ESP01. Avrà un expander con 16 porte, ciascuna collegata a un relè. Abbiamo anche una sorgente regolabile 3v3. Controlleremo quindi un modulo relè a 16 canali utilizzando ESP01 tramite l'applicazione Android, che vi metto a disposizione.

Passaggio 1: consiglio da ricordare

È importante notare, amici miei, che ho usato questo chip in un circuito chiamato MCP23016. È anche importante che tu guardi il video EXPANSOR OF IOS FOR ESP32, ESP8266 AND ARDUINO, in cui provo il dispositivo e mostro che funziona per questi tre tipi di schede.

Passaggio 2: MCP23016

Qui abbiamo un'immagine dell'MCP23016, che è un chip con 28 pin. È importante menzionare che esiste anche il modello MCP23017, che è più comune e non necessita di resistore e condensatore, perché ha un orologio interno. Questo lo rende più facile, ma il suo blocco è diverso da quello che mostriamo in questo video.

Passaggio 3: indirizzo

Per definire l'indirizzo dell'MCP23016, utilizziamo i pin A0, A1 e A2. Puoi semplicemente lasciarli su HIGH o LOW per il cambio di indirizzo.

L'indirizzo sarà formato come segue:

MCP_Address = 20 + (A2 A1 A0)

Dove A2 A1 A0 può assumere valori ALTO/BASSO, si forma un numero binario da 0 a 7.

Per esempio:

A2> GND, A1> GND, A0> GND (significa 000, quindi 20 + 0 = 20)

O altrimenti, A2> ALTO, A1> GND, A0> ALTO (significa 101, quindi 20 + 5 = 25)

Passaggio 4: comandi

Ecco una tabella con i comandi per la comunicazione:

Passaggio 5: categorie

GP0 / GP1 - Registri porta dati

Ci sono due registri che forniscono l'accesso alle due porte GPIO.

La lettura del registro fornisce lo stato dei pin su quella porta.

Bit = 1> ALTO Bit = 0> BASSO

IODIR0 / IODIR1

Ci sono due registri che controllano la modalità pin. (Ingresso o Uscita)

Bit = 1> INGRESSO Bit = 0> USCITA

Passaggio 6: struttura per la comunicazione

Qui parliamo dell'indirizzo del chip e accediamo al comando e ai dati, che è una sorta di protocollo che deve essere fatto per inviare informazioni.

Passaggio 7: programma

Faremo un programma che consiste nel comunicare l'ESP01 con l'MCP23016 per avere più GPIO da usare. Questi 16 nuovi GPIO che avremo controlleranno un modulo relè a 16 canali.

I comandi verranno inviati a ESP01 tramite un'applicazione Android.

Passaggio 8: MCP23016

Passaggio 9: ESP-01

Questa è una scheda a 16 relè.

Passaggio 10: montaggio di ESP01

Passaggio 11: librerie e variabili

Includeremo le librerie responsabili della comunicazione i2c e della creazione dell'Access Point e del webserver. Definiamo l'indirizzo del chip e delle porte. Infine, definiamo le variabili per memorizzare i valori dei pin MCP.

#include // responsável pela comunicação i2c.#include //responsável por criar o accesspoint eo webserver WiFiServer server(80);//webserver para acessarmos attravés do aplicativo //endereço I2C do MCP23016 #define MCPAddress 0x20 //ENDEREÇOS DE REGISTRADORES # define GP0 0x00 // REGISTRO PORTA DATI 0 #define GP1 0x01 // REGISTRO PORTA DATI 1 #define IODIR0 0x06 // REGISTRO DIREZIONE I/O 0 #define IODIR1 0x07 // REGISTRO DIREZIONE I/O 1 // guarda os valores dos pinos do MCP uint8_t currentValueGP0 = 0; uint8_t currentValueGP1 = 0;

Passaggio 12: configurazione

Inizializziamo l'ESP01 e configuriamo le porte. Configuriamo anche l'Access Point e inizializziamo il server.

void setup() { Serial.begin(9600); ritardo(1000); Wire.begin(0, 2); //ESP01 Wire.setClock(200000); configurePort(IODIR0, OUTPUT); configurePort(IODIR1, OUTPUT); writeBlockData(GP0, 0x00); writeBlockData(GP1, 0x00); setupWiFi(); //configurazione del punto di accesso server.begin();//inizializzazione del server }

Passaggio 13: ciclo

Qui controllo se qualche client è stato connesso al server. Leggiamo anche la prima riga di richiesta. Estraiamo i dati per la manipolazione, definiamo l'intestazione della risposta predefinita e inviamo questa risposta al client.

void loop() { WiFiClient client = server.available(); // Verifica se um cliente foi conectado if (!client) { return; } String req = client.readStringUntil('\r');// Faz a leitura da primeira linha da requisição /* /MR é o header prefixo per sabre se a requisição é a esperada per os relés */ if(req.indexOf ("/MR") != -1) { parserData(req); //a parte la richiesta extrai dati per la manipolazione } else{ Serial.println("richiesta non valida"); Restituzione; } client.flush(); Stringa s = "HTTP/1.1 200 OK\r\n"; // cabeçalho padrão de resposta client.print(s); // envia a resposta para o cliente delay(1); } // termina il ciclo

Passaggio 14: ParserData

Dalla richiesta cerchiamo i dati relativi ai relè. Inviamo quindi i dati all'MCP23016.

//a partir da requisição busca os dados referente aos relésvoid parserData(String data) { uint8_t relay = -1; uint8_t gp = -1; uint8_t valore = -1; int indice = data.indexOf("/MR"); //busca o index do prefixo MR if(data[index+5] == '/') // /MR01/1, onde 0 = GP; 1 = RELE; 1 = ESTADO(on/off) { gp = data[indice+3]-'0'; relè = dati[indice+4]-'0'; valore = dati[indice+6]-'0'; //envia os dados para o MCP23016 //[relay-1] per MCP vai de 0-7 os pinos writePinData(relay-1, value, gp); } }

Passaggio 15: configurazione della porta

Impostiamo la modalità pin GPIO (GP0 o GP1).

//configura o modo dos pinos GPIO (GP0 ou GP1)//como parametro passamos: // port: GP0 ou GP1 // INPUT para todos as portas do GP trabalharem como entrada // OUTPUT para todos as portas do GP trabalharem como saida // custom um valor de 0-255 indicando o modo das portas (1=INPUT, 0=OUTPUT) // ex: 0x01 ou B00000001 o 1: indica que apenas o GPX.0 trabalhará come entrada, o restante come saida void configurePort (uint8_t port, uint8_t custom) { if(custom == INPUT) { writeBlockData(port, 0xFF); } else if(custom == OUTPUT) { writeBlockData(port, 0x00); } else { writeBlockData (porta, personalizzato); } }

Passaggio 16: ScriviPinData

In questa parte del codice, cambiamo lo stato di un pin desiderato e inviamo i dati all'MCP.

//muda o estado de um pino desejado, passando como parametro://pin = pino desejado; valore = 0/1 (acceso/spento); gp = 0/1 (PORT do MCP) void writePinData(int pin, int value, uint8_t gp) { uint8_t statusGP = 0; if(gp == GP0) statusGP = currentValueGP0; else statusGP = currentValueGP1; if (valore == 0) { statusGP &= ~(B00000001 << (pin)); // muda o pino para LOW } else if (valore == 1) { statusGP |= (B00000001 << (pin)); // muda o pino para HIGH } if(gp == GP0) currentValueGP0 = statusGP; altrimenti currentValueGP1 = statusGP; //inviare dati per MCP writeBlockData(gp, statusGP); ritardo(10); }

Passaggio 17: WriteBlockData & SetupWiFi

Qui, inviamo i dati all'MCP23016 tramite il bus i2c. Successivamente, configuriamo le proprietà per abilitare l'Access Point. Infine, abbiamo configurato il WiFi per la modalità Access Point e creato un AP con SSID e PASSWORD.

//invia dati per MCP23016 através do barramento i2c//reg: REGISTRADOR //data: dati (0-255) void writeBlockData(uint8_t port, uint8_t data) { Wire.beginTransmission(MCPAddress); Wire.write(porta); Wire.write(dati); Wire.endTransmission(); ritardo(10); }

//configura come proprietà per abilitare o ACCESS POINTvoid setupWiFi() { WiFi.mode(WIFI_AP); WiFi.softAP("ESP01_RELAY", "12345678"); }

Passaggio 18: App

Per creare l'applicazione, utilizziamo MIT App Inventor 2, a cui si può accedere tramite il link:

ai2.appinventor.mit.edu/

L'applicazione è composta da due schermate contenenti ciascuna otto coppie di pulsanti, che indicano lo stato di ciascun relè.

Di seguito sono riportati alcuni dei blocchi di programmazione utilizzati:

IMPORTANTE: l'indirizzo IP predefinito dell'ESP, poiché il punto di accesso è 192.168.4.1

1. Quando lo schermo si inizializza, memorizziamo l'IP in memoria e chiamiamo la procedura per recuperare lo stato dei pulsanti (ON/OFF).

2. Chiama l'altro schermo

1. Quando si fa clic sul pulsante ON di uno dei relè, verranno apportate modifiche visive al pulsante (blocchi verdi). WebViewer1. GoToUrl effettua una richiesta per il nostro ESP01 collegando i dati MR01 / 1 nell'URL.

2. Quando si fa clic sul pulsante OFF di uno dei relè, verranno apportate modifiche visive al pulsante (blocchi verdi). WebViewer1. GoToUrl effettua una richiesta al nostro ESP01 collegando i dati MR01/0 nell'URL.

Questa procedura serve per recuperare lo stato dei pulsanti (relè), perché quando si cambia schermata si ritorna allo schema di creazione.

Il blocco giallo si ripete per ciascuna delle coppie di pulsanti.

Passaggio 19: download

Ecco i file del progetto da scaricare:

File di progetto MIT App Inventor 2 - download

APK dell'applicazione da installare su Android - download

Scarica gli altri file:

PDF

IO NO