Kostengünstige Automatisierung mit ESP01 - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:20

Heute besprechen wir die Automatisierung mit ESP01 mit 16 Relais. Dies ist ein supergünstiges Designmodell, bei dem Sie die Module vervielfachen und bis zu 128 Relais erhalten können, da es möglich ist, bis zu acht Port-Expander in diesen Mikrocontroller zu stecken.

In unserer Rennstrecke haben Sie eine Anwendung auf einem Smartphone, die mit dem ESP01 kommuniziert. Es wird einen Expander mit 16 Ports haben, von denen jeder mit einem Relais verbunden ist. Wir haben auch eine einstellbare 3v3-Quelle. Wir steuern daher ein 16-Kanal-Relaismodul mit ESP01 über die Android-Anwendung, die ich Ihnen zur Verfügung stelle.

Schritt 1: Tipp zum Erinnern

Es ist wichtig anzumerken, meine Freunde, dass ich diesen Chip in einer Schaltung namens MCP23016 verwendet habe. Es ist auch wichtig, dass Sie sich das Video EXPANSOR OF IOS FOR ESP32, ESP8266 AND ARDUINO ansehen, in dem ich das Gerät teste und zeige, dass es für diese drei Board-Typen funktioniert.

Schritt 2: MCP23016

Hier haben wir ein Bild des MCP23016, einem Chip mit 28 Pins. Es ist wichtig zu erwähnen, dass es auch das Modell MCP23017 gibt, das häufiger vorkommt und keinen Widerstand und keinen Kondensator benötigt, da es über eine interne Uhr verfügt. Dies macht es einfacher, aber das Anheften unterscheidet sich von dem, was wir in diesem Video zeigen.

Schritt 3: Adresse

Um die Adresse des MCP23016 zu definieren, verwenden wir die Pins A0, A1 und A2. Sie können sie für die Adressänderung einfach auf HIGH oder LOW belassen.

Die Adresse wird wie folgt gebildet:

MCP_Adresse = 20 + (A2 A1 A0)

Wo A2 A1 A0 HIGH/LOW-Werte annehmen kann, bildet sich eine Binärzahl von 0 bis 7.

Zum Beispiel:

A2> GND, A1> GND, A0> GND (bedeutet 000, dann 20 + 0 = 20)

Oder andernfalls, A2> HIGH, A1> GND, A0> HIGH (bedeutet 101, dann 20 + 5 = 25)

Schritt 4: Befehle

Hier ist eine Tabelle mit Befehlen für die Kommunikation:

Schritt 5: Kategorien

GP0 / GP1 - Datenportregister

Es gibt zwei Register, die den Zugriff auf die beiden GPIO-Ports ermöglichen.

Das Lesen des Registers liefert den Status der Pins an diesem Port.

Bit = 1> HOCH Bit = 0> NIEDRIG

IODIR0 / IODIR1

Es gibt zwei Register, die den Pin-Modus steuern. (Eingabe oder Ausgabe)

Bit = 1> EINGANG Bit = 0> AUSGANG

Schritt 6: Struktur für die Kommunikation

Hier sprechen wir über die Adresse des Chips und greifen auf den Befehl und die Daten zu, was eine Art Protokoll ist, das zum Senden von Informationen ausgeführt werden muss.

Schritt 7: Programm

Wir werden ein Programm erstellen, das darin besteht, den ESP01 mit dem MCP23016 zu kommunizieren, um mehr GPIOs zu verwenden. Diese 16 neuen GPIOs, die wir haben werden, werden ein 16-Kanal-Relaismodul steuern.

Befehle werden über eine Android-Anwendung an ESP01 gesendet.

Schritt 8: MCP23016

Schritt 9: ESP-01

Dies ist eine 16-Relais-Platine.

Schritt 10: Montage ESP01

Schritt 11: Bibliotheken und Variablen

Wir werden die Bibliotheken einbeziehen, die für die i2c-Kommunikation verantwortlich sind und den Access Point und den Webserver erstellen. Wir definieren die Adresse des Chips und der Ports. Schließlich definieren wir die Variablen, um die Werte der MCP-Pins zu speichern.

#include // responsável pela comunicação i2c.#include //responsável por criar o accesspoint eo webserver WiFiServer server(80); // Webserver para acessarmos através do aplicativo //endereço I2C do MCP23016 #define MCPAddress 0x20 //ISTRADORESOS define GP0 0x00 // DATA PORT REGISTER 0 #define GP1 0x01 // DATA PORT REGISTER 1 #define IODIR0 0x06 // I/O DIRECTION REGISTER 0 #define IODIR1 0x07 // I/O DIRECTION REGISTER 1 // guarda os valores dos pinos do MCP uint8_t currentValueGP0 = 0; uint8_t currentValueGP1 = 0;

Schritt 12: Einrichtung

Wir initialisieren den ESP01 und konfigurieren die Ports. Wir konfigurieren auch den Access Point und initialisieren den Server.

Void setup () { Serial.begin (9600); Verzögerung (1000); Draht. Begin(0, 2); // ESP01 Wire.setClock (200000); configurePort (IODIR0, AUSGANG); configurePort (IODIR1, AUSGANG); writeBlockData (GP0, 0x00); writeBlockData(GP1, 0x00); setupWiFi(); //Zugriffspunkt konfigurieren server.begin(); // Initialisierung des Servers }

Schritt 13: Schleife

Hier überprüfe ich, ob Clients mit dem Server verbunden sind. Wir lesen auch die erste Anfragezeile. Wir extrahieren die Daten zur Manipulation, definieren den Standard-Antwortheader und senden diese Antwort an den Client.

Void Schleife () { 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 para sabre se a requisição é a esperada for os relés */ if(req.indexOf ("/MR") != -1) { ParserData(req); // eine partir da requisição extrai os dados para manipulação} else {Serial.println ("ungültige Anfrage"); Rückkehr; } client.flush(); Zeichenfolge 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); } // Schleife beenden

Schritt 14: ParserData

Aus der Anfrage suchen wir nach den Daten zu den Relais. Anschließend senden wir die Daten an den MCP23016.

//ein Teil der Anforderung busca os dados referente aos relésvoid parserData(String data) { uint8_t relay = -1; uint8_t gp = -1; uint8_t-Wert = -1; int index = data.indexOf("/MR"); //busca o index do prefixo MR if(data[index+5] == '/') // /MR01/1, onde 0 = GP; 1 = RELE; 1 = ESTADO (ein/aus) { gp = data[index+3]-'0'; Relais = Daten[index+4]-'0'; Wert = Daten[index+6]-'0'; //envia os dados para o MCP23016 //[Relais-1] porque o MCP vai de 0-7 os pinos writePinData(relay-1, value, gp); } }

Schritt 15: ConfigurePort

Wir stellen den GPIO-Pin-Modus (GP0 oder GP1) ein.

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

Schritt 16: WritePinData

In diesem Teil des Codes ändern wir den Zustand eines gewünschten Pins und senden die Daten an das MCP.

//muda oder estado de um pino desejado, passando como parametro://pin = pino desejado; Wert = 0/1 (ein/aus); gp = 0/1 (PORT tun MCP) void writePinData (int pin, int value, uint8_t gp) {uint8_t statusGP = 0; if(gp == GP0) statusGP = currentValueGP0; sonst statusGP = currentValueGP1; if (Wert == 0) { statusGP &= ~(B00000001 << (Pin)); // muda o pino para LOW} else if (value == 1) { statusGP |= (B00000001 << (pin)); // muda o pino para HIGH} if(gp == GP0) currentValueGP0 = statusGP; sonst currentValueGP1 = statusGP; // envia os dados para o MCP writeBlockData(gp, statusGP); Verzögerung(10); }

Schritt 17: WriteBlockData & SetupWiFi

Hier senden wir Daten über den i2c-Bus an den MCP23016. Als nächstes konfigurieren wir die Eigenschaften, um den Access Point zu aktivieren. Schließlich haben wir das WLAN für den Access Point-Modus konfiguriert und einen AP mit SSID und dem PASSWORT erstellt.

// envia dados para o MCP23016 através do barramento i2c // reg: REGISTRADOR // data: dados (0-255) void writeBlockData(uint8_t port, uint8_t data) { Wire.beginTransmission(MCPAddress); Wire.write (Port); Wire.write (Daten); Wire.endTransmission(); Verzögerung(10); }

// Konfiguriere als proprietades para habilitar o ACCESS POINTvoid setupWiFi () { WiFi.mode (WIFI_AP); WiFi.softAP("ESP01_RELAY", "12345678"); }

Schritt 18: App

Um die Anwendung zu erstellen, verwenden wir MIT App Inventor 2, auf die über den Link zugegriffen werden kann:

ai2.appinventor.mit.edu/

Die Anwendung besteht aus zwei Bildschirmen mit jeweils acht Tastenpaaren, die den Status jedes Relais anzeigen.

Im Folgenden sind einige der verwendeten Programmierblöcke aufgeführt:

WICHTIG: Die Standard-IP-Adresse des ESP als Access Point lautet 192.168.4.1

1. Wenn der Bildschirm initialisiert wird, speichern wir die IP im Speicher und rufen die Prozedur auf, um den Zustand der Tasten wiederherzustellen (ON / OFF).

2. Rufen Sie den anderen Bildschirm auf

1. Wenn Sie auf die EIN-Schaltfläche eines der Relais klicken, nehmen wir visuelle Änderungen an der Schaltfläche vor (grüne Blöcke). WebViewer1. GoToUrl fordert unseren ESP01 an, indem er die MR01 / 1-Daten in der URL verknüpft.

2. Wenn Sie auf die AUS-Schaltfläche eines der Relais klicken, nehmen wir visuelle Änderungen an der Schaltfläche (grüne Blöcke) vor. WebViewer1. GoToUrl stellt eine Anfrage an unseren ESP01, indem es die MR01 / 0-Daten in der URL verknüpft.

Dieses Verfahren wird verwendet, um den Zustand der Schaltflächen (Relais) wiederherzustellen, da beim Ändern des Bildschirms zum Erstellungsmuster zurückgekehrt wird.

Der gelbe Block wiederholt sich für jedes der Tastenpaare.

Schritt 19: Herunterladen

Hier die Projektdateien zum Download:

MIT App Inventor 2 Projektdatei - herunterladen

Anwendung APK auf Android installieren - herunterladen

Laden Sie die anderen Dateien herunter:

PDF

INO