Mehrkanal-WLAN-Spannungs- und Strommesser - Gunook

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

Beim Breadboarding muss man oft verschiedene Teile der Schaltung gleichzeitig überwachen.

Um das lästige Verkleben der Multimeter-Sonden von einem Ort zum anderen zu vermeiden, wollte ich ein mehrkanaliges Spannungs- und Strommessgerät entwerfen.

Das Ina260-Board von Adafruit bietet hierfür eine sehr effektive und effiziente Möglichkeit. Es enthält einen sehr genauen Spannungs- und Strommesser mit integrierter I2C-Brücke (es spart viele Pins, wenn man 3 davon kombiniert!).

Es fehlte nur noch ein Display. Daher die Entscheidung, die Boards an ein ESP32-Entwicklungsboard anzuschließen, das problemlos einen Webserver tragen kann, um die gemessenen Elemente auf einem PC/mobilem Bildschirm zu präsentieren.

Lieferungen

3 x Ina260 Adafruit-Brett

3 x Kopfstifte mit langen Stiften

Min. 6 Überbrückungsdrähte

1 x ESP32 Wrover-B (oder jedes andere Wifi-Board mit I2C-Unterstützung)

2 x 19-polige Stiftleiste (falls zutreffend)

1 x PCB oder Perfboard

1 x 3,3 V Netzteil

Schritt 1: Löten Sie die drei INA-Boards

Der erste Schritt besteht darin, die drei INA260-Platinen zu montieren.

Eine sehr gute Anleitung findet sich auf der Adafruit-Website. Befolgen Sie die Montageanleitung von Adafruit.

Um diese übereinander stapeln zu können, verwenden Sie statt der mitgelieferten Stiftleisten die langen Stiftleisten!

Schritt 2: Konfigurieren Sie drei verschiedene I2C-Adressen

I2C ist ein serielles Protokoll für eine Zweidraht-Schnittstelle, um Low-Speed-Geräte über kurze Distanzen zu verbinden. Es können bis zu 127 Slaves angeschlossen werden. Auf einem Bus muss jedes Gerät durch eine eindeutige I2C-Adresse identifiziert werden. Die I2C-Adresse eines Geräts ist oft fest im Chip eines Geräts verdrahtet. Um die gleichen Geräte an einen Bus anzuschließen, lässt der Hersteller oft die Möglichkeit, die I2C-Adresse durch Zusammenlöten einer Pin-Konfiguration zu ändern.

Dies gilt auch für die drei INA260-Boards. Das Gerät verfügt über zwei Adresspins, A0 und A1, die mit GND, VS, SCL oder SDA verbunden werden können, um die gewünschte Adresse einzustellen. Im Datenblatt des INA260-Chips von Texas Instruments findet man für jede der 16 möglichen Adressen die Liste der Pin-Anschlüsse.

Das adafruit-Board begrenzt dies auf 4 Boards, indem zwei Pads freigelegt werden, mit denen A0 und / oder A1 auf VS gezogen werden können. Die Standardadresse der INA260-Karte ist 0x40.

Sie schließen diesen Schritt ab, indem Sie den beiden anderen Karten unterschiedliche Adressen zuweisen:

Durch Anlöten des A0-Pads der zweiten Platine setzt man seine Adresse auf: 0x41 (oder 1000001 BIN)

Durch Anlöten des A1-Pads der dritten Platine weisen Sie die Adresse zu: 0x44 (oder 1000100 BIN)

Schritt 3: Verbinden Sie die Ina-Boards mit dem ESP32

Nachdem wir nun jedem der INA-Boards unterschiedliche I2C-Adressen zugewiesen haben, ist es an der Zeit, sie mit dem ESP32-Board zu verbinden!

Verbinden Sie sich gemäß dem obigen Bild

1) der VCC-Pin an den 3,3-V-Pin

2) der GND-Pin zum GND-Pin

3) der SDA-Pin zu GPIO-Pin 21

4) der SCL-Pin zu GPIO-Pin 22

Ich habe ein PCB-Design verwendet, um die Verbindungen herzustellen, da es Teil eines größeren Projekts ist (eine einstellbare WiFi-Spannungsversorgung mit einstellbarer Strombegrenzung - hoffe, auch für dieses eine Anleitung zu machen).

Sie können jede andere Art der Verbindung verwenden, dies kann ein Perfboard sein, das Sie verlöten, oder ein Steckbrett. Beides wird auch gut funktionieren.

Schritt 4: Installieren Sie das ESP32-Board in der Arduino IDE

Nachdem wir die Boards nun miteinander verbunden haben, ist es an der Zeit, die Verbindung zu überprüfen.

Wir werden das tun, indem wir die I2C-Adressen der Ina-Boards sammeln.

Das ESP32-Board funktioniert perfekt mit der Arduino IDE.

Lassen Sie uns das ESP32-Board in Arduino mit dem Board-Manager installieren.

Schritt 5: Überprüfen Sie die Ina-zu-ESP32-Verbindung mit dem I2C-Scanner

Wir werden einen einfachen I2C-Adressscanner verwenden, um die Konnektivität zwischen den ESP32- und den Ina260-Boards sicherzustellen.

Der Code des I2C-Adressscanners kann kopiert und in ein leeres Arduino-Projekt eingefügt werden.

Der Code stammt von der Arduino cc-Website:

// -------------------------------------------------- // i2c_scanner // // Version 1 / / Dieses Programm (oder Code, der so aussieht) // ist an vielen Stellen zu finden. // Zum Beispiel im Arduino.cc-Forum. // Der ursprüngliche Autor ist nicht bekannt. // Version 2, Juni 2012, Using Arduino 1.0.1 // Von Arduino.cc-Benutzer Krodal so einfach wie möglich angepasst // Version 3, 26. Februar 2013 // V3 von louarnold // Version 4, 3. März 2013, Using Arduino 1.0.3 // von Arduino.cc-Benutzer Krodal. // Änderungen von louarnold entfernt. // Scan-Adressen von 0…127 auf 1…119 geändert, // laut i2c-Scanner von Nick Gammon // https://www.gammon.com.au/forum/?id=10896 // Version 5, März 28. November 2013 // Wie Version 4, aber Adresse scannt jetzt auf 127. // Ein Sensor scheint die Adresse 120 zu verwenden. // Version 6, 27. November 2015. // Warte auf die serielle Leonardo-Kommunikation hinzugefügt. // // // Diese Skizze testet die Standard-7-Bit-Adressen // Geräte mit höheren Bitadressen werden möglicherweise nicht richtig erkannt. // #include void setup () { Wire.begin (); Serial.begin (9600); while (!Seriell); // Leonardo: auf seriellen Monitor warten Serial.println("\nI2C Scanner"); aufrechtzuerhalten. Void Schleife () { Bytefehler, Adresse; int nGeräte; Serial.println("Scannen…"); nGeräte = 0; for(address = 1; address < 127; address++) { // Der i2c_scanner verwendet den Rückgabewert von // der Write.endTransmisstion, um zu sehen, ob // ein Gerät die Adresse bestätigt hat. Wire.beginTransmission(Adresse); error = Wire.endTransmission(); if (Fehler == 0) { Serial.print ("I2C-Gerät an Adresse 0x gefunden"); if (Adresse <16) Serial.print ("0"); Serial.print (Adresse, HEX); Serial.println(" !"); nGeräte++; aufrechtzuerhalten. Sonst if (Fehler == 4) { Serial.print ("Unbekannter Fehler bei Adresse 0x"); if (Adresse <16) Serial.print ("0"); Serial.println (Adresse, HEX); } } if (nDevices == 0) Serial.println("Keine I2C-Geräte gefunden\n"); sonst Serial.println("fertig\n"); Verzögerung (5000); // warte 5 Sekunden auf den nächsten Scan }

Schritt 6: Erstellen des HTML-Webserver-Ordners

Der ESP32 bietet die Möglichkeit einen Webserver zu betreiben. Es bietet auch einen ziemlich großen RAM-Speicher, um einige Webseiten zu speichern. (Es komprimiert die Webseitendateien automatisch).

Die Arduino IDE bietet die Funktionalität zum direkten Hochladen der erstellten Webseiten in den RAM des ESP32.

Dazu müssen Sie unter dem Ordner des Arduino-Projekts einen Ordner 'data' erstellen. In meinem Fall ist dies \Arduino\esp32_Power_supply_v1_implemented\data.

Es ist wichtig, den Ordner genau "data" zu benennen, da dies der Ordnername ist, nach dem Arduino beim Hochladen der Webseitendateien zum ESP sucht.

Schritt 7: Erstellen Sie die Power Monitor-Webseite

HMTL ist eine Sprache, die es ermöglicht, einen Text in einem Webbrowser darzustellen. Eine HTML-Datei wird unter der Erweiterung htm(l) gespeichert. Die Formatierung einer Webseite wird normalerweise in einer separaten Datei (zB CSS-Datei) abgelegt. Die Programmfunktionalität, die eine Webseite bieten muss, wird normalerweise in einer anderen Datei abgelegt (zB js-Datei, für Javascript).

In meinem HTML-Dokument habe ich Text, Formatierung und Javascript in einer Datei zusammengefasst. Es ist daher kein gutes Beispiel dafür, wie man eine Webseite erstellt, aber es dient dem Zweck. Ich habe das HTML-Dokument 'Index.htm' genannt.

Eine zweite Datei ist in meinem Datenordner enthalten, dh. PicoGraph.js. Die PicoGraph-Bibliothek wird von Vishnu Shankar B von RainingComputers bereitgestellt und ermöglicht eine sehr einfache, aber effektive und flexible Möglichkeit, Grafiken auf einer Webseite zu präsentieren. Ich habe den Code leicht geändert, um meinen Zweck besser zu erfüllen.

Sie werden feststellen, dass die HTML-Webseite auch den Code zur Steuerung der Spannungsversorgungen auf meiner Platine enthält. Der Spannungsversorgungscode steuert den Spannungspegel von 5 I/O-Pins. Sie können den Code ändern, um dies auszuschließen, oder Sie können ihn beibehalten, wenn keine Auswirkungen vorliegen.

Der HTML-Code wird diesem Schritt als TXT-Datei beigefügt (da die Instructables das Hochladen von HTML-Code nicht zulassen).

Um den HTML-Code zu verwenden, kopieren Sie ihn und fügen ihn in einen Texteditor (ich verwende Notepad ++) ein und speichern ihn als ' Index.htm' im Ordner 'Data'. Machen Sie dasselbe für die Datei picograph.txt, benennen Sie sie jedoch in picograph.js um

Bezüglich der HTML-Datei:

Eine Funktion SndUpdate wird verwendet, um Nachrichten vom ESP an die Webseite hin- und herzuschicken.

Die vom ESP gesendeten Nachrichten dienen der Stromversorgungsfunktionalität und liegen außerhalb des Rahmens für diese Anleitung. die Nachrichten an das ESP dienen den Ina260-Board-Messungen.

var Msg = JSON.parse(xh.responseText); PG1_yrand0=Nachr. PG1_yrand0; PG2_yrand0=Nachr. PG2_yrand0; PG3_yrand0=Nachr. PG3_yrand0; PG4_yrand0=Nachricht. PG4_yrand0; PG5_yrand0=Nachr. PG5_yrand0; PG6_yrand0=Nachr. PG6_yrand0;

Der obige Code liest 6 Zahlen von der ESP32-Platine, dh. die Spannungsmessung, die Strommessung der ersten Platine, gefolgt von den beiden Messungen der zweiten und so weiter.

Die Grafiken sind in sogenannte Flex-Container eingebettet, die eine flexible Größenanpassung der Webseite ermöglichen.

.flex-Container { Anzeige: flex; Hintergrundfarbe: Kadettblau; Flex-Wrap: Wickel; }.flex-container > div { Hintergrundfarbe: #f1f1f1; Rand: 10px; Polsterung: 20px; Schriftgröße: 20px; Schriftfamilie: "Sieben Segmente"; Schriftdicke: fett; }

Der Inhalt jedes der Flex-Container setzt sich wie folgt zusammen, einschließlich der eingebetteten Graphen.

(beachten Sie, dass das wo entfernt wurde)

div label for="PG1_scale"Scale:/label input name="PG1_scale" value="10"brbr !-- Canvas für Thr-Graphen -- canvas /Segeltuch

!-- div für Legenden/Labels --

div /div div /div /div

Der letzte wichtige Abschnitt in der HTML-Datei arbeitet mit der PicoGraph-Bibliothek, um die Zahlen darzustellen:

var PG1_demograph = createGraph("PG1_graphDemo", ["Ch1"], "V", "PG1_graphLabels", 20, 11, false, false, 11, "#e52b50"); var PG2_demograph = createGraph("PG2_graphDemo", ["Ch1"], "mA", "PG2_graphLabels", 20, 11, false, false, 11, "#e52b50"); var PG3_demograph = createGraph("PG3_graphDemo", ["Ch2"], "V", "PG3_graphLabels", 20, 11, false, false, 11, "#008000"); var PG4_demograph = createGraph("PG4_graphDemo", ["Ch2"], "mA", "PG4_graphLabels", 20, 11, false, false, 11, "#008000"); // var PG5_demograph = createGraph("PG5_graphDemo", ["Ch3"], "V", "PG5_graphLabels", 20, 11, false, false, 11, "#0000ff"); var PG6_demograph = createGraph("PG6_graphDemo", ["Ch3"], "mA", "PG6_graphLabels", 20, 11, false, false, 11, "#0000ff"); /* Werte jede Sekunde aktualisieren */ setInterval(updateEverySecond, 1000); Funktion updateEverySecond() { /* Neue Werte abrufen */ SndUpdate();

/* Diagramm aktualisieren */ PG1_demograph.update([PG1_yrand0], parseInt(byID("PG1_scale").value)+ parseInt(byID("PG1_scale").value)/10, "#e52b50"); PG2_demograph.update([PG2_yrand0], parseInt(byID("PG2_scale").value)+ parseInt(byID("PG2_scale").value)/10, "#e52b50"); PG3_demograph.update([PG3_yrand0], parseInt(byID("PG3_scale").value)+ parseInt(byID("PG3_scale").value)/10, "#008000"); PG4_demograph.update([PG4_yrand0], parseInt(byID("PG4_scale").value)+ parseInt(byID("PG4_scale").value)/10, "#008000"); // PG5_demograph.update([PG5_yrand0], parseInt(byID("PG5_scale").value)+ // parseInt(byID("PG5_scale").value)/10, "#0000ff"); PG6_demograph.update([PG6_yrand0], parseInt(byID("PG6_scale").value)+ parseInt(byID("PG6_scale").value)/10, "#0000ff"); var Watts = Math.round(PG1_yrand0 * PG2_yrand0 *100)/100; byID("PG1_wattLabel").innerHTML = ` WATT: ${Watts} mW `; var Watts = Math.round(PG3_yrand0 * PG4_yrand0 *100)/100; byID("PG3_wattLabel").innerHTML = `WATT: ${Watts} mW`; // var Watts = Math.round(PG5_yrand0 * PG6_yrand0 *100)/100; // byID("PG5_wattLabel").innerHTML = `WATT: ${Watts} mW`; byID("PG1_scale").value = Math.floor(parseInt(byID("PG1_scale").value)/2+PG1_yrand0); byID("PG2_scale").value = Math.floor(parseInt(byID("PG2_scale").value)/2+PG2_yrand0); byID("PG3_scale").value = Math.floor(parseInt(byID("PG3_scale").value)/2+PG3_yrand0); byID("PG4_scale").value = Math.floor(parseInt(byID("PG4_scale").value)/2+PG4_yrand0); // byID("PG5_scale").value = Math.floor(parseInt(byID("PG5_scale").value)/2+PG5_yrand0); byID("PG6_scale").value = Math.floor(parseInt(byID("PG6_scale").value)/2+PG6_yrand0);

Wenn Sie den Code studieren, werden Sie feststellen, dass ich nur 5 Diagramme der 6 für meinen Zweck verwende. Wenn Sie die Auskommentierung der rechten Zeilen aufheben, wird die 6. Grafik aktiviert.

Für diejenigen, die keine Erfahrung mit HTML haben, kann dieser Schritt als schwierig empfunden werden. Es kann jedoch als nette Einführung in die Welt von HTML dienen. Ich weiß es, weil dies die erste Seite war, die ich je erstellt habe. Also keine Angst haben. Für diejenigen, die unter uns erfahren sind, verzeiht.

Das Ergebnis Ihrer Arbeit an der Webseite kann durch Öffnen Ihres HTML-Dokuments überprüft werden, es wird in Ihren Browser geladen und zeigt sein Aussehen. Sie können nach möglichen Fehlern suchen, indem Sie die F12-Taste in Ihrem Browser drücken. Das Debugging-Fenster wird angezeigt. Eine vollständige Erklärung zum Debuggen liegt außerhalb des Rahmens dieses instructable, aber die Webseite kann als erster Schritt zum Webseiten- / Javascript-Debugging hilfreich sein.

Der nächste Schritt besteht darin, die erstellten Webseiten in den ESP32 zu laden.

Schritt 8: Webseite in den ESP32 laden

Nachdem Sie ein zufriedenstellendes Ergebnis erhalten haben, ist es an der Zeit, die Webseite in den ESP32 hochzuladen.

Sie tun dies, indem Sie die ' Index.htm' (Ihre Webseite) und die ' PicoGraph.js' im Ordner 'data' unter Ihrem Arduino-Projekt speichern.

Der nächste Schritt besteht darin, die ESP32-Platine an den Computer anzuschließen. Nachdem Sie das richtige Board und den COM-Port ausgewählt haben, wählen Sie den ESP32 Sketch Data Upload im Tools-Menü in der Arduino IDE aus.

Sie werden sehen, dass die IDE mit dem Hochladen beginnt, was zu einem erfolgreichen Laden führen sollte.

Als nächstes muss der ESP32-Mikrocontroller als Webserver konfiguriert werden.

Schritt 9: Konfigurieren Sie den ESP32 als Webserver

Im Anhang finden Sie die Arduino Ino-Skizze, die den ESP32 als Webserver konfiguriert.

Sie müssen die SSID und das zugehörige Passwort durch das Passwort Ihres Routers ersetzen.

Wie bereits erwähnt, enthält diese Skizze auch den Code, um die Webseite als Controller für die Stromversorgungsseite der Leiterplatte zu konfigurieren (tatsächlich werden 5 IO-Pins als PWM-Pins konfiguriert und über den Nachrichtenstrom von der Webseite gesteuert).

Die Skizze basiert auf der von Hristo Gochkov entwickelten Standard-Webserver-Skizze.

Einige Erläuterungen zum Code.

Die folgenden Funktionen beziehen sich alle auf die Einrichtung des Webservers.

String formatBytes(size_t bytes)String getContentType(String Dateiname) bool existiert(String Pfad) bool handleFileRead(String Pfad) void handleFileUpload() void handleFileDelete() void handleFileCreate() void handleFileList()

Auch der erste Code in der setup()-Funktion bezieht sich auf PWM und Webserver-Setup.

Der folgende Code legt die Interrupt-Funktion fest, die die Nachrichtenströme zu und von der Webseite bereitstellt:

(Sie sollten die Kennungen aus der Webseitenerstellung erkennen)

server.on("/SndUpdate", HTTP_GET, () {

String-Nachricht = "{"; Msg+="\"PG1_yrand0\":"+ (String) Vina[1]; Msg+=", \"PG2_yrand0\":"+ (Zeichenfolge) Iina[1]; Msg+=", \"PG3_yrand0\":"+ (Zeichenfolge) Vina[0]; Msg+=", \"PG4_yrand0\":"+ (Zeichenfolge) Iina[0]; Msg+=", \"PG5_yrand0\":"+ (Zeichenfolge) Vina[2]; Msg+=", \"PG6_yrand0\":"+ (Zeichenfolge) Iina[2]; Nachricht+="}";

server.send(200, "text/json", Msg);

Dies startet den Server:

server.begin();

Der nächste Codeblock initialisiert die INA260-Karten:

// INA260-Initialisierung if (! ina260_0x40.begin (0x40)) {Serial.println (F ("Konnte INA260 0x40-Chip nicht finden")); // während (1); } Serial.println (F ("Gefunden INA260-Chip 0x40")); if (!ina260_0x41.begin (0x41)) {Serial.println (F("Konnte 0x41 INA260-Chip nicht finden")); // während (1); } Serial.println (F("INA260 0x41 Chip gefunden")); if (!ina260_0x44.begin (0x44)) {Serial.println (F ("Konnte INA260 0x44 Chip nicht finden")); // während (1); } Serial.println (F ("Gefunden INA260-Chip 0x44"));

ina260_0x40.setAveragingCount(INA260_COUNT_256);

ina260_0x40.setVoltageConversionTime(INA260_TIME_1_1_ms); ina260_0x40.setCurrentConversionTime(INA260_TIME_1_1_ms); ina260_0x40.setMode (INA260_MODE_CONTINUOUS); ina260_0x41.setAveragingCount(INA260_COUNT_256); ina260_0x41.setVoltageConversionTime(INA260_TIME_1_1_ms); ina260_0x41.setCurrentConversionTime(INA260_TIME_1_1_ms); ina260_0x41.setMode (INA260_MODE_CONTINUOUS); ina260_0x44.setAveragingCount(INA260_COUNT_256); ina260_0x44.setVoltageConversionTime(INA260_TIME_1_1_ms); ina260_0x44.setCurrentConversionTime(INA260_TIME_1_1_ms); ina260_0x44.setMode (INA260_MODE_CONTINUOUS);

Im Loop-Code stellt die folgende Anweisung die Behandlung des Interrupt-Codes sicher:

server.handleClient();

Der folgende Code in der Schleifenanweisung bezieht sich auf die Stromversorgungsfunktionalität.

Der folgende Code in der loop() ist wieder interessant:

Vina[0]=ina260_0x40.readBusVoltage()/1000.0f; Iina[0]=ina260_0x40.readCurrent(); Vina[1]=ina260_0x41.readBusVoltage()/1000.0f; Iina[1]=ina260_0x41.readCurrent(); Vina[2]=ina260_0x44.readBusVoltage()/1000.0f; Iina[2]=ina260_0x44.readCurrent();

Diese Anweisungen sammeln und bereiten die Messwerte für die Übertragung auf die Webseite über den Server vor. Bei Interrupt-Aufrufen (alle 1000 ms auftretend, im HTML-Java-Skript der Webseite eingestellt).

Schritt 10: Sie sind fertig

Das Hochladen der Skizze in das ESP32-Board sollte das Setup abschließen und Ihr Power-Monitor sollte endgültig sein!

Sie haben vielleicht bemerkt, dass die Stromversorgung des ESP32 jetzt über den USB-Anschluss erfolgt, dies erhöht einen Großteil der Vorteile der WLAN-basierten Verbindung mit Ihren Spannungs- / Strommessern. Daher habe ich ein einfaches LM317-basiertes spannungsgeregeltes Netzteil für den ESP32 hergestellt. Ich hielt es aus dem Rahmen dieses instructable, aber wenn es Interesse gibt, könnte ein nächstes instructable werden.

Im nächsten Schritt habe ich bereits die elektronische Schaltung für die Stromversorgung erstellt, die als Inspiration dienen könnte.

Schritt 11: Stromversorgung des ESP32

Hiermit eine Inspiration, eine eigenständige Stromquelle für Ihren ESP32 zu bauen, wenn Sie keine herumliegen haben.

Der Stromkreis arbeitet mit einem 19V Laptop-Netzteil. Dies erfordert eine zweiphasige Spannungsabsenkung, um die Verlustleistung des LM317 unter Kontrolle zu halten. (Auch mit Kühlkörpern!). Vergessen Sie auch nicht, einen 100uF-Kondensator vor der VCC_ESP-Leitung einzubauen, da diese Mikrocontroller beim Starten der WiFi-Verbindung sicherlich große Stromschwankungen haben.

Beachten Sie, dass Sie den ESP32 nicht mit mehr als einer Stromquelle gleichzeitig betreiben!

Weiter die üblichen Haftungsausschlüsse, vor allem aber

Spaß haben!

Alle Dateien sind auf meinem GitHub zu finden: