Technik-fan.de Wiki - Benutzerbeiträge [de]

Turnigy 9x

2025-02-26T13:33:43Z

Admin:

In diesem Artikel wird beschrieben wie eine alternative Firmware auf den Modellbau Sender Turnigy 9x aufgespielt werden kann.

* Kabel einlöten
* Programmer anstecken
* Treiber herunterladen: http://sourceforge.net/projects/libusb-win32/files/libusb-win32-releases/1.2.6.0/libusb-win32-bin-1.2.6.0.zip/download
* Win AVR herunterladen: http://sourceforge.net/projects/winavr/files
* Programmieren:

avrdude: stk500v2_command(): command failed
avrdude: stk500v2_command(): unknown status 0xc9
avrdude: stk500v2_program_enable(): cannot get connection status
avrdude: initialization failed, rc=-1
Double check connections and try again, or use -F to override
this check.

'''Um den Fehler zu beseitigen:'''

* Sender Ausschalten
* Alle Kabel zum Programmer und PC verbinden
* Alle Schalter auf "AUS"
* Flachband Kabel der Rückseite des Senders (mit den Batterien) einstecken
* Sender Einschalten

'''avrdude -c avrispmkII -p m64 -v -P usb'''

Reading | ################################################## | 100% 0.03s

avrdude: Device signature = 0x1e9602
avrdude: safemode: lfuse reads as E
avrdude: safemode: hfuse reads as 89
avrdude: safemode: efuse reads as FF

avrdude: safemode: lfuse reads as E
avrdude: safemode: hfuse reads as 89
avrdude: safemode: efuse reads as FF
avrdude: safemode: Fuses OK

avrdude done. Thank you.

Backup anlegen:

<syntaxhighlight lang="C">

'''avrdude -c avrispmkII -p m64 -U flash:r:backupflash.bin:r -v -P usb'''

avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.03s
avrdude: Device signature = 0x1e9602
avrdude: safemode: lfuse reads as E
avrdude: safemode: hfuse reads as 89
avrdude: safemode: efuse reads as FF
avrdude: reading flash memory:
Reading | ################################################## | 100% 12.38s
avrdude: writing output file "backupflash.bin"
avrdude: safemode: lfuse reads as E
avrdude: safemode: hfuse reads as 89
avrdude: safemode: efuse reads as FF
avrdude: safemode: Fuses OK
avrdude done. Thank you.

'''avrdude -c avrispmkII -p m64 -U eeprom:r:backupeeprom.bin:r -v -P usb'''

avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.03s
avrdude: Device signature = 0x1e9602
avrdude: safemode: lfuse reads as E
avrdude: safemode: hfuse reads as 89
avrdude: safemode: efuse reads as FF
avrdude: reading eeprom memory:
Reading | ################################################## | 100% 0.43s
avrdude: writing output file "backupeeprom.bin"
avrdude: safemode: lfuse reads as E
avrdude: safemode: hfuse reads as 89
avrdude: safemode: efuse reads as FF
avrdude: safemode: Fuses OK
avrdude done. Thank you.

</syntaxhighlight>

Flashen:

Datei: th9x.bin in Ordner "C:\Program Files\WinAVR-20100110\bin" kopieren...
'''C:\Program Files\WinAVR-20100110\bin>avrdude -c avrispmkII -p m64 -U flash:w:th9x.bin:a -v -P usb'''

<syntaxhighlight lang="C">
avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.03s

avrdude: Device signature = 0x1e9602
avrdude: safemode: lfuse reads as E
avrdude: safemode: hfuse reads as 89
avrdude: safemode: efuse reads as FF
avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed

To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file "th9x.bin"
avrdude: input file th9x.bin auto detected as raw binary
avrdude: writing flash (44956 bytes):

Writing | ################################################## | 100% 9.47s

avrdude: 44956 bytes of flash written
avrdude: verifying flash memory against th9x.bin:
avrdude: load data flash data from input file th9x.bin:
avrdude: input file th9x.bin auto detected as raw binary
avrdude: input file th9x.bin contains 44956 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 8.71s

avrdude: verifying ...
avrdude: 44956 bytes of flash verified

avrdude: safemode: lfuse reads as E
avrdude: safemode: hfuse reads as 89
avrdude: safemode: efuse reads as FF
avrdude: safemode: Fuses OK

avrdude done. Thank you.
</syntaxhighlight >

Turnigy 9x

2025-02-26T13:33:17Z

Admin:

In diesem Artikel wird beschrieben wie eine alternative Firmware auf den Modellbau Sender Turnigy 9x aufgespielt werden kann.

* Kabel einlöten
* Programmer anstecken
* Treiber herunterladen: http://sourceforge.net/projects/libusb-win32/files/libusb-win32-releases/1.2.6.0/libusb-win32-bin-1.2.6.0.zip/download
* Win AVR herunterladen: http://sourceforge.net/projects/winavr/files
* Programmieren:

avrdude: stk500v2_command(): command failed
avrdude: stk500v2_command(): unknown status 0xc9
avrdude: stk500v2_program_enable(): cannot get connection status
avrdude: initialization failed, rc=-1
Double check connections and try again, or use -F to override
this check.

'''Um den Fehler zu beseitigen:'''

* Sender Ausschalten
* Alle Kabel zum Programmer und PC verbinden
* Alle Schalter auf "AUS"
* Flachband Kabel der Rückseite des Senders (mit den Batterien) einstecken
* Sender Einschalten

'''avrdude -c avrispmkII -p m64 -v -P usb'''

Reading | ################################################## | 100% 0.03s

avrdude: Device signature = 0x1e9602
avrdude: safemode: lfuse reads as E
avrdude: safemode: hfuse reads as 89
avrdude: safemode: efuse reads as FF

avrdude: safemode: lfuse reads as E
avrdude: safemode: hfuse reads as 89
avrdude: safemode: efuse reads as FF
avrdude: safemode: Fuses OK

avrdude done. Thank you.

Backup anlegen:

<syntaxhighlight lang="C">

'''avrdude -c avrispmkII -p m64 -U flash:r:backupflash.bin:r -v -P usb'''

avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.03s
avrdude: Device signature = 0x1e9602
avrdude: safemode: lfuse reads as E
avrdude: safemode: hfuse reads as 89
avrdude: safemode: efuse reads as FF
avrdude: reading flash memory:
Reading | ################################################## | 100% 12.38s
avrdude: writing output file "backupflash.bin"
avrdude: safemode: lfuse reads as E
avrdude: safemode: hfuse reads as 89
avrdude: safemode: efuse reads as FF
avrdude: safemode: Fuses OK
avrdude done. Thank you.

'''avrdude -c avrispmkII -p m64 -U eeprom:r:backupeeprom.bin:r -v -P usb'''

avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.03s
avrdude: Device signature = 0x1e9602
avrdude: safemode: lfuse reads as E
avrdude: safemode: hfuse reads as 89
avrdude: safemode: efuse reads as FF
avrdude: reading eeprom memory:
Reading | ################################################## | 100% 0.43s
avrdude: writing output file "backupeeprom.bin"
avrdude: safemode: lfuse reads as E
avrdude: safemode: hfuse reads as 89
avrdude: safemode: efuse reads as FF
avrdude: safemode: Fuses OK
avrdude done. Thank you.

</syntaxhighlight>

Flashen:

Datei: th9x.bin in Ordner "C:\Program Files\WinAVR-20100110\bin" kopieren...
'''C:\Program Files\WinAVR-20100110\bin>avrdude -c avrispmkII -p m64 -U flash:w:th9x.bin:a -v -P usb'''

<source lang=text>
avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.03s

avrdude: Device signature = 0x1e9602
avrdude: safemode: lfuse reads as E
avrdude: safemode: hfuse reads as 89
avrdude: safemode: efuse reads as FF
avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed

To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file "th9x.bin"
avrdude: input file th9x.bin auto detected as raw binary
avrdude: writing flash (44956 bytes):

Writing | ################################################## | 100% 9.47s

avrdude: 44956 bytes of flash written
avrdude: verifying flash memory against th9x.bin:
avrdude: load data flash data from input file th9x.bin:
avrdude: input file th9x.bin auto detected as raw binary
avrdude: input file th9x.bin contains 44956 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 8.71s

avrdude: verifying ...
avrdude: 44956 bytes of flash verified

avrdude: safemode: lfuse reads as E
avrdude: safemode: hfuse reads as 89
avrdude: safemode: efuse reads as FF
avrdude: safemode: Fuses OK

avrdude done. Thank you.
</source>

Open Energy Monitor

2025-02-26T13:31:47Z

Admin: /* Weblinks */

'''Achtung: Es gibt inzwischen eine neue Version des Open Energy Monitors mit dem ESP32 und WLAN: [[Open Energy Monitor mit dem ESP32]]'''

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe eines Arduinos und des Ethernet Shields der Energieverbrauch auf einer Internet Seite abgebildet werden kann. Das Ziel ist das der Energie Verbrauch einer ganzen Wohnung oder eines Hauses übersichtlich auf einer Website dargestellt wird. Mehr Fotos sind in meinem Picasa Album zu finden: https://picasaweb.google.com/112556810584672853030/OpenEnergyMonitor?authuser=0&feat=directlink

'''Folgende Bauteile werden benötigt:'''
-Arduino UNO Duemilanove oder kompatibel
-Ethernet Shield oder ein anderes kompatibles Shield
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-2x 10kOhm Widerstände 1/4W
-1 Elko 47 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3,5 mm Audio Anschluss

[[Datei:emon2.png|Open Energie Monitor]]

==Elektrotechnische Grundlagen==
Elektrische Leistung wird in Watt gemessen.

'''P = U x I'''
z.B. P = 230V x 0,5A = 115W

In Abhnängikeit mit der Zeit ergeben sich Kilowatt Stunden. Braucht ein Verbraucher z.B. 1000 Watt und ist er eine Stunde in Betrieb, dann wird eine Kilowatt Stunde Energie benötigt.

'''1 kWh = 1000W x 1 h'''

Es wird also Spannung und Strom benötigt um die elektrische Energie zu messen. Da in Deutschland die Spannung nur um +-2V pendelt war es für mich nicht notwendig die Spannung zu messen. Somit beschränkt sich diese Anleitung lediglich auf eine Strom Messung. Der Strom wird dann einfach mit 230 multipliziert. Somit erspart man sich viel Arbeit und Kabel gewirr.

----

Es gibt verschiedene Arten Strom und Spannung zu messen. In handelsüblichen Energie Messgeräten wird meistens eine Strom Messung über einen Shunt Widerstand und einen Operationsverstärker vorgenommen. Das ist relativ günstig und genau (siehe: http://en.wikipedia.org/wiki/Shunt_%28electrical%29). Um größere Ströme zu messen nimmt man häufig induktive Strom Sensoren. Diese werden einfach um das stromführende Kabel "geclipst" und erzeugen je nach Stromfluss eine bestimmte Spannung oder einen bestimmten Strom. Der Vorteil hierbei ist das sich durch die Induktion eine sichere Trennung vor der gefährlichen Netzspannung ergibt.
Zudem ist diese Methode auch gut für Mietwohnungen geeignet, weil die Elektroinstallation nicht geändert werden muss. In manchen kleinen Wohnungen wird nur eine Phase verwendet. Somit wird nur ein Sensor für die Strom Messung verwendet.

''' Achtung: Auf den Leitungen liegt auch dann Netzspannung wenn die Sicherungen abgeschaltet sind!!!'''

[[Datei:emon3.jpg|Open Energie Monitor]]

=Converter Board=
Das Converter Board muss die Spannung oder den Strom (hängt vom Sensor ab, siehe: http://openenergymonitor.org/emon/node/156) in eine Spannung zwischen 0-5V DC umwandeln. Es wird ein Spannungsteiler aufgebaut, der 2,5V für den Sensor erzeugt. Mit dem entsprechendem Arduino Sketch können die Werte dann an dem Analog 0 Port ausgelesen werden. Den Aufbau der Schaltung findet man auf den Webseiten des Open Energie Monitors: http://openenergymonitor.org/emon/node/54

[[Datei:emon4.jpg|Open Energie Monitor]]
[[Datei:emon5.jpg|Open Energie Monitor]]

Die ganze Schaltung passt ohne Probleme in eine 7x7cm Abzweigdose.

[[Datei:emon12.jpg|Open Energie Monitor]]

=Arduino Sketch=
Es empfiehlt sich die Schaltung zuerst über USB zu testen, bevor man sich an die Kommunikation mit dem Ethernet Shield vertraut macht. Die Parameter müssen individuell mit einer "genormten Last" z.B. einem Wasserkocher etc. eingestellt werden. Ein Energie Messgerät sollte natürlich auch vorhanden sein.

Hier ist mein Arduino Sketch mit den Parametern für den 30A Strom Sensor:
[[Media:USBemon.zip|Download Arduino Sketch: USB emon]]

==Kalibrierung==
Ich habe für die Kalibrierung eine umgebaute Steckdosenleiste hergenommen. Dabei muss die Phase aus dem Gehäuse geführt werden. Wenn man den Sensor um das komplette Kabel montiert kann nichts gemessen werden. Das liegt daran das die Ströme sich gegenseitig aufheben. Natürlich ergibt sich in dieser Anordnung ein kleiner Messfehler, weil das Energiekosten Messgerät auch Strom verbraucht. Dieser Fehler ist jedoch sehr gering.

[[Datei:emon6.jpg|Open Energie Monitor]]

Um die Daten zu visualisieren habe ich die Werte einfach in eine Open Office Calc Tabelle kopiert und ein Diagramm erstellt. Nach dem Import mussten lediglich noch die Punkte in Kommas umgewandelt werden. Also z.B.
245.6
245,6

<gallery>
Datei:emon7.png|Samsung Fernseher
Datei:emon8.png|Wasserkocher und Herdplatten
Datei:emon9.png|Energiesparlampe 18W
Datei:emon14.png|Stromverbrauch an einem Samstag Abend.
</gallery>

==Ethernet Shield und emon==
Wenn die Mess Ergebnisse korrekt sind, kann das Ethernet Shield eingebunden werden. Das Sketch besteht aus den Programmen emon und dem Beispiel "Weblient" aus der Ethernet Library. Damit die Daten korrekt und sicher auf den Webserver übermittelt werden können ist es notwendig die API Keys aus dem emoncms Webinterface auszulesen. Die Keys finden sich hier:

[[Datei:emon11.jpg|Open Energie Monitor]]

An dieser Stelle im Arduino Sketch wird der API Key eingetragen:

<source>
client.print("GET /emon/api/post?apikey=9888888888888888888&json={power:");
client.print(watt);
client.print(",temperature:25.0}");
client.println();
</source>

Die lokale IP Adresse und die IP Adresse des Servers muss natürlich auch noch an die eigene Umgebung angepasst werden.

<source>
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192,168,1,152 };
byte server[] = { 111,111,101,111}; // Enter your IP
</source>

[[Media:EthernetAndPowerInet.zip|Download Arduino Sketch: emon and Ethernet]]

Es können so auch mehrere Werte an emoncms übergeben werden. Z.B. Strom, Spannung und Temperatur.

----

In den folgende Schritten soll die Kommunikation mit der MYSQL Datenbank geprpüft werden. Als erstes wird geprüft ob das Shield im lokalen Netz erreichbar ist:

ping 192.168.1.152

Danach muss die Apache Log Datei auf dem Server geprüft werden. Dies kann bei einem Linux Server am besten mit folgendem Befehl geschehen:

tail -f /var/log/apache2/access.log

Um das ganze bunter und übersichtlicher zu gestalten kann man das ganze noch mit ccze "einfärben".

apt-get install ccze
tail -f /var/log/apache2/access.log | '''ccze'''

Bei einer erfolgreichen Verbindung stehen folgende Einträge in der Log Datei:

[[Datei:emon10.png|Open Energie Monitor]]

=Software auf dem Server=

Download der *.zip Archive:

https://github.com/openenergymonitor/emoncms3

Entpacken auf dem Server:

cd /var/www/emon
wget https://github.com/openenergymonitor/emoncms3/tarball/master
mv master openenergymonitor-emoncms3-3a1eb8b.tar
unp openenergymonitor-emoncms3-3a1eb8b.tar
mv openenergymonitor-emoncms3 emon

Die Visualisierung der Daten übernimmt das PHP Script emoncms. Damit das Script auf dem Apache2 Webserver läuft muss die Option AllowOverride All gesetzt werden.

vim /etc/apache2/sites-enabled/000-default

<Directory /var/www/nossl/wiki>
Options Indexes FollowSymLinks MultiViews
'''AllowOverride None'''
Order allow,deny
allow from all
</Directory>

muss geändert werden zu

<Directory /var/www/nossl/wiki>
Options Indexes FollowSymLinks MultiViews
'''AllowOverride All'''
Order allow,deny
allow from all
</Directory>

Nach einem Neustart des Apache Webservers ist die Seite erreichbar:
/etc/init.d/apache2 restart

Danach muss eine Datenbank für emoncms in phpmyadmin angelegt werden. Es ist zu beachten das der Zugriff von jeder IP-Adresse möglich ist, damit der Arduino auch in die SQL Datenbank schreiben darf. Eine Anleitung zur Installation ist hier zu finden:
http://openenergymonitor.org/emon/node/150

==User Registrierung abschalten==
Um zu verhindern das sich fremde Leute in emoncms einloggen kann man den Button registrieren verstecken. Dazu muss folgende Datei verändert werden:
vim /var/www/emon/Views/user/login_block.php

Diese Zeile suchen:
<input type="submit" class="button04" value="Login" onclick="javascript: form.action='<?php echo $GLOBALS['path']; ?>user/login';" /> or
<input ype="submit" class="button04" value="Register" onclick="javascript: form.action='<?php echo $GLOBALS['path']; ?>user/create';" />
und mit dieser Zeile ersetzen:
<input type="submit" class="button04" value="Login" onclick="javascript: form.action='<?php echo $GLOBALS['path']; ?>user/login';" />

==Eigenes Dashboard erstellen==

Das Dashboard kann sehr flexibel angepasst werden. Dabei werden die einzelnen Graphen einfach der Reihe nach in das Feld "Edit Dashboard" geschrieben. Wichtig ist das man immer den korrekten '''Api Key''' und die korrekte '''Feed ID''' einträgt.

Also z.B:

<iframe style="width:925px;height:300px;" marginheight="0" src="http://'''YOURDOMAIN'''/emon/Vis/rawdata.php?apikey='''YOURAPIKEY'''&'''feedid=4'''"
marginwidth="0" frameborder="0" scrolling="no"></iframe>

Hier ein Beispiel für eine schöne Übersicht auf Deutsch:

<source lang=php>
<div class="widget-container-nc">
<h2>Energie Explorer</h2>
<iframe style="width:645px; height:470px;" marginheight="0" marginwidth="0" src="http://YOURDOMAIN/emon/Vis/kWhdZoomer/kwhdzoomer.php?apikey=YOURAPIKEY&kwhd=7&power=4" frameborder="0" scrolling="no">
</iframe>
</div>

<div class="widget-container-v" style="height:562px">
<div class="widget">
<div class="title">Aktueller Energie Verbrauch<b></b></div><b>
<div class="dial" feed="power" max="5000" units="W" scale="1"></div>
</b></div><b>
<div style="clear:both;"></div><br>

<div class="stats" style="height:70px">
<b>Heutiger Energieverbrauch</b><br>
<div class="value"><span class="kwhd"></span> kWh</div>
</div>

<div class="widget">
<div id="house-graph" class="graph" feed="power"></div>
</div>
</b></div>

<iframe style="width:925px;height:300px;" marginheight="0" src="http://YOURDOMAIN/emon/Vis/rawdata.php?apikey=YOURAPIKEY&feedid=4" marginwidth="0" frameborder="0" scrolling="no"></iframe>
<br><br>
</source>

Die Sprache lässt sich einfach in den entsprechenden PHP Dateien ändern:

vim /emon/Vis/kWhdZoomer/view.js
vim /emon/Vis/kWhdZoomer/kwhdzoomer.php

Ergibt z.B. folgendes Dashboard:

[[Datei:emon17.png|Open Energie Monitor]]

Fertige Installation:

[[Datei:emon15.jpg|300px|Open Energie Monitor]][[Datei:emon16.jpg|300px|Open Energie Monitor]]

= Weblinks =

* http://openenergymonitor.org Official Page

Open Energy Monitor

2025-02-26T13:31:32Z

Admin: /* Weblinks */

Einfache Steuerung der parallelen Schnittstelle

2025-02-26T13:30:33Z

Admin:

Ziel dieser Beschreibung ist es, die parallele Schnittstelle über ein Webinterface steuern zu können.
Ich verwende eine Schaltung aus 4 Leds, die auf eine Rochlasterplatine gelötet wurden. Damit kann man sich sehr leicht den Zustand der einzelnen Ports anzeigen lassen. Ich verwende dabei keine Vorwiderstände da ich ultra helle LED's genommen habe. Zur Sicherheit empfiehlt es sich aber 100 Ohm Vorwiderstände zu verwenden.
Im wesentlichen gibt es zwei Möglichkeiten den parallelen Port unter Debian zu steuern. Zum einen lässt sich der Port direkt per Speicher Adresse aus einem C Programm heraus schreiben und lesen. Nachteil dabei: Speicher Adressen darf nur Root schreiben. Es ist also nicht möglich das ganze per www-data User aus einer Website heraus zu starten.
Die andere Möglichkeit besteht darin den Hardware Zugriff über ein C Programm das ein paar Linux Kernel Module benötigt vorzunehmen. Die Module können wiederum einem bestimmten Linux User oder einer Gruppe angehören. So kann der parallele Port dann auch über ein Webfrontend (PHP, Ajax etc.) gesteuert werden. Auf diese Möglichkeit möchte ich hier genauer eingehen.

Als erstes sollten die benötigten Module geladen werden:
modprobe parport
modprobe ppdev

lsmod|grep parport

sollte dann folgende Ausgaben produzieren:
parport_pc 32132 0
parport 33256 2 ppdev,parport_pc
nun benötigen wir den gcc und alle Programme die zum kompilieren nötig sind:
apt-get install build-essential
nun legen wir uns einen Ordner zum kompilieren an. Für alle die wenig Erfahrung im kompilieren von Linux Software haben biete ich hier meine kompilierte ausführbare Datei zum Download an. (Debian etch 2.6.18-6-686):
mkdir /usr/src/blink
cd /usr/src/blink
Darin speichern wir unsere C Quellcode Datei mit folgendem Inhalt:
vim blink.c
Inhalt, das Programm stammt übrigens aus diesem Forumbeitrag:
<syntaxhighlight lang="C">
/*Dieser Code laesst LEDs die an Pins 2...9 (Datenregister)
angeschlossen sind blinken. */

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <linux/ppdev.h>
#include <linux/parport.h>
#include <sys/ioctl.h>

int main()
{
int fd,loop=0;
unsigned char datareg=0xFF;
unsigned char controlreg=0x00;
struct ppdev_frob_struct frob;

/*parallele Schnittstelle Ã¶en*/
if((fd = open ("/dev/parport0", O_RDWR))!=-1)
{
ioctl (fd, PPCLAIM);
}
else
{
printf("Konnte Schnittstelle nicht oeffnen\n");
return 1;
}

/*Pins 2..9 als Ausgang konfigurieren*/
frob.mask = 0x20;
frob.val =0x00;
ioctl (fd, PPFCONTROL, &frob);

/*10 mal LEDs ein- und ausschalten*/
while ((loop++)<1)
{
datareg=0xFF;
ioctl(fd,PPWDATA ,&datareg);
sleep(1);
datareg=0x00;
ioctl(fd,PPWDATA ,&datareg);
sleep(1);
}

/*parallele Schnittstelle schliessen*/
ioctl(fd,PPRELEASE);
close(fd);

return 0;
}
</syntaxhighlight >
Dann wird ein kleines Makefile erstellt:
vim Makefile
Inhalt:
<source lang=bash>
CC = gcc
PROG = blink

all:
$(CC) -c $(PROG).c
$(CC) -o $(PROG) $(PROG).o

clean:
rm -f $(PROG) $(PROG).o *~
</source>
Nun kompilieren wir das ganze mit:
make
und schon erscheint eine ausführbare Datei mit dem Namen blink. Wir starten die Datei mit:
./blink
Jetzt sollten die LED's an der parallelen Schnittstelle aufblinken...Um zu testen ob das Programm auch als www-data User läuft, könnnen wir das Programm als www-data ausführen:
su www-data
./blink
Wenn alles bis dahin klappt können wir uns ein PHP Skript schreiben das dieses Programm über ein Webfrontend aufrufen kann. Ich verwende hier ein einfaches Beispiel um die Funktion darzustellen. Achtung: Wegen Sicherheitslücken sollte das Programm nur zu Testzwecken benützt werden.
apt-get install apache php5
cd /var/www
mkdir blink
chown www-data www-data ../*
vim index.php
Inhalt der Datei index.php:
<source lang=html4strict>
<HTML>

<TITLE>Parallele Schnittstelle per Webfrontend steuern...</TITLE>
</HEAD>
<BODY>
<font face="arial">
<CENTER><h3>Öffnet beim Neu Laden den Parallelport...</h3></CENTER>
<body bgcolor=ffffe9>
</BODY>
</HEAD>
<CENTER>

<html>
<?php
shell_exec('/usr/src/blink');
echo exec('whoami');
?>
</center>
</source>
Nun sollte beim Aufrufen oder Aktualisieren der Seite ein blinken der LED's sichtbar sein. Es sind nun diverse Funktionen möglich. Z.B. können über Optokoppler Relais geschaltet werden. Über diese Relais können so Verbraucher übers Internet geschaltet werden. Zudem kann das ganze mit einem Netzwerkkabel an den S0 Bus der Telefonanlage angeschlossen werden (siehe: CAPI, Asterisk etc.).

Der PC als Temperatur Sensor - Digitemp

2025-02-26T13:29:59Z

Admin:

'''Dieser Artikel beschäftigt sich mit der Temperatur Messung unter Debian Linux. Als Grundlage dient das Digitemp Projekt für den seriellen Anschluss, da die Bauteile günstig zu beschaffen sind und jeder Server mit einer COM Schnittstelle ausgestattet ist.'''
Als erstes sollte man sich ein altes Modem Kabel für die Bauteile besorgen. Man kann dann alles direkt an den Stecker anlöten. Eine ausführliche

Bauanleitung findet ihr hier:
https://systemausfall.org/wikis/howto/DigiTemp
Nun müssen wir das Programm digitemp installieren:
apt-get install digitemp
Konfiguration initialisieren:
digitemp_DS9097 -i -s0 -q -c /root/digitemp.cfg
Jetzt muss Digitemp der Sensor "mitgeteilt" werden mit:
digitemp_DS9097 -i ttyS0
Die Ausgabe sollte dann so aussehen:
Searching the 1-Wire LAN
106C6C7C000000 : DS1820/DS18S20/DS1920 Temperature Sensor
ROM #0 : 106C6C7C01080012
Wrote .digitemprc
Damit man das ganze schön als Graphen anzeigen lassen kann müssen noch die rrdtools installiert werden:
apt-get install rrdtool
Nun erstellen wir ein paar Scripte unter /auktion/rrdtool
cd /auktion/rrdtool
vim erzeugepng.sh
Die Datei sollte mit folgendem Inhalt gefüllt werden:
nice -n 19 /usr/bin/rrdtool graph /var/www/temperatur.png -a PNG -b 1024 --start -129600 -A \
-l 0 -u 30 -t "Zimmer Temperatur" --vertical-label "Grad Celsius" -w 600 -h 200 \
DEF:g1=/auktion/rrdtool/temperatur/temperatur.rrd:gehaeuse:AVERAGE \
DEF:gmin=/auktion/rrdtool/temperatur/temperatur.rrd:gehaeuse:MIN \
DEF:gmax=/auktion/rrdtool/temperatur/temperatur.rrd:gehaeuse:MAX \
VDEF:g1a=g1,LAST \
VDEF:gmina=gmin,MINIMUM \
VDEF:gmaxa=gmax,MAXIMUM \
LINE2:g1#ff0000:"Zimmer Temperatur" \
GPRINT:g1a:"aktuell\: %5.2lf Â°C" \
COMMENT:"(Last updated\: $(/bin/date "+%d.%m.%Y %H\:%M\:%S"))\n"
Datei ausführbar machen mit:
chmod ug+x erzeugepng.sh
Wenn alles geklappt hat erscheint nach Eingabe von:
./erzeugepng.sh
unter dem Ordner /var/www/temperatur.png die Grafik...

Arduino und das Imax B6 Ladegerät

2025-02-26T13:29:21Z

Admin:

=Einleitung=

In dieser Anleitung wird beschrieben wie das Ladegerät Imax B6 über einen Arduino mit dem PC verbunden werden kann. Der Vorteil ist das einfach ein USB Kabel zur Datenübertragung genützt werden kann.

==Hardware==

Damit der Arduino nicht booten kann wird ein Kabel von Masse nach Reset angeschlossen. Als Stecker kann man einfach eine Buchsenleiste (Rastermaß 2,54) feilen damit diese in den Anschluß vom Imax B6 passt.

[[Datei:Imaxb6 1.jpg|Imax B6]]

=Aufbau=
Anschluß des Imax B6 Ladegerätes an den Arduino

[[Datei:Imaxb6 3.jpg|Imax B6]]

Um mit dem Imax B6 auch kleine 160 mAh LiPos zu laden habe ich mir aus einer Universal Platine diesen Adapter zum Laden gebaut.

[[Datei:Imaxb6 2.jpg|Imax B6]]

Der ganze Aufbau mit dem Ladegerät sieht dann so aus:

[[Datei:Imaxb6 4.jpg|Imax B6]]

==Auswertung==

Nach der Arduino Treiber Installation können die Daten am einfachsten mit dem Tool Logview aufgezeichnet und gespeichert werden. Logview kann hier heruntergeladen werden: http://logview.info

Turnigy 160 mAh (Hobbyking)

Zugeführte Ladung: 130 mAh

[[Datei:Lipo160mAh.jpg|800px|Imax B6]]

Lidl Loop Low Self Discharge Mignon Zelle (ähnlich Eneloop)

Zugeführte Ladung: 2230 mAh

Entladen (200 mAh): 1720 mAh

[[Datei:LidlLoop.jpg|800px|Imax B6]]

Alle Senders eines Transponders anzeigen lassen

2025-02-26T13:28:33Z

Admin:

'''Hier eine einfache Möglichkeit um sich alle Senders eines Transponders anzeigen zu lassen'''

In das VDR Verzeichniss wechseln:
cd /etc/vdr
Die Senderliste anzeigen lassen:
vim channels.conf
Für das Erste z.B. erscheint dieser Eintrag:
Das Erste;ARD:410000:C0M64:C:6900:101:102=deu,103=2ch;106=dd:104:0:28106:1:1101:0
Die Nummer des Transponders beträgt in diesem Fall: 410000.
Durch ein grep auf die channels.conf (Suche nach der Transponderfrequenz) werden alle Sender des Transponders angezeigt:
grep 410000 channels.conf
Ausgabe:
<syntaxhighlight lang="C">
Das Erste;ARD:410000:C0M64:C:6900:101:102=deu,103=2ch;106=dd:104:0:28106:1:1101:0
WDR Köln;ARD:410000:C0M64:C:6900:601:602=deu:604:0:28111:1:1101:0
BR-alpha;ARD:410000:C0M64:C:6900:701:702=deu:704:0:28112:1:1101:0
arte;ARD:410000:C0M64:C:6900:401:402=deu,403=fra:404:0:28109:1:1101:0
hr-fernsehen;ARD:410000:C0M64:C:6900:301:302=deu:304:0:28108:1:1101:0
Phoenix;ARD:410000:C0M64:C:6900:901:902=deu:904:0:28114:1:1101:0
SWR Fernsehen BW;ARD:410000:C0M64:C:6900:801:802=deu:804:0:28113:1:1101:0
Bayerisches FS;ARD:410000:C0M64:C:6900:201:202=deu,203=2ch:204:0:28107:1:1101:0
Test-R;ARD:410000:C0M64:C:6900:701:702:204:0:28130:1:1101:0
</syntaxhighlight>

Alle Senders eines Transponders anzeigen lassen

2025-02-26T13:28:25Z

Admin:

'''Hier eine einfache Möglichkeit um sich alle Senders eines Transponders anzeigen zu lassen'''

In das VDR Verzeichniss wechseln:
cd /etc/vdr
Die Senderliste anzeigen lassen:
vim channels.conf
Für das Erste z.B. erscheint dieser Eintrag:
Das Erste;ARD:410000:C0M64:C:6900:101:102=deu,103=2ch;106=dd:104:0:28106:1:1101:0
Die Nummer des Transponders beträgt in diesem Fall: 410000.
Durch ein grep auf die channels.conf (Suche nach der Transponderfrequenz) werden alle Sender des Transponders angezeigt:
grep 410000 channels.conf
Ausgabe:
<syntaxhighlight lang="bash">
Das Erste;ARD:410000:C0M64:C:6900:101:102=deu,103=2ch;106=dd:104:0:28106:1:1101:0
WDR Köln;ARD:410000:C0M64:C:6900:601:602=deu:604:0:28111:1:1101:0
BR-alpha;ARD:410000:C0M64:C:6900:701:702=deu:704:0:28112:1:1101:0
arte;ARD:410000:C0M64:C:6900:401:402=deu,403=fra:404:0:28109:1:1101:0
hr-fernsehen;ARD:410000:C0M64:C:6900:301:302=deu:304:0:28108:1:1101:0
Phoenix;ARD:410000:C0M64:C:6900:901:902=deu:904:0:28114:1:1101:0
SWR Fernsehen BW;ARD:410000:C0M64:C:6900:801:802=deu:804:0:28113:1:1101:0
Bayerisches FS;ARD:410000:C0M64:C:6900:201:202=deu,203=2ch:204:0:28107:1:1101:0
Test-R;ARD:410000:C0M64:C:6900:701:702:204:0:28130:1:1101:0
</syntaxhighlight>

Alle Senders eines Transponders anzeigen lassen

2025-02-26T13:28:01Z

Admin:

'''Hier eine einfache Möglichkeit um sich alle Senders eines Transponders anzeigen zu lassen'''

In das VDR Verzeichniss wechseln:
cd /etc/vdr
Die Senderliste anzeigen lassen:
vim channels.conf
Für das Erste z.B. erscheint dieser Eintrag:
Das Erste;ARD:410000:C0M64:C:6900:101:102=deu,103=2ch;106=dd:104:0:28106:1:1101:0
Die Nummer des Transponders beträgt in diesem Fall: 410000.
Durch ein grep auf die channels.conf (Suche nach der Transponderfrequenz) werden alle Sender des Transponders angezeigt:
grep 410000 channels.conf
Ausgabe:
<syntaxhighlight lang="bash">
Das Erste;ARD:410000:C0M64:C:6900:101:102=deu,103=2ch;106=dd:104:0:28106:1:1101:0
WDR Köln;ARD:410000:C0M64:C:6900:601:602=deu:604:0:28111:1:1101:0
BR-alpha;ARD:410000:C0M64:C:6900:701:702=deu:704:0:28112:1:1101:0
arte;ARD:410000:C0M64:C:6900:401:402=deu,403=fra:404:0:28109:1:1101:0
hr-fernsehen;ARD:410000:C0M64:C:6900:301:302=deu:304:0:28108:1:1101:0
Phoenix;ARD:410000:C0M64:C:6900:901:902=deu:904:0:28114:1:1101:0
SWR Fernsehen BW;ARD:410000:C0M64:C:6900:801:802=deu:804:0:28113:1:1101:0
Bayerisches FS;ARD:410000:C0M64:C:6900:201:202=deu,203=2ch:204:0:28107:1:1101:0
Test-R;ARD:410000:C0M64:C:6900:701:702:204:0:28130:1:1101:0
<\syntaxhighlight>

Fernsehen mit der XBOX - Installation von Xineliboutput auf der xBox

2025-02-26T13:26:34Z

Admin:

==Diese Anleitung orientiert sich an einem Wiki Eintrag und beschreibt die Installation von Xineliboutput mit Hilfe von Xebian auf der XBOX.==

1. Als erstes muss Xebian auf der XBOX installiert werden. Dazu benötigt ihr eine XBOX auf der unsignierte Software läuft. Das Image gibt es hier zum herunterladen.

2. Debian Grundkonfiguration:
Nameserver anpassen:
vim /etc/resolv.conf
Standard Software installieren:
apt-get update
apt-get install vim unp bzip2
Exim4 entfernen, da Mailserver nicht benötigt wird:
apt-get remove --purge exim4
Syntax Highlighting aktivieren:
vim /etc/vim/vimrc
Die Zeile
" syntax on
einkommentieren
syntax on
Falls DHCP gewünscht wird müssen die Interfaces angepasst werden:
vim /etc/network/interfaces
In diesem Fall muss das static in dhcp geändert werden, die 3 Zeilen darunter werden auskommentiert.
vim /etc/apt/sources.list

<syntaxhighlight lang="bash">
deb http://ftp.at.debian.org/debian/ stable main contrib non-free
deb http://non-us.debian.org/debian-non-US stable/non-US main contrib non-free
deb-src http://non-us.debian.org/debian-non-US stable/non-US main contrib non-free
deb http://security.debian.org/ stable/updates main contrib non-free
deb-src http://security.debian.org/ stable/updates main contrib non-free
#Debian Multimedia
deb http://www.debian-multimedia.org etch main
deb-src http://debian-multimedia.org etch main
# VDR
deb http://e-tobi.net/vdr-experimental etch base addons vdr-multipatch
</syntaxhighlight>
apt-get update

'''ACHTUNG NICHT: apt-get upgrade ausführen'''

Nun verbindet man sich am besten per SSH zur XBOX.

3. XServer Installation:
apt-get install xserver-xorg xineliboutput-sxfe xterm xfonts-base xfonts-base
vim /etc/X11/xorg.conf
<source lang=bash>
Section "Files"
FontPath "/usr/share/fonts/X11/misc"
FontPath "/usr/X11R6/lib/X11/fonts/misc"
FontPath "/usr/share/fonts/X11/cyrillic"
FontPath "/usr/X11R6/lib/X11/fonts/cyrillic"
FontPath "/usr/share/fonts/X11/100dpi/:unscaled"
FontPath "/usr/X11R6/lib/X11/fonts/100dpi/:unscaled"
FontPath "/usr/share/fonts/X11/75dpi/:unscaled"
FontPath "/usr/X11R6/lib/X11/fonts/75dpi/:unscaled"
FontPath "/usr/share/fonts/X11/Type1"
FontPath "/usr/X11R6/lib/X11/fonts/Type1"
FontPath "/usr/share/fonts/X11/100dpi"
FontPath "/usr/X11R6/lib/X11/fonts/100dpi"
FontPath "/usr/share/fonts/X11/75dpi"
FontPath "/usr/X11R6/lib/X11/fonts/75dpi"
# path to defoma fonts
FontPath "/var/lib/defoma/x-ttcidfont-conf.d/dirs/TrueType"
EndSection

Section "Module"
Load "bitmap"
Load "dbe"
Load "ddc"
Load "dri"
Load "extmod"
Load "freetype"
Load "glx"
Load "int10"
Load "record"
Load "vbe"
EndSection

Section "InputDevice"
Identifier "Generic Keyboard"
Driver "kbd"
Option "CoreKeyboard"
Option "XkbRules" "xorg"
Option "XkbModel" "pc105"
Option "XkbLayout" "us"
EndSection

Section "InputDevice"
Identifier "Configured Mouse"
Driver "mouse"
Option "CorePointer"
Option "Device" "/dev/input/mice"
Option "Protocol" "ImPS/2"
Option "Emulate3Buttons" "true"
EndSection

Section "Device"
Identifier "nVidia Corporation GeForce3 MX for XBox"
# Driver "nv"
Driver "nvxbox"
Option "UseFBDev" "true"
Option "HWCursor" "false"
# Option "NoAccel" "true"
EndSection

Section "Device"
Identifier "Frame Buffer"
Driver "fbdev"
Option "UseFBDev" "true"
EndSection

Section "Monitor"
Identifier "Generic Monitor"
Option "DPMS"
HorizSync 28-32
VertRefresh 43-60
EndSection

Section "Screen"
Identifier "Default Screen"
Device "nVidia Corporation GeForce3 MX for XBox"
# Device "Frame Buffer"
Monitor "Generic Monitor"
DefaultDepth 24
SubSection "Display"
Depth 1
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 4
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 8
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 15
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 16
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 24
Modes "640x480"
EndSubSection
EndSection

Section "DRI"
Mode 0666
EndSection
</source>
4. Init Skript anpassen:
vim /etc/init.d/xorg
<source lang=bash>
#! /bin/sh
### BEGIN INIT INFO
# Provides: X4VDR
# Required-Start: $local_fs
# Required-Stop: vdr
# Default-Start: 2
# Default-Stop:
# Short-Description: X-Server for VDR
# Description: Starts the X-Server for the VDR.
### END INIT INFO
#
# Author: Helmar Gerloni <helmar@gerloni.net>
# Version: 2006-09-13
#

PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DESC="X-Server for VDR"
NAME=X4VDR
PIDFILE=/var/run/$NAME\.pid
SCRIPTNAME=/etc/init.d/$NAME

#
# Function that starts X.
#
d_start() {
vdr-sxfe --tcp --reconnect --syslog --fullscreen --video=xv xvdr://vdr.server.ip:37890 > /dev/null 2&>1 &
start-stop-daemon --start --background --pidfile $PIDFILE --make-pidfile --exec /usr/bin/X -- :0 vt7 -br -nolisten tcp
if [ $? -gt 0 ]; then
echo "Error starting X-Server."
exit $?
fi
}

#
# Function that stops X.
#
d_stop() {
start-stop-daemon --stop --quiet --pidfile $PIDFILE
if [ $? -gt 0 ]; then
echo "Error stopping X-Server."
fi
}

case "$1" in
start)
echo -n "Starting $DESC: $NAME"
d_start
echo "."
;;
stop)
echo -n "Stopping $DESC: $NAME"
d_stop
echo "."
;;
*)
echo "Usage: $SCRIPTNAME {start|stop|restart|force-reload}" >&2
exit 1
;;
esac

exit 0
</source>
Das Script ausführbar machen mit:
chmod ug+x /etc/init.d/xorg
Das VDR Script startet nun den X-Server und zugleich vdr-sxfe. Zum starten und testen einfach:
/etc/init.d/xorg start
eingeben

Fernsehen mit der XBOX - Installation von Xineliboutput auf der xBox

2025-02-26T13:24:50Z

Admin:

Fernsehen mit der XBOX - Installation von Xineliboutput auf der xBox

2025-02-26T12:56:10Z

Admin:

Fernsehen mit der XBOX - Installation von Xineliboutput auf der xBox

2025-02-26T12:55:54Z

Admin:

==Diese Anleitung orientiert sich an einem Wiki Eintrag und beschreibt die Installation von Xineliboutput mit Hilfe von Xebian auf der XBOX.==

1. Als erstes muss Xebian auf der XBOX installiert werden. Dazu benötigt ihr eine XBOX auf der unsignierte Software läuft. Das Image gibt es hier zum herunterladen.

2. Debian Grundkonfiguration:
Nameserver anpassen:
vim /etc/resolv.conf
Standard Software installieren:
apt-get update
apt-get install vim unp bzip2
Exim4 entfernen, da Mailserver nicht benötigt wird:
apt-get remove --purge exim4
Syntax Highlighting aktivieren:
vim /etc/vim/vimrc
Die Zeile
" syntax on
einkommentieren
syntax on
Falls DHCP gewünscht wird müssen die Interfaces angepasst werden:
vim /etc/network/interfaces
In diesem Fall muss das static in dhcp geändert werden, die 3 Zeilen darunter werden auskommentiert.
vim /etc/apt/sources.list
<syntaxhighlight lang="bash">
deb http://ftp.at.debian.org/debian/ stable main contrib non-free
deb http://non-us.debian.org/debian-non-US stable/non-US main contrib non-free
deb-src http://non-us.debian.org/debian-non-US stable/non-US main contrib non-free
deb http://security.debian.org/ stable/updates main contrib non-free
deb-src http://security.debian.org/ stable/updates main contrib non-free
#Debian Multimedia
deb http://www.debian-multimedia.org etch main
deb-src http://debian-multimedia.org etch main
# VDR
deb http://e-tobi.net/vdr-experimental etch base addons vdr-multipatch
</syntaxhighlight>
apt-get update

'''ACHTUNG NICHT: apt-get upgrade ausführen'''

Nun verbindet man sich am besten per SSH zur XBOX.

3. XServer Installation:
apt-get install xserver-xorg xineliboutput-sxfe xterm xfonts-base xfonts-base
vim /etc/X11/xorg.conf
<source lang=bash>
Section "Files"
FontPath "/usr/share/fonts/X11/misc"
FontPath "/usr/X11R6/lib/X11/fonts/misc"
FontPath "/usr/share/fonts/X11/cyrillic"
FontPath "/usr/X11R6/lib/X11/fonts/cyrillic"
FontPath "/usr/share/fonts/X11/100dpi/:unscaled"
FontPath "/usr/X11R6/lib/X11/fonts/100dpi/:unscaled"
FontPath "/usr/share/fonts/X11/75dpi/:unscaled"
FontPath "/usr/X11R6/lib/X11/fonts/75dpi/:unscaled"
FontPath "/usr/share/fonts/X11/Type1"
FontPath "/usr/X11R6/lib/X11/fonts/Type1"
FontPath "/usr/share/fonts/X11/100dpi"
FontPath "/usr/X11R6/lib/X11/fonts/100dpi"
FontPath "/usr/share/fonts/X11/75dpi"
FontPath "/usr/X11R6/lib/X11/fonts/75dpi"
# path to defoma fonts
FontPath "/var/lib/defoma/x-ttcidfont-conf.d/dirs/TrueType"
EndSection

Section "Module"
Load "bitmap"
Load "dbe"
Load "ddc"
Load "dri"
Load "extmod"
Load "freetype"
Load "glx"
Load "int10"
Load "record"
Load "vbe"
EndSection

Section "InputDevice"
Identifier "Generic Keyboard"
Driver "kbd"
Option "CoreKeyboard"
Option "XkbRules" "xorg"
Option "XkbModel" "pc105"
Option "XkbLayout" "us"
EndSection

Section "InputDevice"
Identifier "Configured Mouse"
Driver "mouse"
Option "CorePointer"
Option "Device" "/dev/input/mice"
Option "Protocol" "ImPS/2"
Option "Emulate3Buttons" "true"
EndSection

Section "Device"
Identifier "nVidia Corporation GeForce3 MX for XBox"
# Driver "nv"
Driver "nvxbox"
Option "UseFBDev" "true"
Option "HWCursor" "false"
# Option "NoAccel" "true"
EndSection

Section "Device"
Identifier "Frame Buffer"
Driver "fbdev"
Option "UseFBDev" "true"
EndSection

Section "Monitor"
Identifier "Generic Monitor"
Option "DPMS"
HorizSync 28-32
VertRefresh 43-60
EndSection

Section "Screen"
Identifier "Default Screen"
Device "nVidia Corporation GeForce3 MX for XBox"
# Device "Frame Buffer"
Monitor "Generic Monitor"
DefaultDepth 24
SubSection "Display"
Depth 1
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 4
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 8
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 15
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 16
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 24
Modes "640x480"
EndSubSection
EndSection

Section "DRI"
Mode 0666
EndSection
</source>
4. Init Skript anpassen:
vim /etc/init.d/xorg
<source lang=bash>
#! /bin/sh
### BEGIN INIT INFO
# Provides: X4VDR
# Required-Start: $local_fs
# Required-Stop: vdr
# Default-Start: 2
# Default-Stop:
# Short-Description: X-Server for VDR
# Description: Starts the X-Server for the VDR.
### END INIT INFO
#
# Author: Helmar Gerloni <helmar@gerloni.net>
# Version: 2006-09-13
#

PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DESC="X-Server for VDR"
NAME=X4VDR
PIDFILE=/var/run/$NAME\.pid
SCRIPTNAME=/etc/init.d/$NAME

#
# Function that starts X.
#
d_start() {
vdr-sxfe --tcp --reconnect --syslog --fullscreen --video=xv xvdr://vdr.server.ip:37890 > /dev/null 2&>1 &
start-stop-daemon --start --background --pidfile $PIDFILE --make-pidfile --exec /usr/bin/X -- :0 vt7 -br -nolisten tcp
if [ $? -gt 0 ]; then
echo "Error starting X-Server."
exit $?
fi
}

#
# Function that stops X.
#
d_stop() {
start-stop-daemon --stop --quiet --pidfile $PIDFILE
if [ $? -gt 0 ]; then
echo "Error stopping X-Server."
fi
}

case "$1" in
start)
echo -n "Starting $DESC: $NAME"
d_start
echo "."
;;
stop)
echo -n "Stopping $DESC: $NAME"
d_stop
echo "."
;;
*)
echo "Usage: $SCRIPTNAME {start|stop|restart|force-reload}" >&2
exit 1
;;
esac

exit 0
</source>
Das Script ausführbar machen mit:
chmod ug+x /etc/init.d/xorg
Das VDR Script startet nun den X-Server und zugleich vdr-sxfe. Zum starten und testen einfach:
/etc/init.d/xorg start
eingeben

Fernsehen mit der XBOX - Installation von Xineliboutput auf der xBox

2025-02-26T12:50:30Z

Admin:

==Diese Anleitung orientiert sich an einem Wiki Eintrag und beschreibt die Installation von Xineliboutput mit Hilfe von Xebian auf der XBOX.==

1. Als erstes muss Xebian auf der XBOX installiert werden. Dazu benötigt ihr eine XBOX auf der unsignierte Software läuft. Das Image gibt es hier zum herunterladen.

2. Debian Grundkonfiguration:
Nameserver anpassen:
vim /etc/resolv.conf
Standard Software installieren:
apt-get update
apt-get install vim unp bzip2
Exim4 entfernen, da Mailserver nicht benötigt wird:
apt-get remove --purge exim4
Syntax Highlighting aktivieren:
vim /etc/vim/vimrc
Die Zeile
" syntax on
einkommentieren
syntax on
Falls DHCP gewünscht wird müssen die Interfaces angepasst werden:
vim /etc/network/interfaces
In diesem Fall muss das static in dhcp geändert werden, die 3 Zeilen darunter werden auskommentiert.
vim /etc/apt/sources.list
<syntaxhighlight lang="bash" line>
deb http://ftp.at.debian.org/debian/ stable main contrib non-free
deb http://non-us.debian.org/debian-non-US stable/non-US main contrib non-free
deb-src http://non-us.debian.org/debian-non-US stable/non-US main contrib non-free
deb http://security.debian.org/ stable/updates main contrib non-free
deb-src http://security.debian.org/ stable/updates main contrib non-free
#Debian Multimedia
deb http://www.debian-multimedia.org etch main
deb-src http://debian-multimedia.org etch main
# VDR
deb http://e-tobi.net/vdr-experimental etch base addons vdr-multipatch
</syntaxhighlight>
apt-get update

'''ACHTUNG NICHT: apt-get upgrade ausführen'''

Nun verbindet man sich am besten per SSH zur XBOX.

3. XServer Installation:
apt-get install xserver-xorg xineliboutput-sxfe xterm xfonts-base xfonts-base
vim /etc/X11/xorg.conf
<source lang=bash>
Section "Files"
FontPath "/usr/share/fonts/X11/misc"
FontPath "/usr/X11R6/lib/X11/fonts/misc"
FontPath "/usr/share/fonts/X11/cyrillic"
FontPath "/usr/X11R6/lib/X11/fonts/cyrillic"
FontPath "/usr/share/fonts/X11/100dpi/:unscaled"
FontPath "/usr/X11R6/lib/X11/fonts/100dpi/:unscaled"
FontPath "/usr/share/fonts/X11/75dpi/:unscaled"
FontPath "/usr/X11R6/lib/X11/fonts/75dpi/:unscaled"
FontPath "/usr/share/fonts/X11/Type1"
FontPath "/usr/X11R6/lib/X11/fonts/Type1"
FontPath "/usr/share/fonts/X11/100dpi"
FontPath "/usr/X11R6/lib/X11/fonts/100dpi"
FontPath "/usr/share/fonts/X11/75dpi"
FontPath "/usr/X11R6/lib/X11/fonts/75dpi"
# path to defoma fonts
FontPath "/var/lib/defoma/x-ttcidfont-conf.d/dirs/TrueType"
EndSection

Section "Module"
Load "bitmap"
Load "dbe"
Load "ddc"
Load "dri"
Load "extmod"
Load "freetype"
Load "glx"
Load "int10"
Load "record"
Load "vbe"
EndSection

Section "InputDevice"
Identifier "Generic Keyboard"
Driver "kbd"
Option "CoreKeyboard"
Option "XkbRules" "xorg"
Option "XkbModel" "pc105"
Option "XkbLayout" "us"
EndSection

Section "InputDevice"
Identifier "Configured Mouse"
Driver "mouse"
Option "CorePointer"
Option "Device" "/dev/input/mice"
Option "Protocol" "ImPS/2"
Option "Emulate3Buttons" "true"
EndSection

Section "Device"
Identifier "nVidia Corporation GeForce3 MX for XBox"
# Driver "nv"
Driver "nvxbox"
Option "UseFBDev" "true"
Option "HWCursor" "false"
# Option "NoAccel" "true"
EndSection

Section "Device"
Identifier "Frame Buffer"
Driver "fbdev"
Option "UseFBDev" "true"
EndSection

Section "Monitor"
Identifier "Generic Monitor"
Option "DPMS"
HorizSync 28-32
VertRefresh 43-60
EndSection

Section "Screen"
Identifier "Default Screen"
Device "nVidia Corporation GeForce3 MX for XBox"
# Device "Frame Buffer"
Monitor "Generic Monitor"
DefaultDepth 24
SubSection "Display"
Depth 1
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 4
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 8
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 15
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 16
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 24
Modes "640x480"
EndSubSection
EndSection

Section "DRI"
Mode 0666
EndSection
</source>
4. Init Skript anpassen:
vim /etc/init.d/xorg
<source lang=bash>
#! /bin/sh
### BEGIN INIT INFO
# Provides: X4VDR
# Required-Start: $local_fs
# Required-Stop: vdr
# Default-Start: 2
# Default-Stop:
# Short-Description: X-Server for VDR
# Description: Starts the X-Server for the VDR.
### END INIT INFO
#
# Author: Helmar Gerloni <helmar@gerloni.net>
# Version: 2006-09-13
#

PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DESC="X-Server for VDR"
NAME=X4VDR
PIDFILE=/var/run/$NAME\.pid
SCRIPTNAME=/etc/init.d/$NAME

#
# Function that starts X.
#
d_start() {
vdr-sxfe --tcp --reconnect --syslog --fullscreen --video=xv xvdr://vdr.server.ip:37890 > /dev/null 2&>1 &
start-stop-daemon --start --background --pidfile $PIDFILE --make-pidfile --exec /usr/bin/X -- :0 vt7 -br -nolisten tcp
if [ $? -gt 0 ]; then
echo "Error starting X-Server."
exit $?
fi
}

#
# Function that stops X.
#
d_stop() {
start-stop-daemon --stop --quiet --pidfile $PIDFILE
if [ $? -gt 0 ]; then
echo "Error stopping X-Server."
fi
}

case "$1" in
start)
echo -n "Starting $DESC: $NAME"
d_start
echo "."
;;
stop)
echo -n "Stopping $DESC: $NAME"
d_stop
echo "."
;;
*)
echo "Usage: $SCRIPTNAME {start|stop|restart|force-reload}" >&2
exit 1
;;
esac

exit 0
</source>
Das Script ausführbar machen mit:
chmod ug+x /etc/init.d/xorg
Das VDR Script startet nun den X-Server und zugleich vdr-sxfe. Zum starten und testen einfach:
/etc/init.d/xorg start
eingeben

Fernsehen mit der XBOX - Installation von Xineliboutput auf der xBox

2025-02-26T12:49:52Z

Admin:

==Diese Anleitung orientiert sich an einem Wiki Eintrag und beschreibt die Installation von Xineliboutput mit Hilfe von Xebian auf der XBOX.==

1. Als erstes muss Xebian auf der XBOX installiert werden. Dazu benötigt ihr eine XBOX auf der unsignierte Software läuft. Das Image gibt es hier zum herunterladen.

2. Debian Grundkonfiguration:
Nameserver anpassen:
vim /etc/resolv.conf
Standard Software installieren:
apt-get update
apt-get install vim unp bzip2
Exim4 entfernen, da Mailserver nicht benötigt wird:
apt-get remove --purge exim4
Syntax Highlighting aktivieren:
vim /etc/vim/vimrc
Die Zeile
" syntax on
einkommentieren
syntax on
Falls DHCP gewünscht wird müssen die Interfaces angepasst werden:
vim /etc/network/interfaces
In diesem Fall muss das static in dhcp geändert werden, die 3 Zeilen darunter werden auskommentiert.
vim /etc/apt/sources.list
<syntaxhighlight lang="C" line>
deb http://ftp.at.debian.org/debian/ stable main contrib non-free
deb http://non-us.debian.org/debian-non-US stable/non-US main contrib non-free
deb-src http://non-us.debian.org/debian-non-US stable/non-US main contrib non-free
deb http://security.debian.org/ stable/updates main contrib non-free
deb-src http://security.debian.org/ stable/updates main contrib non-free
#Debian Multimedia
deb http://www.debian-multimedia.org etch main
deb-src http://debian-multimedia.org etch main
# VDR
deb http://e-tobi.net/vdr-experimental etch base addons vdr-multipatch
</syntaxhighlight>
apt-get update

'''ACHTUNG NICHT: apt-get upgrade ausführen'''

Nun verbindet man sich am besten per SSH zur XBOX.

3. XServer Installation:
apt-get install xserver-xorg xineliboutput-sxfe xterm xfonts-base xfonts-base
vim /etc/X11/xorg.conf
<source lang=bash>
Section "Files"
FontPath "/usr/share/fonts/X11/misc"
FontPath "/usr/X11R6/lib/X11/fonts/misc"
FontPath "/usr/share/fonts/X11/cyrillic"
FontPath "/usr/X11R6/lib/X11/fonts/cyrillic"
FontPath "/usr/share/fonts/X11/100dpi/:unscaled"
FontPath "/usr/X11R6/lib/X11/fonts/100dpi/:unscaled"
FontPath "/usr/share/fonts/X11/75dpi/:unscaled"
FontPath "/usr/X11R6/lib/X11/fonts/75dpi/:unscaled"
FontPath "/usr/share/fonts/X11/Type1"
FontPath "/usr/X11R6/lib/X11/fonts/Type1"
FontPath "/usr/share/fonts/X11/100dpi"
FontPath "/usr/X11R6/lib/X11/fonts/100dpi"
FontPath "/usr/share/fonts/X11/75dpi"
FontPath "/usr/X11R6/lib/X11/fonts/75dpi"
# path to defoma fonts
FontPath "/var/lib/defoma/x-ttcidfont-conf.d/dirs/TrueType"
EndSection

Section "Module"
Load "bitmap"
Load "dbe"
Load "ddc"
Load "dri"
Load "extmod"
Load "freetype"
Load "glx"
Load "int10"
Load "record"
Load "vbe"
EndSection

Section "InputDevice"
Identifier "Generic Keyboard"
Driver "kbd"
Option "CoreKeyboard"
Option "XkbRules" "xorg"
Option "XkbModel" "pc105"
Option "XkbLayout" "us"
EndSection

Section "InputDevice"
Identifier "Configured Mouse"
Driver "mouse"
Option "CorePointer"
Option "Device" "/dev/input/mice"
Option "Protocol" "ImPS/2"
Option "Emulate3Buttons" "true"
EndSection

Section "Device"
Identifier "nVidia Corporation GeForce3 MX for XBox"
# Driver "nv"
Driver "nvxbox"
Option "UseFBDev" "true"
Option "HWCursor" "false"
# Option "NoAccel" "true"
EndSection

Section "Device"
Identifier "Frame Buffer"
Driver "fbdev"
Option "UseFBDev" "true"
EndSection

Section "Monitor"
Identifier "Generic Monitor"
Option "DPMS"
HorizSync 28-32
VertRefresh 43-60
EndSection

Section "Screen"
Identifier "Default Screen"
Device "nVidia Corporation GeForce3 MX for XBox"
# Device "Frame Buffer"
Monitor "Generic Monitor"
DefaultDepth 24
SubSection "Display"
Depth 1
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 4
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 8
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 15
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 16
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 24
Modes "640x480"
EndSubSection
EndSection

Section "DRI"
Mode 0666
EndSection
</source>
4. Init Skript anpassen:
vim /etc/init.d/xorg
<source lang=bash>
#! /bin/sh
### BEGIN INIT INFO
# Provides: X4VDR
# Required-Start: $local_fs
# Required-Stop: vdr
# Default-Start: 2
# Default-Stop:
# Short-Description: X-Server for VDR
# Description: Starts the X-Server for the VDR.
### END INIT INFO
#
# Author: Helmar Gerloni <helmar@gerloni.net>
# Version: 2006-09-13
#

PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DESC="X-Server for VDR"
NAME=X4VDR
PIDFILE=/var/run/$NAME\.pid
SCRIPTNAME=/etc/init.d/$NAME

#
# Function that starts X.
#
d_start() {
vdr-sxfe --tcp --reconnect --syslog --fullscreen --video=xv xvdr://vdr.server.ip:37890 > /dev/null 2&>1 &
start-stop-daemon --start --background --pidfile $PIDFILE --make-pidfile --exec /usr/bin/X -- :0 vt7 -br -nolisten tcp
if [ $? -gt 0 ]; then
echo "Error starting X-Server."
exit $?
fi
}

#
# Function that stops X.
#
d_stop() {
start-stop-daemon --stop --quiet --pidfile $PIDFILE
if [ $? -gt 0 ]; then
echo "Error stopping X-Server."
fi
}

case "$1" in
start)
echo -n "Starting $DESC: $NAME"
d_start
echo "."
;;
stop)
echo -n "Stopping $DESC: $NAME"
d_stop
echo "."
;;
*)
echo "Usage: $SCRIPTNAME {start|stop|restart|force-reload}" >&2
exit 1
;;
esac

exit 0
</source>
Das Script ausführbar machen mit:
chmod ug+x /etc/init.d/xorg
Das VDR Script startet nun den X-Server und zugleich vdr-sxfe. Zum starten und testen einfach:
/etc/init.d/xorg start
eingeben

Fernsehen mit der XBOX - Installation von Xineliboutput auf der xBox

2025-02-26T12:49:00Z

Admin:

==Diese Anleitung orientiert sich an einem Wiki Eintrag und beschreibt die Installation von Xineliboutput mit Hilfe von Xebian auf der XBOX.==

1. Als erstes muss Xebian auf der XBOX installiert werden. Dazu benötigt ihr eine XBOX auf der unsignierte Software läuft. Das Image gibt es hier zum herunterladen.

2. Debian Grundkonfiguration:
Nameserver anpassen:
vim /etc/resolv.conf
Standard Software installieren:
apt-get update
apt-get install vim unp bzip2
Exim4 entfernen, da Mailserver nicht benötigt wird:
apt-get remove --purge exim4
Syntax Highlighting aktivieren:
vim /etc/vim/vimrc
Die Zeile
" syntax on
einkommentieren
syntax on
Falls DHCP gewünscht wird müssen die Interfaces angepasst werden:
vim /etc/network/interfaces
In diesem Fall muss das static in dhcp geändert werden, die 3 Zeilen darunter werden auskommentiert.
vim /etc/apt/sources.list
<syntaxhighlight lang="bash" line>
deb http://ftp.at.debian.org/debian/ stable main contrib non-free
deb http://non-us.debian.org/debian-non-US stable/non-US main contrib non-free
deb-src http://non-us.debian.org/debian-non-US stable/non-US main contrib non-free
deb http://security.debian.org/ stable/updates main contrib non-free
deb-src http://security.debian.org/ stable/updates main contrib non-free
#Debian Multimedia
deb http://www.debian-multimedia.org etch main
deb-src http://debian-multimedia.org etch main
# VDR
deb http://e-tobi.net/vdr-experimental etch base addons vdr-multipatch
</syntaxhighlight>
apt-get update

'''ACHTUNG NICHT: apt-get upgrade ausführen'''

Nun verbindet man sich am besten per SSH zur XBOX.

3. XServer Installation:
apt-get install xserver-xorg xineliboutput-sxfe xterm xfonts-base xfonts-base
vim /etc/X11/xorg.conf
<source lang=bash>
Section "Files"
FontPath "/usr/share/fonts/X11/misc"
FontPath "/usr/X11R6/lib/X11/fonts/misc"
FontPath "/usr/share/fonts/X11/cyrillic"
FontPath "/usr/X11R6/lib/X11/fonts/cyrillic"
FontPath "/usr/share/fonts/X11/100dpi/:unscaled"
FontPath "/usr/X11R6/lib/X11/fonts/100dpi/:unscaled"
FontPath "/usr/share/fonts/X11/75dpi/:unscaled"
FontPath "/usr/X11R6/lib/X11/fonts/75dpi/:unscaled"
FontPath "/usr/share/fonts/X11/Type1"
FontPath "/usr/X11R6/lib/X11/fonts/Type1"
FontPath "/usr/share/fonts/X11/100dpi"
FontPath "/usr/X11R6/lib/X11/fonts/100dpi"
FontPath "/usr/share/fonts/X11/75dpi"
FontPath "/usr/X11R6/lib/X11/fonts/75dpi"
# path to defoma fonts
FontPath "/var/lib/defoma/x-ttcidfont-conf.d/dirs/TrueType"
EndSection

Section "Module"
Load "bitmap"
Load "dbe"
Load "ddc"
Load "dri"
Load "extmod"
Load "freetype"
Load "glx"
Load "int10"
Load "record"
Load "vbe"
EndSection

Section "InputDevice"
Identifier "Generic Keyboard"
Driver "kbd"
Option "CoreKeyboard"
Option "XkbRules" "xorg"
Option "XkbModel" "pc105"
Option "XkbLayout" "us"
EndSection

Section "InputDevice"
Identifier "Configured Mouse"
Driver "mouse"
Option "CorePointer"
Option "Device" "/dev/input/mice"
Option "Protocol" "ImPS/2"
Option "Emulate3Buttons" "true"
EndSection

Section "Device"
Identifier "nVidia Corporation GeForce3 MX for XBox"
# Driver "nv"
Driver "nvxbox"
Option "UseFBDev" "true"
Option "HWCursor" "false"
# Option "NoAccel" "true"
EndSection

Section "Device"
Identifier "Frame Buffer"
Driver "fbdev"
Option "UseFBDev" "true"
EndSection

Section "Monitor"
Identifier "Generic Monitor"
Option "DPMS"
HorizSync 28-32
VertRefresh 43-60
EndSection

Section "Screen"
Identifier "Default Screen"
Device "nVidia Corporation GeForce3 MX for XBox"
# Device "Frame Buffer"
Monitor "Generic Monitor"
DefaultDepth 24
SubSection "Display"
Depth 1
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 4
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 8
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 15
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 16
Modes "640x480"
EndSubSection
SubSection "Display"
Depth 24
Modes "640x480"
EndSubSection
EndSection

Section "DRI"
Mode 0666
EndSection
</source>
4. Init Skript anpassen:
vim /etc/init.d/xorg
<source lang=bash>
#! /bin/sh
### BEGIN INIT INFO
# Provides: X4VDR
# Required-Start: $local_fs
# Required-Stop: vdr
# Default-Start: 2
# Default-Stop:
# Short-Description: X-Server for VDR
# Description: Starts the X-Server for the VDR.
### END INIT INFO
#
# Author: Helmar Gerloni <helmar@gerloni.net>
# Version: 2006-09-13
#

PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DESC="X-Server for VDR"
NAME=X4VDR
PIDFILE=/var/run/$NAME\.pid
SCRIPTNAME=/etc/init.d/$NAME

#
# Function that starts X.
#
d_start() {
vdr-sxfe --tcp --reconnect --syslog --fullscreen --video=xv xvdr://vdr.server.ip:37890 > /dev/null 2&>1 &
start-stop-daemon --start --background --pidfile $PIDFILE --make-pidfile --exec /usr/bin/X -- :0 vt7 -br -nolisten tcp
if [ $? -gt 0 ]; then
echo "Error starting X-Server."
exit $?
fi
}

#
# Function that stops X.
#
d_stop() {
start-stop-daemon --stop --quiet --pidfile $PIDFILE
if [ $? -gt 0 ]; then
echo "Error stopping X-Server."
fi
}

case "$1" in
start)
echo -n "Starting $DESC: $NAME"
d_start
echo "."
;;
stop)
echo -n "Stopping $DESC: $NAME"
d_stop
echo "."
;;
*)
echo "Usage: $SCRIPTNAME {start|stop|restart|force-reload}" >&2
exit 1
;;
esac

exit 0
</source>
Das Script ausführbar machen mit:
chmod ug+x /etc/init.d/xorg
Das VDR Script startet nun den X-Server und zugleich vdr-sxfe. Zum starten und testen einfach:
/etc/init.d/xorg start
eingeben

Arduino Printer Control (Städtische Bühnen Münster)

2025-02-25T14:47:02Z

Admin: /* Einleitung */

=Einleitung=
Für die Aufführung der "Winterreise" von Elfriede Jelinek mussten 40 Drucker gleichzeitig angesteuert werden. Ich habe dafür eine Schaltung entwickelt, die es ermöglicht alle Drucker gleichzeitig anzusteuern. Im "Herzen" der Schaltung befindet sich ein Arduino Mega 2560. Dieser steuert an den IO-Ports die seriellen Printer Module vom Typ: BAS-120 an. Die Drucker werden über ein MIDI Keyboard angesprochen. So habe ich jeder Taste auf dem Keyboard einem Drucker zugeordnet. Über spezielle Tasten ist es möglich alle Drucker anzusprechen.

=MIDI Steuerung=
Siehe: [[Arduino MIDI Input]]

[[Datei:KeyBoard.png|Keyboard Belegung]]

[[Datei:Theater1.jpg|800px|Keyboard Belegung]]

Alle Fotos zum Projekt sind in meinem Picasa Album: [https://picasaweb.google.com/112556810584672853030/ArduinoTheaterProjektWinterreiseVonElfriedeJelinek?authuser=0&feat=directlink|Picasa]

Arduino Printer Control (Städtische Bühnen Münster)

2025-02-25T14:46:57Z

Admin:

=Einleitung=
Für die Aufführung der "Winterreise" von Elfriede Jelinek mussten 40 Drucker gleichzeitig angesteuert werden. Ich habe dafür eine Schaltung entwickelt, die es ermöglicht alle Drucker gleichzeitig anzusteuern. Im "Herzen" der Schaltung befindet sich ein Arduino Mega 2560. Dieser steuert an den IO-Ports die seriellen Printer Module vom Typ: BAS-120 an. Die Drucker werden über ein MIDI Keyboard angesprochen. So habe ich jeder Taste auf dem Keyboard einem Drucker zugeordnet. Über spezielle Tasten ist es möglich alle Drucker anzusprechen.

Test

=MIDI Steuerung=
Siehe: [[Arduino MIDI Input]]

[[Datei:KeyBoard.png|Keyboard Belegung]]

[[Datei:Theater1.jpg|800px|Keyboard Belegung]]

Alle Fotos zum Projekt sind in meinem Picasa Album: [https://picasaweb.google.com/112556810584672853030/ArduinoTheaterProjektWinterreiseVonElfriedeJelinek?authuser=0&feat=directlink|Picasa]

Atheros und Madwifi: Das WLAN im EEE-PC in den Promiscuous Mode schalten

2025-02-25T14:45:43Z

Admin:

'''Achtung: Das Mitschneiden von Internetverkehr in fremden Netzwerken ist strafbar. Diese Anleitung bezieht sich auf das eigene WLAN Netzwerk! Der Author übernimmt keine Haftung für irgendwelche Schäden!'''

In dieser Anleitung wird beschrieben wie sich eine Netzwerkkarte unter Debian/Ubuntu in den Promiscuous Mode schalten lässt. Als Grundlage dient der Madwifi Treiber. Eine Liste der unterstützten Hardware Komponenten ist hier verfügbar.
WLAN Verbindung im Netzwerkmanager deaktivieren:
rechte Maustaste auf das Netzwerksymbol, Haken bei Enable Wireless entfernen
ifconfig sollte nun nur noch die Ethernet Schnittstelle eth0 anzeigen
ifconfig
eth0 Protokoll:Ethernet Hardware Adresse 00:1E:8C:BC:
inet Adresse:192.168.1.102 Bcast:192.168.1.255 Maske:255.255.255.0
inet6 Adresse: fe80::21e:8cff:/64 GÃ¼ltigkeitsbereich:Verbindung
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:107 errors:0 dropped:0 overruns:0 frame:0
TX packets:126 errors:0 dropped:0 overruns:0 carrier:2
Kollisionen:0 SendewarteschlangenlÃ¤nge:1000
RX bytes:13587 (13.2 KB) TX bytes:0 (0.0 b)
Speicher:fbfc0000-fc000000
Physische WLAN Schnittstelle herunterfahren:
ifconfig wifi0 down
Virtuelle Schnittstelle im Monitor Modus (Promiscuous Mode) erstellen:
wlanconfig ath10 create wlandev wifi0 wlanmode monitor
Ein iwconfig sollte uns nun unsere neue virtuelle Schnittstelle anzeigen (Die Schnittstelle ath wird durchlaufend nummeriert, es kann also sein das diese bei euch anders heisst):
iwconfig
ath01 IEEE 802.11g ESSID:"" Nickname:""
Mode:Monitor Channel:0 Access Point: Not-Associated
Bit Rate:0 kb/s Tx-Power:17 dBm Sensitivity=1/1
Retry:off RTS thr:off Fragment thr:off
Encryption key:off
Power Management:off
Link Quality=0/70 Signal level=-94 dBm Noise level=-94 dBm
Rx invalid nwid:0 Rx invalid crypt:0 Rx invalid frag:0
Tx excessive retries:0 Invalid misc:0 Missed beacon:0
Physische Schnittstelle hochfahren:
ifconfig wifi0 up
Airmon Schnittstelle zuweisen:
airmon-ng start ath01
Airodump starten:
airodump-ng ath01
Nun sollte Airodump alle Informationen zu den gefundenen WLAN Netzwerken anzeigen. In diesem Fall werden auch versteckte Netzwerke angezeigt.

[[Datei:Airodump-wlans.png|Airodump WLAN]]

Atheros und Madwifi: Das WLAN im EEE-PC in den Promiscuous Mode schalten

2025-02-25T14:45:30Z

Admin:

Open Energy Monitor mit dem ESP32

2018-02-06T07:07:52Z

Admin: /* Emoncms */

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung und Spannung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend. Die Kosten für die einzelnen Komponenten sollten 30€ nicht übersteigen.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss
-Optional: 1000uF / 10V Kondensator zur Stabilisierung

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben. Ein 1000uF Kondensator zwischen 5V und GND ist empfehlenswert, da je nach 5V Netzteil die Messwerte stark schwanken.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

//WiFi
const char* ssid = "AccessPoint";
const char* password = "pass";

//WiFi
void WIFI_Connect()
{
digitalWrite(2,1);
WiFi.disconnect();
Serial.println("Booting Sketch...");
WiFi.mode(WIFI_AP_STA);
WiFi.begin(ssid, password);
// Wait for connection
for (int i = 0; i < 25; i++)
{
if ( WiFi.status() != WL_CONNECTED ) {
delay ( 250 );
digitalWrite(2,0);
Serial.print ( "." );
delay ( 250 );
digitalWrite(2,1);
}
}
digitalWrite(2,0);
}

void setup() {
Serial.begin(115200);
delay(500);
//WiFi Part
WIFI_Connect();
}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
WIFI_Connect();
} else {
//Do something if the WiFi is available
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand. Der Offset Wert sollte nicht am PC USB Port sondern an einem separaten 5V Netzteil kalibriert werden. Denn die meisten PC USB Anschlüsse liefern bei 200mA nur noch eine Spannung von 4,5V.

'''ICAL''' = Kalibrierung

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
timer = millis();
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

==Download Arduino Sketch==
'''Achtung: Ihr müsst das Programm noch an Eure WLAN und EMON Server Parameter anpassen.'''
[[Media:EmonCMS ESP32 v1.zip|Download Arduino Sketch: Emon ESP32]]

=Emoncms=
In Emoncms kann nun ein schönes Dashboard erstellt werden. Dazu gibt es bereits bei den Inputs die Funktionen "Power to kWh und Power to kWh/d".

[[Datei:ESP32 07.png|700px|Klicken um zu vergrößern]]

Die Werte können nun alle im Dashboard angezeigt werden.

[[Datei:ESP32 06.png|700px|Klicken um zu vergrößern]]

= Weblinks =

* https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino Official Page

Open Energy Monitor mit dem ESP32

2018-02-06T07:07:14Z

Admin:

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung und Spannung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend. Die Kosten für die einzelnen Komponenten sollten 30€ nicht übersteigen.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss
-Optional: 1000uF / 10V Kondensator zur Stabilisierung

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben. Ein 1000uF Kondensator zwischen 5V und GND ist empfehlenswert, da je nach 5V Netzteil die Messwerte stark schwanken.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

//WiFi
const char* ssid = "AccessPoint";
const char* password = "pass";

//WiFi
void WIFI_Connect()
{
digitalWrite(2,1);
WiFi.disconnect();
Serial.println("Booting Sketch...");
WiFi.mode(WIFI_AP_STA);
WiFi.begin(ssid, password);
// Wait for connection
for (int i = 0; i < 25; i++)
{
if ( WiFi.status() != WL_CONNECTED ) {
delay ( 250 );
digitalWrite(2,0);
Serial.print ( "." );
delay ( 250 );
digitalWrite(2,1);
}
}
digitalWrite(2,0);
}

void setup() {
Serial.begin(115200);
delay(500);
//WiFi Part
WIFI_Connect();
}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
WIFI_Connect();
} else {
//Do something if the WiFi is available
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand. Der Offset Wert sollte nicht am PC USB Port sondern an einem separaten 5V Netzteil kalibriert werden. Denn die meisten PC USB Anschlüsse liefern bei 200mA nur noch eine Spannung von 4,5V.

'''ICAL''' = Kalibrierung

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
timer = millis();
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

==Download Arduino Sketch==
'''Achtung: Ihr müsst das Programm noch an Eure WLAN und EMON Server Parameter anpassen.'''
[[Media:EmonCMS ESP32 v1.zip|Download Arduino Sketch: Emon ESP32]]

=Emoncms=
In Emoncms kann nun ein schönes Dashboard erstellt werden. Dazu gibt es bereits bei den Inputs die Funktionen "Power to kWh und Power to kWh/d".

[[Datei:ESP32 07.png|700px|Klicken um zu vergrößern]]

= Weblinks =

* https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino Official Page

Datei:ESP32 07.png

2018-02-06T07:05:42Z

Admin:

Datei:ESP32 06.png

2018-02-06T07:03:43Z

Admin:

Open Energy Monitor mit dem ESP32

2018-02-05T13:11:54Z

Admin: /* Kalibrierung */

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung und Spannung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend. Die Kosten für die einzelnen Komponenten sollten 30€ nicht übersteigen.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss
-Optional: 1000uF / 10V Kondensator zur Stabilisierung

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben. Ein 1000uF Kondensator zwischen 5V und GND ist empfehlenswert, da je nach 5V Netzteil die Messwerte stark schwanken.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

//WiFi
const char* ssid = "AccessPoint";
const char* password = "pass";

//WiFi
void WIFI_Connect()
{
digitalWrite(2,1);
WiFi.disconnect();
Serial.println("Booting Sketch...");
WiFi.mode(WIFI_AP_STA);
WiFi.begin(ssid, password);
// Wait for connection
for (int i = 0; i < 25; i++)
{
if ( WiFi.status() != WL_CONNECTED ) {
delay ( 250 );
digitalWrite(2,0);
Serial.print ( "." );
delay ( 250 );
digitalWrite(2,1);
}
}
digitalWrite(2,0);
}

void setup() {
Serial.begin(115200);
delay(500);
//WiFi Part
WIFI_Connect();
}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
WIFI_Connect();
} else {
//Do something if the WiFi is available
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand. Der Offset Wert sollte nicht am PC USB Port sondern an einem separaten 5V Netzteil kalibriert werden. Denn die meisten PC USB Anschlüsse liefern bei 200mA nur noch eine Spannung von 4,5V.

'''ICAL''' = Kalibrierung

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
timer = millis();
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

==Download Arduino Sketch==
'''Achtung: Ihr müsst das Programm noch an Eure WLAN und EMON Server Parameter anpassen.'''
[[Media:EmonCMS ESP32 v1.zip|Download Arduino Sketch: Emon ESP32]]

= Weblinks =

* https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino Official Page

Open Energy Monitor mit dem ESP32

2018-02-05T13:09:11Z

Admin:

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung und Spannung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend. Die Kosten für die einzelnen Komponenten sollten 30€ nicht übersteigen.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss
-Optional: 1000uF / 10V Kondensator zur Stabilisierung

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben. Ein 1000uF Kondensator zwischen 5V und GND ist empfehlenswert, da je nach 5V Netzteil die Messwerte stark schwanken.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

//WiFi
const char* ssid = "AccessPoint";
const char* password = "pass";

//WiFi
void WIFI_Connect()
{
digitalWrite(2,1);
WiFi.disconnect();
Serial.println("Booting Sketch...");
WiFi.mode(WIFI_AP_STA);
WiFi.begin(ssid, password);
// Wait for connection
for (int i = 0; i < 25; i++)
{
if ( WiFi.status() != WL_CONNECTED ) {
delay ( 250 );
digitalWrite(2,0);
Serial.print ( "." );
delay ( 250 );
digitalWrite(2,1);
}
}
digitalWrite(2,0);
}

void setup() {
Serial.begin(115200);
delay(500);
//WiFi Part
WIFI_Connect();
}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
WIFI_Connect();
} else {
//Do something if the WiFi is available
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand. Der Offset Wert sollte nicht am PC USB Port sondern an einem separaten 5V Netzteil kalibriert werden. Denn die meisten PC USB Anschlüsse liefern bei 200mA nur noch eine Spannung von 4,5V.

'''ICAL''' = Kalibrierung

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
timer = millis();
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

==Download Arduino Sketch==
'''Achtung: Ihr müsst das Programm noch an Eure WLAN und EMON Server Parameter anpassen.'''
[[Media:EmonCMS ESP32 v1.zip|Download Arduino Sketch: Emon ESP32]]

= Weblinks =

* https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino Official Page

Open Energy Monitor mit dem ESP32

2018-02-05T13:06:46Z

Admin: /* Download Arduino Sketch */

Open Energy Monitor mit dem ESP32

2018-02-05T13:06:34Z

Admin: /* Download Arduino Sketch */

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung und Spannung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend. Die Kosten für die einzelnen Komponenten sollten 30€ nicht übersteigen.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss
-Optional: 1000uF / 10V Kondensator zur Stabilisierung

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben. Ein 1000uF Kondensator zwischen 5V und GND ist empfehlenswert, da je nach 5V Netzteil die Messwerte stark schwanken.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

//WiFi
const char* ssid = "AccessPoint";
const char* password = "pass";

//WiFi
void WIFI_Connect()
{
digitalWrite(2,1);
WiFi.disconnect();
Serial.println("Booting Sketch...");
WiFi.mode(WIFI_AP_STA);
WiFi.begin(ssid, password);
// Wait for connection
for (int i = 0; i < 25; i++)
{
if ( WiFi.status() != WL_CONNECTED ) {
delay ( 250 );
digitalWrite(2,0);
Serial.print ( "." );
delay ( 250 );
digitalWrite(2,1);
}
}
digitalWrite(2,0);
}

void setup() {
Serial.begin(115200);
delay(500);
//WiFi Part
WIFI_Connect();
}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
WIFI_Connect();
} else {
//Do something if the WiFi is available
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand. Der Offset Wert sollte nicht am PC USB Port sondern an einem separaten 5V Netzteil kalibriert werden. Denn die meisten PC USB Anschlüsse liefern bei 200mA nur noch eine Spannung von 4,5V.

'''ICAL''' = Kalibrierung

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
timer = millis();
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

==Download Arduino Sketch==
'''Achtung: Ihr müsst das Programm noch an Eure WLAN und EMON Server Werte anpassen.'''
[[Media:EmonCMS ESP32 v1.zip|Download Arduino Sketch: Emon ESP32]]

Open Energy Monitor mit dem ESP32

2018-02-05T13:06:18Z

Admin:

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung und Spannung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend. Die Kosten für die einzelnen Komponenten sollten 30€ nicht übersteigen.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss
-Optional: 1000uF / 10V Kondensator zur Stabilisierung

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben. Ein 1000uF Kondensator zwischen 5V und GND ist empfehlenswert, da je nach 5V Netzteil die Messwerte stark schwanken.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

//WiFi
const char* ssid = "AccessPoint";
const char* password = "pass";

//WiFi
void WIFI_Connect()
{
digitalWrite(2,1);
WiFi.disconnect();
Serial.println("Booting Sketch...");
WiFi.mode(WIFI_AP_STA);
WiFi.begin(ssid, password);
// Wait for connection
for (int i = 0; i < 25; i++)
{
if ( WiFi.status() != WL_CONNECTED ) {
delay ( 250 );
digitalWrite(2,0);
Serial.print ( "." );
delay ( 250 );
digitalWrite(2,1);
}
}
digitalWrite(2,0);
}

void setup() {
Serial.begin(115200);
delay(500);
//WiFi Part
WIFI_Connect();
}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
WIFI_Connect();
} else {
//Do something if the WiFi is available
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand. Der Offset Wert sollte nicht am PC USB Port sondern an einem separaten 5V Netzteil kalibriert werden. Denn die meisten PC USB Anschlüsse liefern bei 200mA nur noch eine Spannung von 4,5V.

'''ICAL''' = Kalibrierung

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
timer = millis();
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

==Download Arduino Sketch==
Ihr müsst das Programm noch an Eure WLAN und EMON Server Werte anpassen.
[[Media:EmonCMS ESP32 v1.zip|Download Arduino Sketch: Emon ESP32]]

Open Energy Monitor mit dem ESP32

2018-02-05T13:04:32Z

Admin:

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung und Spannung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend. Die Kosten für die einzelnen Komponenten sollten 30€ nicht übersteigen.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss
-Optional: 1000uF / 10V Kondensator zur Stabilisierung

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben. Ein 1000uF Kondensator zwischen 5V und GND ist empfehlenswert, da je nach 5V Netzteil die Messwerte stark schwanken.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

//WiFi
const char* ssid = "AccessPoint";
const char* password = "pass";

//WiFi
void WIFI_Connect()
{
digitalWrite(2,1);
WiFi.disconnect();
Serial.println("Booting Sketch...");
WiFi.mode(WIFI_AP_STA);
WiFi.begin(ssid, password);
// Wait for connection
for (int i = 0; i < 25; i++)
{
if ( WiFi.status() != WL_CONNECTED ) {
delay ( 250 );
digitalWrite(2,0);
Serial.print ( "." );
delay ( 250 );
digitalWrite(2,1);
}
}
digitalWrite(2,0);
}

void setup() {
Serial.begin(115200);
delay(500);
//WiFi Part
WIFI_Connect();
}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
WIFI_Connect();
} else {
//Do something if the WiFi is available
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Download Arduino Sketch==
[[Media:EmonCMS ESP32 v1.zip|Download Arduino Sketch: Emon ESP32]]

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand. Der Offset Wert sollte nicht am PC USB Port sondern an einem separaten 5V Netzteil kalibriert werden. Denn die meisten PC USB Anschlüsse liefern bei 200mA nur noch eine Spannung von 4,5V.

'''ICAL''' = Kalibrierung

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
timer = millis();
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

Datei:EmonCMS ESP32 v1.zip

2018-02-05T13:03:05Z

Admin:

Open Energy Monitor mit dem ESP32

2018-02-05T12:43:53Z

Admin: /* Spezielle Hinweise für den ESP32 */

Open Energy Monitor mit dem ESP32

2018-02-05T12:42:46Z

Admin: /* Spezielle Hinweise für den ESP32 */

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung und Spannung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend. Die Kosten für die einzelnen Komponenten sollten 30€ nicht übersteigen.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss
-Optional: 1000uF / 10V Kondensator zur Stabilisierung

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben. Ein 1000uF Kondensator zwischen 5V und GND ist empfehlenswert, da je nach 5V Netzteil die Messwerte stark schwanken.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
// put your setup code here, to run once:

}

//WiFi Part
const char* ssid = "AccessPoint";
const char* password = "pass";

//WiFi
void WIFI_Connect()
{
digitalWrite(2,1);
WiFi.disconnect();
Serial.println("Booting Sketch...");
WiFi.mode(WIFI_AP_STA);
WiFi.begin(ssid, password);
// Wait for connection
for (int i = 0; i < 25; i++)
{
if ( WiFi.status() != WL_CONNECTED ) {
delay ( 250 );
digitalWrite(2,0);
Serial.print ( "." );
delay ( 250 );
digitalWrite(2,1);
}
}
digitalWrite(2,0);
}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
WIFI_Connect();
} else {
//Do something if the WiFi is available
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand. Der Offset Wert sollte nicht am PC USB Port sondern an einem separaten 5V Netzteil kalibriert werden. Denn die meisten PC USB Anschlüsse liefern bei 200mA nur noch eine Spannung von 4,5V.

'''ICAL''' = Kalibrierung

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
timer = millis();
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

Open Energy Monitor mit dem ESP32

2018-02-05T12:41:23Z

Admin: /* Spezielle Hinweise für den ESP32 */

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung und Spannung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend. Die Kosten für die einzelnen Komponenten sollten 30€ nicht übersteigen.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss
-Optional: 1000uF / 10V Kondensator zur Stabilisierung

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben. Ein 1000uF Kondensator zwischen 5V und GND ist empfehlenswert, da je nach 5V Netzteil die Messwerte stark schwanken.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
// put your setup code here, to run once:

}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
//WIFI_Connect();
} else {
//Do something if the WiFi is available
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand. Der Offset Wert sollte nicht am PC USB Port sondern an einem separaten 5V Netzteil kalibriert werden. Denn die meisten PC USB Anschlüsse liefern bei 200mA nur noch eine Spannung von 4,5V.

'''ICAL''' = Kalibrierung

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
timer = millis();
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

Open Energy Monitor mit dem ESP32

2018-02-05T12:39:32Z

Admin:

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung und Spannung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend. Die Kosten für die einzelnen Komponenten sollten 30€ nicht übersteigen.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss
-Optional: 1000uF / 10V Kondensator zur Stabilisierung

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben. Ein 1000uF Kondensator zwischen 5V und GND ist empfehlenswert, da je nach 5V Netzteil die Messwerte stark schwanken.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
// put your setup code here, to run once:

}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
//WIFI_Connect();
} else {
//Do something
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand. Der Offset Wert sollte nicht am PC USB Port sondern an einem separaten 5V Netzteil kalibriert werden. Denn die meisten PC USB Anschlüsse liefern bei 200mA nur noch eine Spannung von 4,5V.

'''ICAL''' = Kalibrierung

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
timer = millis();
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

Open Energy Monitor mit dem ESP32

2018-02-05T12:32:13Z

Admin: /* Einleitung */

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung und Spannung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss
-Optional: 1000uF / 10V Kondensator zur Stabilisierung

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben. Ein 1000uF Kondensator zwischen 5V und GND ist empfehlenswert, da je nach 5V Netzteil die Messwerte stark schwanken.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
// put your setup code here, to run once:

}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
//WIFI_Connect();
} else {
//Do something
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand. Der Offset Wert sollte nicht am PC USB Port sondern an einem separaten 5V Netzteil kalibriert werden. Denn die meisten PC USB Anschlüsse liefern bei 200mA nur noch eine Spannung von 4,5V.

'''ICAL''' = Kalibrierung

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
timer = millis();
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

Open Energy Monitor mit dem ESP32

2018-02-05T12:30:21Z

Admin: /* Kalibrierung */

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss
-Optional: 1000uF / 10V Kondensator zur Stabilisierung

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben. Ein 1000uF Kondensator zwischen 5V und GND ist empfehlenswert, da je nach 5V Netzteil die Messwerte stark schwanken.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
// put your setup code here, to run once:

}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
//WIFI_Connect();
} else {
//Do something
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand. Der Offset Wert sollte nicht am PC USB Port sondern an einem separaten 5V Netzteil kalibriert werden. Denn die meisten PC USB Anschlüsse liefern bei 200mA nur noch eine Spannung von 4,5V.

'''ICAL''' = Kalibrierung

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
timer = millis();
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

Open Energy Monitor mit dem ESP32

2018-02-05T12:29:46Z

Admin: /* Kalibrierung */

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss
-Optional: 1000uF / 10V Kondensator zur Stabilisierung

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben. Ein 1000uF Kondensator zwischen 5V und GND ist empfehlenswert, da je nach 5V Netzteil die Messwerte stark schwanken.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
// put your setup code here, to run once:

}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
//WIFI_Connect();
} else {
//Do something
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand. Der Offset Wert sollte nicht am PC USB Port sondern an einem separaten 5V Netzteil kalibriert werden. Denn die meisten PC USB Anschlüsse liefern bei 200mA nur noch eine Spannung von 4,5V.

'''ICAL''' = Kalibrierung
'''inPinI1''' = ADC Pin

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
timer = millis();
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

Open Energy Monitor mit dem ESP32

2018-02-05T12:26:49Z

Admin:

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss
-Optional: 1000uF / 10V Kondensator zur Stabilisierung

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben. Ein 1000uF Kondensator zwischen 5V und GND ist empfehlenswert, da je nach 5V Netzteil die Messwerte stark schwanken.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
// put your setup code here, to run once:

}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
//WIFI_Connect();
} else {
//Do something
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand.

'''ICAL''' = Kalibrierung
'''inPinI1''' = ADC Pin

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
timer = millis();
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

Open Energy Monitor mit dem ESP32

2018-02-05T12:26:14Z

Admin: /* Aufbau */

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben. Ein 1000uF Kondensator zwischen 5V und GND ist empfehlenswert, da je nach 5V Netzteil die Messwerte stark schwanken.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
// put your setup code here, to run once:

}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
//WIFI_Connect();
} else {
//Do something
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand.

'''ICAL''' = Kalibrierung
'''inPinI1''' = ADC Pin

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
timer = millis();
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

Open Energy Monitor mit dem ESP32

2018-02-04T19:03:36Z

Admin: /* Kalibrierung */

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
// put your setup code here, to run once:

}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
//WIFI_Connect();
} else {
//Do something
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand.

'''ICAL''' = Kalibrierung
'''inPinI1''' = ADC Pin

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
timer = millis();
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

Open Energy Monitor mit dem ESP32

2018-02-04T18:59:17Z

Admin: /* Aufbau */

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 05.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
// put your setup code here, to run once:

}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
//WIFI_Connect();
} else {
//Do something
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand.

'''ICAL''' = Kalibrierung
'''inPinI1''' = ADC Pin

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

Datei:ESP32 05.png

2018-02-04T18:58:42Z

Admin:

Open Energy Monitor mit dem ESP32

2018-02-04T18:50:45Z

Admin: /* Spezielle Hinweise für den ESP32 */

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut. Die Funktion WifiEvent startet den ESP32 neu wenn keine Verbindung mehr zum WLAN besteht. Leider funktioniert jeder andere Weg im Moment nicht zuverlässig.

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
// put your setup code here, to run once:

}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
//WIFI_Connect();
} else {
//Do something
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand.

'''ICAL''' = Kalibrierung
'''inPinI1''' = ADC Pin

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

Open Energy Monitor

2018-02-04T18:47:39Z

Admin:

Open Energy Monitor mit dem ESP32

2018-02-04T18:43:58Z

Admin: /* Kalibrierung */

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut:

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
// put your setup code here, to run once:

}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
//WIFI_Connect();
} else {
//Do something
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand.

'''ICAL''' = Kalibrierung
'''inPinI1''' = ADC Pin

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - '''0.06''';//Offset

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

Open Energy Monitor mit dem ESP32

2018-02-04T18:42:33Z

Admin: /* Kalibrierung */

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut:

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
// put your setup code here, to run once:

}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
//WIFI_Connect();
} else {
//Do something
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62 Ohm Burden Widerstand.

'''ICAL''' = Kalibrierung
'''inPinI1''' = ADC Pin

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

Open Energy Monitor mit dem ESP32

2018-02-04T18:41:24Z

Admin: /* Software */

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

==Spezielle Hinweise für den ESP32==
Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut:

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
// put your setup code here, to run once:

}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
//WIFI_Connect();
} else {
//Do something
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62Ohm Burden Widerstand.

'''ICAL''' = Kalibrierung
'''inPinI1''' = ADC Pin

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>

Open Energy Monitor mit dem ESP32

2018-02-04T18:39:29Z

Admin: /* Kalibrierung */

=Einleitung=

In dieser Anleitung wird beschrieben wie mit Hilfe einer ESP32 Platine ein Strom Sensor für 3 Phasen Wechselstrom aufgebaut werden kann. Der Spannungsteiler aus den 10kOhm Widerständen erzeugt 1,6V für die SCT-013-030 Strom Sensoren. Die Stromsensoren werden mit den ADC Pin's des ESP32 verbunden. Natürlich sind die Messungen nicht sonderlich genau, da die Phasenverschiebung nicht berücksichtigt wird. Auch das wäre durch zusätzliche Transformatoren möglich die dann auf die ADC Pin's geführt werden. Da ich damit nur meinen ungefähren Stromverbrauch zuhause messen möchte ist die Schaltung völlig ausreichend.

'''Folgende Bauteile werden benötigt:'''
-Board: DOIT ESP32 DEVKIT V1 (ca. 10€)
-Strom Sensor SCT-013-30 (30A) oder SCT-013-100 (100A) siehe: http://openenergymonitor.org/emon/node/156
-6x 10kOhm Widerstände 1/4W
-3x Elko 10 uF
-Universalplatine
-evtl. USB Netzteil oder anderes Netzteil für die Spannungsversorgung
-Pfosten Stecker Rastermaß: 2.54mm
-3 x 3,5 mm Audio Anschluss

'''Pinbelegung des DOIT ESP32 DEVKIT V1 Board:'''

https://github.com/playelek/pinout-doit-32devkitv1

=Grundlagen=

Auf der Seite von Open Energy Monitor finden sich genügend Informationen über die Grundlagen der Leistungsberechnung. Das Prinzip lässt sich 1:1 vom Aufbau eines Arduinos übernehmen. Der ESP32 verkraftet jedoch maximal 3,3V am Analog Eingang.

https://learn.openenergymonitor.org/electricity-monitoring/ct-sensors/interface-with-arduino

=Aufbau=

Auf die Lochrasterplatine müssen nur wenige Bauteile. Die Teile lassen sich relativ einfach einlöten. Für den Aufbau werden nur wenige PIN's des ESP32 benötigt. Bei meinem Aufbau gibt es am obersten Sensor Anschluss noch einen zusätzlichen Burden Widerstand von 200 Ohm. Das liegt daran das der SCT-013-030 Sensor schon einige Jahre alt ist. Bei den neuen Sensoren sind keine Burden Widerstände nötig, da diese schon einen 62 Ohm Burden eingebaut haben.

[[Datei:ESP32 03.png|700px|Klicken um zu vergrößern]]

[[Datei:ESP32 01.png|700px|Klicken um zu vergrößern]]

=Software=

Ich verwende zum programmieren immer die Arduino Gui. Es sind zuerst einige Anpassungen nötig damit das DOIT ESP32 Board von der Arduino Software erkannt wird. Hierzu muss diese Anleitung umgesetzt werden:

https://github.com/espressif/arduino-esp32

Nach dem Neustart der Arduino Software kann dann das passende ESP32 Board ausgewählt werden. In meinem Beispiel ist es ein DOIT V1 Board.

[[Datei:ESP32 04.png|700px|Klicken um zu vergrößern]]

Bei der Programmierung des ESP32 gibt es ein paar Dinge zu beachten. Auf den Boards ist meist ein passender Spannungsregler für 3,3V und ein passender FTDI Chip aufgelötet. Somit entfällt eine weitere Schaltung zur Spannungsversorgung. Zudem wird das Board vom FTDI Chip durch die Arduino Software automatisch in den "Upload Modus" versetzt. Man muss also nicht wie beim ESP8266 bestimmte Taster drücken (Flash und Reset) um das Board in den "Upload Modus" zu bringen.

Ich habe öfters die WifiManager Library für das WLAN verwendet. Auf Dauer hatte ich damit jedoch immer wieder Probleme, so das ich meine WLAN Daten mit Absicht "fest" in das Programm einbaue. Zudem ergibt sich beim WLAN noch ein Problem wenn auf einmal die WLAN Verbindung unterbrochen wird, z.B. wenn der Router neu gestartet wird. Danach verbindet sich der ESP32 nämlich nicht mehr automatisch mit dem WLAN. Um das zu verhindern habe ich folgende Funktion in den Code eingebaut:

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
// put your setup code here, to run once:

}

void loop() {
//Wifi WatchDog
WiFi.onEvent(WiFiEvent);
//Check if WiFi is here
//Automatically reconnect the ESP32 if the WiFi Router is not there...
if (WiFi.status() != WL_CONNECTED)
{
WiFi.onEvent(WiFiEvent);
//WIFI_Connect();
} else {
//Do something
}
}

//Wifi Watchdog
void WiFiEvent(WiFiEvent_t event) {
Serial.printf("[WiFi-event] event: %d - ", event);
switch(event) {
case SYSTEM_EVENT_STA_GOT_IP:
Serial.println("WiFi connected");
Serial.print("IP address: "); Serial.println(WiFi.localIP());
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
Serial.println("WiFi lost connection");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
case SYSTEM_EVENT_STA_START:
Serial.println("ESP32 station start");
break;
case SYSTEM_EVENT_STA_CONNECTED:
Serial.println("ESP32 station connected to AP");
break;
case SYSTEM_EVENT_STA_LOST_IP:
Serial.println("ESP32 Lost IP");
WiFi.begin(); // <<<<<<<<<<< added <<<<<<<<<<<<<<<
ESP.restart();
break;
}
}
</source>

==Kalibrierung==
Als nächstes müssen die Stromsensoren kalibriert werden. Dazu sollten folgende Variablen angepasst werden. Die Kalibrierung habe ich mit einer 100W Lampe und einem Wasserkocher 1800W durchgeführt. Eine genaue Stromzange oder eine Wattmeter sind sehr nützliche Hilfsmittel. In meinem Fall kann der SCT-013-030 als kleinste Einheit 100mA Strom erkennen. Die Sensoren haben 1800 Wicklungen und einen 62Ohm Burden Widerstand.

'''ICAL''' = Kalibrierung
'''inPinI1''' = ADC Pin

filteredI = '''0.9989''' * (lastFilteredI+sampleI-lastSampleI); //Kalibrierung

<source lang=c++>
#include <Arduino.h>
#include <WiFi.h>

void setup() {
Serial.begin(115200);
delay(500);
}

//Setup variables
int numberOfSamples = 4000;
double ICAL = 1.08;

//Set Voltage and current input pins
int inPinI1 = 34;

// CT: Voltage depends on current, burden resistor, and turns
#define CT_BURDEN_RESISTOR 62
#define CT_TURNS 1800
#define VOLTAGE 225

// Initial gueses for ratios, modified by VCAL/ICAL tweaks
double I_RATIO = (long double)CT_TURNS / CT_BURDEN_RESISTOR * 3.3 / 4096 * ICAL;

//Filter variables 1
double lastFilteredI, filteredI;
double sqI,sumI;
//Sample variables
int lastSampleI,sampleI;
double Irms1;
unsigned long timer;

void loop() {
//**************************************************************************
//Phase1
for (int n=0; n<numberOfSamples; n++)
{

//Used for offset removal
lastSampleI=sampleI;

//Read in voltage and current samples.
sampleI = analogRead(inPinI1);

//Used for offset removal
lastFilteredI = filteredI;

//Digital high pass filters to remove 1.6V DC offset.
filteredI = 0.9989 * (lastFilteredI+sampleI-lastSampleI);

//Root-mean-square method current
//1) square current values
sqI = filteredI * filteredI;
//2) sum
sumI += sqI;
delay(0.0002);
}

//Calculation of the root of the mean of the voltage and current squared (rms)
//Calibration coeficients applied.
Irms1 = (I_RATIO * sqrt(sumI / numberOfSamples)) - 0.06;
if (Irms1 < 0){ Irms1 = 0; }; //Set negative Current to zero
sumI = 0;

Serial.println("Irms1:"+String(Irms1));
}
</source>