<> Beim Eddy-2-Power Windrad verfolgen wir einen Niedrigtechnologie Ansatz. D.h. wir bevorzugen einfache robuste Mechanik und Technologien mit Materialien, die nicht nur in Industrieländern beschaffbar sind und bestenfalls recycelt wurden. Damit wir vergleichbare Messwerte erfassen können, verlassen wir den low tech Weg beim Messen. Auch hier halten wir es so einfach und praktikabel wie möglich. Alle wichtigen Schritte, Knackpunkte und Fallstricke die uns begegnen werden dokumentiert. Allerdings ist hier etwas mehr Vorwissen und andere Hardware notwendig. = Messbereiche = == Windgeschwindigkeit == * [[Eddy-2-Power/Windmessgerät]] * Später erfassen wir vlt. auch die Windrichtung, die ist bei Vertikalachsenanlagen aber nachrangig. == Strom == * vom Generator zum Laderegler * zu den Akkus * von den Akkus * zum Dump == Spannung == * am Gleichrichter * an den Batterien * am Dump * am LVD == Geschwindigkeit des Windrads == * Umdrehungen des Rotors pro Minute == Temperaturen == * Luft * Batterien * Dump == Sonnenlicht == * zum Vergleich wie sich Solarzellen ergänzen würden ---- = Hardwaresetup für Messungen und Kommunikation = == grundlegender Aufbau == * WLAN Router - die Verbindung zur Außenwelt; zum "Ablesen" der Messwerte * Raspberry Pi - Messwerte speichern, Berechnungen, Darstellung * per Netzwerkkabel mit WLAN Router verbunden * Anemometer * Datenbank * grafische Darstellung mit Munin * Arduino - Messwerte der Sensoren erfassen * Der Arduino wird quasi als billiger Analog/Digital Wandler für den Pi genutzt. Der AD Wandler übersetzt die analogen Werte zwischen 0 und 5 Volt in digitale zwischen 0 und 1023 (10Bit). * Stromversorgung, Kommunikation und Firmwareflash via USB am Pi * Sensoren - siehe oben * Ausgabe erfolgt sekündlich als csv Zeile (Komma separierte Werte) * weitere Interaktion ist bislang nicht geplant * Stromversorgung - Alle Messgeräte werden unabhängig vom Windrad mit Strom versorgt. So können auch bei Umbau, Wartung, Fehlern etc. weiterhin Daten erfasst werden. * Software - Die Programme zur Erfassung und Auswertung werden weitestgehend in Python/Micropython geschrieben, für den Mikrocontroller im Arduino C++ Dialekt. Die Datenbank wird zunächst SQLite. Munin dient zur Darstellung der Messwerte. Eine weitere softwaregestützte Auswertung ist vorerst nicht geplant. Die erfassten Daten werden wir zu Forschungszwecken veröffentlichen. == Aufbau Messschaltung == Entweder ein Arduino/Genuino (z.B. uno) oder etwas abgespeckter ein Atmel328p, daran die Sensoren... === Atmega328p auf Breadboard === Im alltäglichen Betrieb ist die Arduino Umgebung nicht notwendig, der geflashte Atmega Microcontroller reicht. * + preislich guenstiger * + geringerer Stromverbrauch * - braucht extra Hardware Umgebung zum flashen und für die serielle Konsole * benötigte Bauteile: * atmega328 (mit bootloader) * ic halter für atmega328 * 16mhz quarz * 2x18 bis 22 picofarad kondensatoren * 10k widerstand * led * mini breadboard, lochrasterplatine * rs323 usb ttl level wandler * 5v netzteil oder von akku mit spannungs- oder schaltregler (z.B. LM7805) auf 5V * Spannungsteiler für Sensoren am Arduino * http://www.elektronik-kompendium.de/sites/slt/1506141.htm * Atmega Breadboard Beschaltung: * https://www.arduino.cc/en/Main/Standalone * https://www.arduino.cc/en/Tutorial/ArduinoToBreadboard * Atmega flashen, so geht's: * http://shelvin.de/atmega328p-pu-bootloader-laden-vom-arduino-uno-als-isp/ * https://frag-duino.de/index.php/maker-faq/35-programmieren-eines-atmel-atmega-328p-mit-dem-arduino-uno-bootloader * http://www.arduino-tutorial.de/2010/08/ftdi-ft232rl/ - atmega168 mittels arduino flashen == Strom messen mit dem ACS714 == Der Arduino hat einen 10Bit AD Wandler d.h. er unterscheidet analoge Spannungen zwischen 0 und 5 Volt in 1024 Schritten (von 0 bis 1023). In diesem Bereich werden die -30A bis +30A die der ACS714 messen kann abgebildet. Das sind 0,0586A pro Schritt (60/2^10 = 0,05859375). Kleinere Differenzen im Stromfluss sind unabhängig von allen anderen Einflüssen auf die Messung nicht darstellbar. Laut Datenblatt hat der Sensor eine Genauigkeit von 66mV/A bei +-30A. Wer mit kleineren Strömen zu tun hat kann mit der +-5A Auslegung des Sensores mit einer Genauigkeit von 182mV/A messen. * http://forum.arduino.cc/index.php?topic=108953.0 -- "Looks like my assumption that 0-1023 matches -30 to 30A is wrong. With a sensitivity of 66 mV per A the optimized -30 to 30 range would be (Vcc/2)-1.98V to (Vcc/2)+1.98V (0.52V to 4.48V). That's something like .073982 A per step. 73,982 microamps per step. (long microAmps = (analogRead(pin) - 512) * 73982L;)" Damit Messfehler klein bleiben sollten stromführende Leitungen mit ein wenig Abstand am Hall Sensor vorbei geführt werden. Die Analog Pins des Arduino bedanken für ein delay(1) mit genaueren Messwerten. Und es bietet sich an, über mehrere Messungen zu mitteln. {{{ a = 0; for(int i = 0; i < 100; i++) { delay(1); a = a + analogRead(A0); } ampere = a / 100; }}} * http://playground.arduino.cc/Main/CurrentSensing * http://forum.arduino.cc/index.php?topic=108953.0 * https://www.hacktronics.com/Tutorials/arduino-current-sensor.html * http://www.sysrun.de/2012/11/stromsensoren-fur-die-motoren/#more-29 * https://blog.thesen.eu/genaue-strommessung-mit-dem-arduino-und-dem-acs712-hall-sensor-mittels-oversampling/ === Genauigkeitsbesprechung === * https://www.mikrocontroller.net/topic/304395 -- "Er hat eine Auflösung von 10 Bit mit bis zu 1 Bit Linearitätsfehler und absolut einen Fehler von bis zu +/- 2 LSB. Bei Verwendung von dem Spannungsteiler und einer 5V Referenz entspricht ein LSB 5V/1024*1000/110=0,044V. Da der Wandler laut Spezifikation bis zu 3 LSB daneben liegen kann, hat man also keinen Recht, sich an Fehler von bis zu 3*0,044V = 0,133V zu stören. Die Widerstandstoleranzen im Spannungsteiler sind dabei noch nicht berücksichtigt." * "Der Regelbereich liegt zwischen 0,5 und 4,5V. Zumindest ist das bei meinem -30 bis 30A Sensor so. Ich habe folgende Lösung gewählt, die mit meinem Messgerät auf ein zehntel Ampere übereinstimmt. 0,5V entspricht 102 und 4,5V 921, das ganze wird dann umgerechnet in Zehntelampere und dann wieder durch 10 geteilt." {{{ int mess2 = analogRead(1); float Strom = map(mess2, 102, 921, -300, 300)/10.00; }}} == Spannungen mit dem Arduino messen == Um Spannungen bis 15V (an den Akkus) am Arduino messen zu können muss der Bereich von 0-15V auf 0-5V runtergebracht werden. Das erledigt eine Spannungsteilerschaltung. Aus den 0 bis 5V Werten macht der A/D Wandler im Arduino Werte zwischen 0 und 1023. Wir können mit diesem Aufbau also nur Spannungsdifferenzen von mehr als 0,0117V (12V/1042) abbilden. Das reicht für unsere Zwecke und wird nicht weiter optimiert. Am Generator werden Spannungen bis 60V erreicht. Selbst hier sind wir über den Spannungsteiler und 10Bit A/D Wandler mit 0,059V Spannungdifferenz noch hinreichend gut unterwegs. Der Spannungsteiler wird über eine einfache Widerstandsschaltung realisiert. {{attachment:Spannungsteiler_Steckplatine.png}} {{{ R_ges = R_1 + R_2 V_2 = V_ges * R_2 / (R_1 + R_2) }}} Die Batteriespannung (von <15V ausgehend) fällt über R_1 und R_2 ab. Der Arduino misst die Spannung, die über R_2 abfällt also zwischen GND und R_1. * 0-15V --> 0-5V mit R_1 = 10kOhm und R_2 = 4,7kOhm * 0-17V --> 0-5V mit R_1 = 10kOhm und R_2 = 4kOhm * kleine Reserve bei möglichen Überspannungen * 17V durch 14.kOhm bedeutet 1,21mA Stromfluss * 0-60V --> 0-5V mit R_1 = 11kOhm und R_2 = 1kOhm * 60V durch 12kOhm bedeutet 5mA Stromfluss Parallel zu R_2 wird noch eine Zener-Diode (Z1) mit 5,1V in Sperrrichtung zu R_1 geschaltet. Damit wird verhindert, dass der Analogeingang des Arduino mehr als 5,1V sieht. Bei höheren Spannungen wird die Z-Diode entgegen der Sperrichtung leitend und der Arduino bleibt verschont. Wir verwenden hier 1N4733A Z-Dioden (5,1V 49mA). * http://www.elektronik-kompendium.de/sites/slt/0201111.htm - Spannungsteiler / Spannungsteilerschaltung * http://www.elektronik-kompendium.de/sites/slt/1012151.htm - Spannungsstabilisierung mit Z-Diode == Spannungen mit A/D Wandler am Pi messen == === Raspi GPIO === * Pin Belegung: http://www.elektronik-kompendium.de/sites/raspberry-pi/1907101.htm * http://www.elektronik-kompendium.de/sites/raspberry-pi/2002191.htm * Pi Überblick I²C, SPI und UART: https://raspberry.tips/faq/raspberry-pi-spi-und-i2c-aktivieren/ Grundsätzlich, der Raspberry Pi wird mit 5 Volt gespeist. Allerdings arbeitet der System on Chip auf Basis von 3,3 Volt, was bedeutet, dass auch die GPIOs mit 3,3 Volt arbeiten. Sowohl eingangs- als auch ausgangsseitig. Desweiteren verträgt ein GPIO nur ein paar Milliampere (mA) Strom. Je nach Quelle ist von einem anderen Wert die Rede. Man spricht von maximal 16 mA. Wobei Ein- und Ausgänge bereits mit 0,5 mA sicher schalten. Wenn man es sich bei der Dimensionierung einfach haben will, dann kann man mit 1 oder 2 mA rechnen. Je nach Beschaltung sollte man aber nicht mehr als 8 mA aus einem GPIO ziehen. Die GPIO-Pins mit festdefinierter Spannung eignen sich weniger gut zur Stromversorgung. Vor allem nicht die +3,3V-Pins und nur begrenzt die +5V-Pins. Diese spannungsführenden Pins eignen sich nur, um einen fest definierten Pegel bereitzustellen. Externe Schaltungsteile, insbesondere Relais und Motoren, sollten über ein eigenes Netzteil versorgt werden. === MCP3208 === * A/D Wandler mit SPI Interface MCP Bsp.: * MCP3008 - 10 Bit Auflösung 8 Kanäle * MCP3204 - 12 Bit Auflösung 4 Kanäle * MCP3208 - 12 Bit Auflösung 8 Kanäle * kann mit 3,3 (Pi), 5V (Arduino) bis 7V betrieben werden {{attachment:mcp3008_3208_pins.png|MCP3208 Pinbelegung|height=200}} * Pinbelegung: * VDD ist die Versorgungsspannung des Schaltkreises. Sie liegt zwischen 2,7 und 5,5V, alles was über 7V geht zerstört den Schaltkreis. * VREF ist eine Referenzspannung die benötigt wird, um die Spannung an den analogen Anschlüssen zu vergleichen und so einen digitalen Wert zu berechnen. Sie sollte nicht höher als die Versorgungsspannung sein! * AGND ist die Masse für den analogen Teil des Schaltkreises. * CLK bestimmt den Takt für die Datenübertragung (engl.: clock). * DOUT ist der digitale Ausgang der SPI-Schnittstelle. * DIN ist der digitale Eingang der SPI-Schnittstelle. * CS/SHDN ist der Steuereingang des Schaltkreises (eng.: cable select). Wird er auf low gesetzt ist der Schaltkreis aktiv. * DGND ist die Masse des digitalen Teils des Schaltkreises. * CH1...7 sind die 8 analogen Eingangskanäle. Sie können mit einer Spannung belegt werden, die mit einer Referenzspannung (VREF) verglichen und dann in einer Auflösung von 1024 (10 Bit Auflösung, 210 = 1024) an die SPI-Schnittstelle übergeben wird. Die Spannung an den Eingängen darf laut Datenblatt -0,6V bis VDD+0,6V nicht unter- / überschreiten, da der Schaltkreis sonst Schaden nimmt. === SPI am Pi === Der MCP3208 kommuniziert mittels SPI mit dem Pi. * SPI Hardware Interface des Pi aktivieren mittels ''raspi-config'' * SPI Kernelmodul laden * bei Pi A oder B: {{{ modprobe spi_bcm2835 }}} * bei Pi B+, 2 und 3: {{{ modprobe spi_bcm2708 }}} * Damit das Kernelmodul bei jedem Boot geladen wird in ''/etc/modules-load.d/modules.conf'' reinschreiben * Achtung: VDD und VREF nicht höher als 3,3V wählen! Der Pi verträgt keine 5V an den GPIO Pins. * Im Schaltkreis unten braucht der Stromsensor 5V zum Betrieb und gibt dann Werte zwischen 0V und 5V an Vout zurück. Deswegen gibt es dort mit R3 & R4 einen weiteren Spannungsteiler {{attachment:MCP3008_an_Pi_mit_Spannungsteiler_Steckplatine.png|MCP3008 an Pi mit Spannungsteiler|height=750}} === Python gpiozero MCP Bibliothek === Die Werte des MCP3208 lassen sich in Python unkompliziert mittels gpiozero Bibliothek auslesen. * gpiozero Bibliothek: https://gpiozero.readthedocs.io/en/v1.2.0/index.html * installieren: {{{ aptitude install python3-setuptools python3-gpiozero }}} * A/D Werte auslesen Python Bsp. Code: {{{ #!/usr/bin/python3 from gpiozero import MCP3208 sensor1 = MCP3208(0) # Read data from the ADC def getData(readSensor): value = readSensor rawValue = value.value return rawValue print('Sensor1: %.1f' % (getData(sensor1)*100)) sensor1.close() }}} * gemessene Spannung = (AD Wert / 4096) * Referenzspannung * Spannungsstabilisierung mit Z-Diode: http://www.elektronik-kompendium.de/sites/slt/1012151.htm * Bsp Verdrahtung mcp3xxx für Thermometer: http://www.geeklee.co.uk/rpi-mcp3008-tmp36-sqlite-lighttpd/ == Rotor Umdrehungen == * rpm mittels reed switch * Das kann genauso wie beim [Eddy-2-Power/Windmessgerät]] realisiert werden. * geeignet sind auch einfache Fahrradcomputer * später rpm counter aka Kilometerzähler für den Rotor in Software realisieren == Temperaturen == Die Temperaturerfassung dient hauptsächlich der Problemanalyse und wird auch für Schutzschaltungen genutzt. Anfällig für Überhitzung sind insbesondere die Akkus und die Lastwiderstände. Wir verwenden zur Messung DS18B20 Sensoren. Die sind zwar etwas teurer als temperaturabhängige Widerstände, dafür liefern sie relativ genaue Werte, müssen nicht erst geeicht werden und funktionieren über längere Datenleitungen ohne aufwändigen Schaltungsaufwand. * todo: Grafik der Schaltung einfügen * in ''/etc/modules'' zwei Zeilen ergänzen: {{{ w1_gpio w1_therm }}} * dann folgendes in /boot/config.txt setzen: {{{ dtoverlay=w1-gpio }}} * Pythoncode für das Muninplugin: {{{ #!/usr/bin/python3 import sys def getData(temp_filedescriptor): temperature = 0 read_repeat = 10 # mittelwert for i in range(read_repeat): tempfile = open(temp_filedescriptor) temptext = tempfile.read() tempfile.close() tempdata = temptext.split("\n")[1].split(" ")[9] temperature += float(tempdata[2:]) return temperature / (read_repeat * 1000) if len(sys.argv) == 2 and sys.argv[1] == "autoconf": print("yes") elif len(sys.argv) == 2 and sys.argv[1] == "config": print('graph_title temperature values @ ds18b20') print('graph_vlabel temperature in °C') print('graph_category sensors') print('graph_args -l 0') print('T1.label T1' ) else: print('T1.value %.2f' % (getData("/sys/bus/w1/devices/28-0000074abb83/w1_slave"))) }}} * weitere Links: * http://www.reuk.co.uk/wordpress/raspberry-pi/ds18b20-temperature-sensor-with-raspberry-pi/ * https://www.modmypi.com/blog/ds18b20-one-wire-digital-temperature-sensor-and-the-raspberry-pi * http://webshed.org/wiki/RaspberryPI_DS1820 == Sonnenlicht == * lichtabhängiger Widerstand an Spannungsteiler an mcp3208 ---- = Datenerfassung = In der einfachen Variante werden fast alle Messwerte durch einen Arduino kontinuierlich erfasst. Der Raspi liest sie via USB aus und schreibt die Daten zunächst in eine sqlite Datenbank. == Vorbereitung des Arduinos == Vom Raspi aus kann der Arduino per USB geflasht werden. Entweder über die Arduino IDE oder über die Konsole mittels ''ino''. * ino über pip installieren: {{{ aptitude install python-pip screen pip install ino }}} * ino läuft nur mit python2 * screen wird zum Testen der seriellen Konsole genutzt == Arduinocode flashen == * {{{ mkdir test cd test ino init vi src/sketch.ino ino list-models ino build -m mega2560 ino upload -m mega2560 }}} == Kommunikation zwischen Arduino & Raspi == Raspi und Arduino sprechen direkt über USB miteinander. Der Arduino bezieht somit auch seinen Strom aus dem USB Port des Raspis. Alternativ können beide per USB mit Strom versorgt werden und z.B. über I2C oder SPI Daten austauschen. * screen /dev/ttyACM0 115200 * ino serial (verwendet picocom) Hier werden Raspi und Arduino per USB verbinden. Letzteres bezieht dabei seinen Strom über den Raspi. * http://www.doctormonk.com/2012/04/raspberry-pi-and-arduino.html Es ginge auch separat (jeweils getrennt per USB mit Strom versorgen) und dann mittels I2C kommunizieren: * http://fritzing.org/projects/i2c-raspberrypi2-master-to-arduino-slave I2C Verbindung * https://blog.retep.org/2014/02/15/connecting-an-arduino-to-a-raspberry-pi-using-i2c/ Software * http://arduino-pi.blogspot.de/2014/03/speeding-up-i2c-bus-on-raspberry-pi-and.html I2C beschleunigen Zukünftig könnten die Messwerte auch direkt vom Pi am Arduino ausgelesen werden. Dafür gibt es z.B. die ''pyduino'' API. == Arduino Ausgabe == Der Arduino läuft in einer Dauerschleife, in der er die aktuellen Werte der Sensoren aufnimmt und ohne weitere Berechnungen ausgibt. Diese Werte werden sekündlich als csv Zeile über den USB Port ausgegeben. Der Arduino gibt beim Start eine Zeile mit Bezeichnung der csv Werte aus. Damit ist es möglich die Ausgabe auf jedem beliebigem Rechner zu empfangen und auszuwerten. Auf dem angeschlossenen Pi läuft ein Script, das die Werte in eine SQlite Datenbank überträgt und die Umrechnungen der Messwerte vornimmt. {{attachment:arduino_hello_world.jpg}} * Bsp. für Arduino Sensoren auslesen: {{{ const int ledPin1 = 13; const int ledPin2 = 12; const int APin1 = 4; // the number of the analog input pin int av1; int av2; void setup() { Serial.begin(115200); pinMode(ledPin1, OUTPUT); pinMode(ledPin2, OUTPUT); Serial.println("=== start === "); Serial.println("csv head: "); Serial.println("av1 high, av2 low"); } void loop() { digitalWrite(ledPin2, HIGH); digitalWrite(ledPin1, LOW); delay(500); av1 = analogRead(APin1); Serial.print(av1); Serial.print(", "); digitalWrite(ledPin1, HIGH); digitalWrite(ledPin2, LOW); delay(500); // delay in between reads for stability av2 = analogRead(APin1); Serial.println(av2); } }}} == Messwerte in Datenbank speichern == Der Raspi liest die Messwerte des Arduinos aus und speichert sie in einer Datenbank. * Script einfügen === SQLite Beispiele === ==== Create ==== {{{ CREATE TABLE COMPANY( ID INT PRIMARY KEY NOT NULL, UNIXTIME INT NOT NULL, SENSOR1 INT, SENSOR2 INT, ) }}} * storage classes: INT, REAL, TEXT, BLOB {{{ sqlite3 }}} und darin: {{{ .help .tables .schema test SELECT * FROM test; }}} ==== SELECT ==== {{{ SELECT v_bat, a_bat FROM test; SELECT v_bat, a_bat FROM test WHERE ; SELECT v_bat, a_bat FROM test WHERE unixtime LIKE '14839129%'; SELECT v_bat, a_bat FROM test WHERE unixtime BETWEEN 1483907574 AND 1483907595; SELECT COUNT() as ENTRIES FROM test; SELECT COUNT() as ENTRIES FROM test WHERE v_bat > 710; SELECT AVG(random) FROM test WHERE random <=100; SELECT p2rand, random FROM test GROUP BY random; SELECT avg(p2rand), random FROM test GROUP BY random; SELECT avg(p2rand), random FROM test GROUP BY random ORDER BY count(p2rand); SELECT MAX(unixtime), A0, A1, A2, A3, A4, A5 FROM test; SELECT * FROM test ORDER BY unixtime DESC LIMIT 10; }}} ==== DELETE ==== {{{ DELETE FROM test WHERE A5 > 1023; DELETE FROM test WHERE A0 > 1023 OR A1 > 1023 OR A2 > 1023 OR A3 > 1023 OR A4 > 1023 OR A5 > 1023; }}} = Datenkonvertierung = In der Datenbank liegen Rohdaten, also die Messwerte des Arduino A/D Wandlers. Diese werden entsprechend der Sensoren und Beschaltung in Spannungs- und Stromwerte umgerechnet. Dazu wird ein Bautagebuch geführt, in dem Änderungen am Aufbau des Windrads und der Elektronik festgehalten werden. == Script zur Umrechnung der Messwerte == * == Fehleranalyse == * = Datenanalyse & Visualisierung = == Anzeige der Messwerte in Echtzeit == Während der Entwicklung werden die Daten per ssh ausgelesen. Das erfordert einen Computer und entsprechende Einarbeitung. Um sekundengenau aktuelle Messwerte, ohne weitere Hilfsmittel betrachten zu können, wird ein kleines Display angeschlossen werden (LCD oder altes Handydisplay). Ebenso ist eine einfache Akkuladestandsanzeige z.B. mit verschieden farbigen LEDs angedacht. == Monitoring mittles Munin == Im ersten Schritt werden die Messwerte in Echtzeitgraphen ohne weitere Analysen mittels ''munin'' dargestellt. Das hat den Vorteil, dass wir alle Messwerte im zeitlichen Verlauf betrachten können und auch relativ aktuelle Messwerte sehen (max. 5 Minuten alt). Außer einem Browser sind keine weiteren Hilfsmittel zum Ablesen notwendig. Munin generiert Grafiken aus den gesammelten Daten und stellt sie auf einer Webseite dar. Das sieht dann z.B. so aus: {{attachment:munin_sensor-day.png}} {{attachment:munin_anemometer-month.png}} * Munin Plugin unter ''/etc/munin/plugins/'' anlegen: {{{ #!/usr/bin/python import sys if len(sys.argv) == 2 and sys.argv[1] == "autoconf": print "yes" elif len(sys.argv) == 2 and sys.argv[1] == "config": print 'graph_title sensor values @ arduino' print 'graph_vlabel A/D value' print 'graph_category sensors' print 'graph_args --base 1000 -l 0' print 'A0.label Sensor A0' print 'A1.label Sensor A1' print 'A2.label Sensor A2' print 'A3.label Sensor A3' print 'A4.label Sensor A4' print 'A5.label Sensor A5' else: tmp_file = open("/tmp/eddy_last_values", 'r') sensor_values = tmp_file.readline() tmp_file.close() A = sensor_values.split(", ") print 'A0.value %s' % str(A[1]) print 'A1.value %s' % str(A[2]) print 'A2.value %s' % str(A[3]) print 'A3.value %s' % str(A[4]) print 'A4.value %s' % str(A[5]) print 'A5.value %s' % str(A[6]) }}} * root Rechte für Plugins einstellen in ''/etc/munin/plugin-conf.d/munin-node'': {{{ [anemometer] user root [sensor] user root }}} * test with munin-run -d anemometer this should print one line * http://munin-monitoring.org/ - Monitoring Software * http://munin-monitoring.org/wiki/HowToWritePlugins - Munin Plugin schreiben === Munin mit lighttpd === Die Munin Graphen liefert Pi mittels Webserver lighttpd aus. Im Prinzip diesen Schritten folgen: * https://wiki.ubuntuusers.de/lighttpd/ * Zugangsbeschränkung einrichten: {{{ lighty-enable-mod auth vi /etc/lighttpd/conf-enabled/10-auth.conf systemctl force-reload lighttpd htpasswd -cm /var/www/html/.htpasswd }}} == Messwertdarstellung mit gnuplot == * GnuPlotHowTo {{attachment:gnuplot_testmessung.png}} {{{ set title "Arduino Sensorwerte" set ylabel "A/D Eingangswert" set xlabel "Datum" set autoscale ## unix timestamp an X-Achse set xdata time set timefmt x "%s" ## print png image set output "eddy2power.png" set terminal png size 1440,900 plot \ "eddy2power.csv" using 1:2 title 'A1' with dots , \ "eddy2power.csv" using 1:3 title 'A2' with dots , \ "eddy2power.csv" using 1:4 title 'A3' with dots , \ "eddy2power.csv" using 1:5 title 'A4' with dots , \ "eddy2power.csv" using 1:6 title 'A5' with dots , \ "eddy2power.csv" using 1:7 title 'A6' with dots , \ }}} == feinere Analyse == Alle erfassten Daten werden für spätere Analysen in einer Datenbank gespeichert. So können bei dokumentierten Veränderungen und Umbauten am Windrad später entsprechende Schlussfolgerungen gezogen werden. * pydata * pandas.pydata.org * seaborn.pydata.org * processing * http://www.dustynrobots.com/academia/teaching/seeing-sensors-how-to-visualize-and-save-arduino-sensed-data/ ---- = Tipps & Tricks = == Arduino via Raspi resetten == Wenn Pi und Arduino an der selben Stromversorgung hängen kann ein Kabel direkt von einem GPIO Pin am Pi zum Arduino Reset Pin geführt werden. Achtung, bei unterschiedlichen Stromquellen sollte eine kleine Diodenschaltung den dann möglichen Stromfluss unterbinden, damit die gute Hardware nicht verbrutzelt wird. {{attachment:arduino_reset_via_pi-gpio.png}} * [[attachment:arduino_reset_via_pi-gpio.fzz]] Hier wird GPIO Pin 4 des Pis genutzt, mit dem Reset Pin am Ardunio verbunden und durch dieses Script (auf dem Pi) kurz auf HIGH gesetzt: {{{ #!/bin/ash echo 4 > /sys/class/gpio/export echo out > /sys/class/gpio/gpio26/direction echo "0" > /sys/class/gpio/gpio4/value; sleep 1; echo "1" > /sys/class/gpio/gpio4/value exit 0 }}} * Es wird eine Sekunde gewartet, ein paar Millisekunden würden auch genügen. * als ''root'' ausführen == Arduino soft reset verhindern == Jedes Mal, wenn mit pyserial eine Verbindung zum Arduino hergestellt wird, führt dieser ein reset durch (reset on serial connection). Es gibt mehrere Möglichkeiten das zu unterbinden. Die softwareseitig Einfachste ist wohl folgendes Kommando in der Raspberry Pi Konsole: {{{ stty -F /dev/ttyACM0 -hupcl }}} * http://raspberrypi.stackexchange.com/questions/9695/disable-dtr-on-ttyusb0 * http://playground.arduino.cc/Main/DisablingAutoResetOnSerialConnection == Atmega an Raspi == * https://domes-finest.de/2013/10/16/raspberry-pi-mit-einem-arduino-per-i2c-verbinden/ * https://oscarliang.com/raspberry-pi-arduino-connected-i2c/ * Atmega an Pi PINs 8 & 10 & 3,3V! + 11MHz quarz * serial 9600 baud * gehts auch schneller? * https://de.pinout.xyz/pinout/uart * 100nF Glättungskondensatoren zwischen vcc &gnd sowie avcc & agnd * ADC Messfequenz: 50Hz-200kHz == genauere Messwerte == * 10ms warten vor jeder Messung * testen ob Werte nach 1ms und 10ms sehr unterschiedlich sind * http://forum.arduino.cc/index.php?topic=54976.msg428738#msg428738 * AnalogIn logarithmisch mappen damit kleine Stromflüsse besser sichtbar werden * https://www.arduino.cc/en/Reference/Map * https://www.arduino.cc/en/Tutorial/Calibration == bessere Analog/Digital Wandler am Arduino == Wem der interne 10Bit A/D Wandler des Arduinos nicht fein genug auflöst, der/die schaltet einen höher bittigen davor (z.B. mcp3201 oder adc121c). Damit sind z.B. Amperemessungen in 0,0146A Schritten möglich (60/2^12 = 0,014648438). * http://playground.arduino.cc/Code/MCP3208 - 12bit Sensor am Arduino * http://arduino-projekte.de/index.php?n=43 - mcp320x Funktionen * https://www.raspiprojekt.de/machen/basics/schaltungen/26-analoge-signale-mit-dem-mcp3008-verarbeiten.html?showall=1 https://www.raspiprojekt.de/machen/downloads/category/5-anleitungen.html?download=9:analog-digitalwandler-mcp3008 * oder auch: * ADS1015 12-Bit ADC 4 Kanäle * ADS1115 16-Bit ADC 4 Kanäle == A/D Wandler am Pi == Der Rapsberry Pi kann nur digitale Werte aufnehmen. Der A/D Wandler lässt sich aber auch direkt an den Pi anschließen: * http://erik-bartmann.de/component/attachments/download/21.html - Pi A/D Wandler mit mcp3008 * https://www.raspberrypi.org/forums/viewtopic.php?f=32&t=134997# - Python A/D Wandler Treiber * Raspberry Pi HAT - 8 Channel ADC - MCP3208 - SPI - mit level shift (3.3V-5V) 25-30€ == Multiplexer == Da die Wandler recht teuer sind und selten wirklich simultan gemessen werden muss bietet sich der Einsatz von Multiplexern an. Dabei werden mehrere Eingangsignale auf ein einzelnes gelegt. Im Programm lässt sich dann festlegen, welcher Eingang gerade gewählt wird. * z.B. !SparkFun Analog/Digital MUX Breakout - CD74HC406 5€ - Multiplexer für 16 analoge auf einen digitalen Eingang (spart 16 A/D Wandler) * https://github.com/sparkfun/Analog_Digital_MUX_Breakout * http://bildr.org/2011/02/cd74hc4067-arduino/ == Hall Sensor für Wechselstrommessungen == * http://www.homautomation.org/2013/09/17/current-monitoring-with-non-invasive-sensor-and-arduino/ - AC monitoring with non-invasive sensor and arduino == Arduino low power == * http://shelvin.de/arduino-in-den-sleep_mode_pwr_down-schlaf-modus-setzen/ * http://interface.khm.de/index.php/lab/interfaces-advanced/sleep_watchdog_battery/ * http://donalmorrissey.blogspot.de/2010/04/putting-arduino-diecimila-to-sleep-part.html == Arduino Optimierung - don't use delay() == * https://learn.adafruit.com/multi-tasking-the-arduino-part-1/a-classy-solution == Links == * https://openenergymonitor.org - Open Source Projekt zur Verbrauchsmessung von Haushaltsgeräten