Als klassische Variante, einen ohm'schen Netzverbraucher (z.Bsp.
Glühlampen) in ihrer Helligkeit zu steuern, wird üblicherweise ein Triac
in einer Phasenanschnitt- oder Phasenabschnittsteuerung verwendet.
Diese Schaltung ist einfach aufzubauen, kostet wenig und man kann durch
Änderung der Zeitkonstante eines RC-Gliedes (durch Ändern des
Widerstandes mit Hilfe eines Potentiometers) die Spannungsform an der
Last beeinflussen. Dies geschieht durch "An- oder Abschneiden" der
"Sinuswelle" zu einem gewünschten Zeitpunkt. Die daraus resultierende,
verbleibende "Wellenform" versorgt die Last mit Energie. Da die
"Sinuswelle" nun jedoch nicht mehr "vollständig" ist, ist auch die
effektiv übertragene Energie zur Last kleiner. Das bedeutet weniger
Spannung liegt an der Lampe an. Somit sinkt auch die Lampenhelligkeit.
Hierzu findet man reichlich Informationen
im Netz. Will man eine solche Phasenanschnittsteuerung nun jedoch nicht
mit einem Potentiometer steuern, sondern mit einem Microcontroller oder
einer externen analogen Spannung von zum Beispiel 0-5V, so ist hier ein
erweiterter Schaltungsaufwand notwendig.
Auf eine ganz andere
Weise ist die hier dargestellte Schaltung aufgebaut. Hier wird nicht mit
einem Triac die negative bzw. positive Halbwelle angeschnitten, sondern
mit einem FET der Pfad in einem Brückengleichricher durchgeschaltet.
Der FET selbst wird per PWM (PulsWeitenModulation) angesteueuert. Die
PWM wiederum erzeugt der Einfachheit halber ein Atmega Microcontroller.
Durch die frei wählbaren PWM Grundfrequenzen sind hier sehr schnelle und
somit auch flackerfreie Schaltvorgänge realisierbar.
Die Skizze soll die simple Funktionsweise veranschaulichen: Im Bild ist
der Stromkreis dargestellt. Der Verbraucher liegt in Serie mit dem
Brückengleichrichter an der Phase L und dem Neutralleiter N. Im Querpfad
des Brückengleichrichters befindet sich ein Schalter (in der realen
Anwendung ein angesteuerter Mosfet). Wird der Schalter S nun nicht
betätigt, bleibt also offen, kann durch die Dioden kein Strom fliessen.
Weder die positive noch die negative Halbwelle finden einen
geschlossenen Stromkreis. Anders sieht es jedoch aus wenn der Schalter S
geschlossen wird. Dies ist in der rechten Skizze dargestellt. Der
Strompfad einer Halbwelle ist in rot, der der anderen Halbwelle in blau
dargestellt. Der Strom fliesst und die Lampe leuchtet. Das besondere
daran ist es nun, verfolgt man die Stromrichtung beider Halbwellen durch
den Schalter, so kann man erkennen, dass bei beiden Halbwellen die
selbe Stromrichtung vorliegt. Damit ist es nun möglich mit einem
Transistor oder FET, eine Wechselpannungsquelle zu schalten. Das
Ein/Aus Verhältnis (also PWM) des Schaltsignals, kann somit wieder die
effektive Spannung an der Last beeinflussen.
Und genau eine solche Schaltung habe ich hier aufgebaut. Der
Atmega-Microcontroller erzeugt ein PWM Signal, das über einen
Optokoppler den Mosfet ansteuert. Somit sind ganz einfach per Software
alle möglichen Schalt- und Dimmszenarien realisierbar. (z.Bsp.
Steuerung der Lampenhelligkeit über eine Analogspannung am ADC des µC
...)
Im Bild links ist ein Testaufbau des Dimmers (Laststellers)
dargestellt. Die Versorgungsspannung des µC wird hier noch durch einen
AC/DC Converter realisiert, um eingangsseitig eine galvanische Trennung
vom Netz herzustellen.
Dieses Blog durchsuchen
Raspberry als Datenlogger Teil2...Die Sensoren und Python
Raspberry PI samt Powerbank im Gehäuse |
- Die PI Platine gemeinsam mit einer USB Powerbank in ein Gehäuse eingebaut
- Anschlüsse wie Ethernet, USB, HDMI durch Ausschnitte im Gehäuse nach aussen geführt
- Zwei Leuchtdioden und einen Taster ins Gehäuse eingebaut und auf die GPIOs geschaltet
- Den I²C Bus des PI auf eine Buchse im Gehäuse geführt
- Eine MicroSD Karte mit einem Raspi-Wheezy Image bespielt
- Einen USB-Stick mit FAT32 formatiert
- Das Betriebssystem soweit konfiguriert, dass das Filesystem für den Stick, alle Module für den I²C-Bus, sowie Python geladen werden
Raspberry PI im Plastikgehäuse |
Ausführung: Feuchtesensor im TO39 Gehäuse, druckfest, mit Edelstahl-Sinterfilter
Genauigkeit: Feuchte ±1,8% rF, Temperatur ±0,2 °C
Genauigkeit 0...10% rF (0 ... 50°C): ±(0,1% rF + 17% aw)
Messbereich: Feuchte 0 ... 100% r.F. (max. dp = +80 °C), Temperatur - 40 ... +125 °C
Abmessungen: 5,2 x 9 mm
Anschlüsse: TO 39 Footprint
Auflösung Feuchte: 0,02% rF
Hysterese bei 50% rF: < ±1% rF
Linearitätsfehler: < ±1% rF
Ansprechzeit t63: < 10 sec (Mit Edelstahl-Sinterfilter)
Auflösung Temperatur: 0,015 °C
Digitale Schnittstelle: I2C, Adresse 0x28 oder Alternativadresse
Betriebsspannung: 2,7 … 5,5 V
Stromaufnahme (typ): < 1µA in Bereitschaft < 22µA bei 1Hz Messrate 850 µA maximal
HYT939 Sensor |
Nachdem der Sensor nun an den Raspberry angeschlossen ist, fehlt nur mehr ein Programm um ihn oder auch mehrere anzusteuern und auszulesen. Hier verwende ich den Python Interpreter. Damit lassen sich auf einfache Weise die Daten auslesen und auch auf Datenträgern speichern. Das "Programm" besteht aus zwei Teilen:
- Hauptscript: beinhaltet nur eine Endlosschleife, die die LEDs steuert, den Taster abfragt, die Sensorfunktion aufruft, deren ausgelesene Werte übergibt, aufbereitet und auf den Stick speichert.
- Funktion Sensor auslesen: adressiert den I²C Bus, liest die Sensordaten aus, rechnet sie in lesbare Werte um und übergibt den Output an die Funktion
# /usr/bin/python # License: GPL 2.0 # edited by Ingmar B. Aug.2015 import os from time import * import time import threading import hyt939o import RPi.GPIO as GPIO # Setup LED Ports (pin12 = LED rot, pin18 = LED gruen) GPIO.setwarnings(False) GPIO.setmode(GPIO.BOARD) GPIO.setup(12, GPIO.OUT) GPIO.setup(18, GPIO.OUT) GPIO.setup(16, GPIO.IN) # LED Gruen einschalten sobald das Script gestartet ist GPIO.output(18, GPIO.HIGH) #gpsd = None #seting the global variable address = [0x2a, 0x29] #hyt939 = [0, 0] hum = [0, 0] temphyt = [0, 0] loopon = True #set variable for loop i=1 #counter for address selection os.system('clear') #clear the terminal (optional) while loopon: # bei beginn des auslesens aller daten die rote Led einschalten GPIO.output(12, GPIO.HIGH) if GPIO.input(16)== GPIO.HIGH: loopon = False os.system('clear') # Variablen fuer Sensor HYT 939 uebergeben for i in range(2): hyt939=hyt939o.ReadMeasurement(address[i]) time.sleep(0.1) hum[i]=hyt939[0] temphyt[i]=hyt939[1] print '--------------------------------------- ' print 'SENSORS reading Sensor Nr.:' , i print print 'humidity hyt939 ' , hum[i] print 'temperature hyt939 ' , temphyt[i] print '--------------------------------------- ' print print 'data to write:' , str(hum[0]), str(temphyt[0]), str(hum[1]), str(temphyt[1]) print ("date :" + time.strftime("%x")) print ("time :" + time.strftime("%X")) print date = time.strftime("%x") zeit = time.strftime("%X") ## write all data to usbstick fileout = open("/media/usbstick/wetterfrosch.txt", "a") time.sleep(0.1) fileout.write(date+";"+zeit+";"+str(hum[0])+";"+str(temphyt[0])+";"+str(hum[1])+";"+str(temphyt[1])+"\n") time.sleep(0.1) fileout.close() time.sleep(0.1) # nach schreiben bzw auslesen der daten rote LED wieder abschalten GPIO.output(12, GPIO.LOW) time.sleep(0.8) #set to whatever GPIO.output(18, GPIO.LOW) # gruene Led ausschalten
print "Ende"
Das folgende Listing liest den Sensor aus:
# Reading mesaurements from HYT 939 humidity and temperature sensor
# First Version by Caerandir May 2014 modified by i.bihlo 2015
import smbus, time
bus = smbus.SMBus(1) # Raspberry Rev. 2
address = 0x28 # Fixed default address of HYT 939
# Initialize sensor to acquire measurements
def MeasurementRequest():
void = bus.write_quick(address)
time.sleep(0.1)
# Read Humidiy and Temperature to 14 bit accuracy
def ReadMeasurement():
void= bus.write_quick(address)
time.sleep(0.1)
# Acquire 4 byte from sensor
#time.sleep(0.1)
Readout = bus.read_i2c_block_data(address,0,4)
# Calculiere die relLF in % aus den vier Bytes in "Readout"
RelHum = Readout[0]<<8 | Readout[1]
RelHum = RelHum & 0x3FFF
RelativeHumidity = 100*RelHum/(2**14)
# Calculiere die Temperatur vom Sensor
Readout[3] = Readout[3] & 0x3F
temp = Readout[2]<<6 | Readout[3]
Temperature = 165.0*temp/(2**14)-40
print "Hrel: ", RelativeHumidity, " %"
print "T: ", Temperature, " C"
return RelativeHumidity, Temperature
MeasurementRequest()
time.sleep(0.2)
ReadMeasurement()
Eine Versuchsmessung über einen Tag und eine Nacht mit drei Sensoren hat folgendes Ergebnis geliefert. In diesem Fall wurden die Temperaturdaten aufgezeichnet. (Die Daten vom USB-Stick wurden mit Matlab importiert und daraus ein Plot erstellt.)
Raspberry als Datenlogger Teil1...Das Betiebssystem einrichten
Der Raspberry Pi ist ja mittlerweile ein bekannter und beliebter
Scheckkartenplatinen-Computer mit dem sich allerlei anstellen lässt. Vom
TV-Frontend mit Kodi, über Spielekonsolenemulatoren mit Retropi,
bis hin zum Bürorechner, ist damit fast alles möglich. In diesem
Projekt möchte ich vorstellen, wie mit Hilfe des Raspberry Pi Model2
physikalische Größen, wie Temperatur und Luftfeuchtigkeit gemessen und
auf einem Speichermedium geloggt werden. Und zwar mit einem
Feuchtesensor der Type HYT939 der am I²C Bus angeschlossen wird, genauer
gesagt: mehrere I²C Feuchtesensoren am Bus...
Wir beginnen zuallererst mit der Versorgung des Raspberry PI. Im Bild
ist ein Pi2 in ein einfaches Kunststoffgehäuse eingebaut und an eine 2Ah
USB-Powerbank von RS-Components angeschlossen. Der Ladeanschluss der
Powerbank ist vom Gehäuse nach aussen geführt. So kann der Pi wahlweise
über die Powerbank (mit einer nicht rechenintensiven Anwendung bis zu
3h) oder über eine externe USB-Versorgung (z.Bsp. einem
Handyladeadapter) betrieben werden. Der I²C Bus des PI (Pin 3 SDA und
Pin 5 SCL sowie Pin 2,4 +5V und GND an Pin 6,14...) sind auf einen
Stecker im Gehäuse ausgeführt. Um später irgendwelche Statusmeldungen
ausgeben zu können, sind zwei LEDs an die GPIOs 24 und 18 (an Pin18 und
Pin12) angeschlossen. Ein weiterer GPIO wird über einen 22k
Pulldown-Widerstand an einen Taster an 5V geschaltet. (GPIO23 an Pin16).
Für die USB Anschlüsse, Ethernet und HDMI wurden im Gehäuse passende Ausschnitte gemacht, an eine USB Schnittstelle ein Keyboard und an den HDMI Port ein Monitor angeschlossen. Die LAN Verbindung mit Internetzugang sollte auch hergestellt sein, um nach der Ersteinrichtung die benötigten Module und Updates laden zu können.
Jetzt fehlt nur noch das Speichermedium mit Betriebssystem. Der PI2 ist mit einem Micro-SD Slot ausgestattet. Ich habe hier eine 4GB Micro SD mit einem raspian-wheezy image bespielt. Um das Imagefile auf einfache Weise auf die SD-Karte zu bekommen, empfiehlt es sich, das Tool win32diskimager zu verwenden. Ist die Speicherkarte dann fertiggestellt, kann man beginnen.
Der Raspberry zeigt nach dem Einschalten kurz seinen Farbverlauf und dann beginnt auch schon der Bootprozess. Ist der dann beendet, so startet das OS am PI erstmal eine Setup Routine.
Hier sind nun folgende Schritte durchzuführen:
i2c_bcm2708
i2c_dev
dann mit STRG+X den Editor beenden und bei Speichern JA wählen.
danach mit:
Falls ja, ist der auszukommentieren oder zu löschen.
jetzt wieder neustarten mit:
UUID=XXXX-XXXX /media/usbstick/ vfat utf8,uid=pi,gid=pi,noatime 0
weiter gehts mit der Einrichtung der GPIOs und den Python libraries:
Das zu Anfang gestartete Setup Script lässt sich immer über folgenden Befehl aufrufen:
Das war´s für den Anfang. Im zweiten Teil beschreibe ich dann die Sensorhardware und die Python-Scripts, die die Sensoren dann auslesen…
Raspberry PI2 mit Powerbank im Plastikgehäuse |
Für die USB Anschlüsse, Ethernet und HDMI wurden im Gehäuse passende Ausschnitte gemacht, an eine USB Schnittstelle ein Keyboard und an den HDMI Port ein Monitor angeschlossen. Die LAN Verbindung mit Internetzugang sollte auch hergestellt sein, um nach der Ersteinrichtung die benötigten Module und Updates laden zu können.
Jetzt fehlt nur noch das Speichermedium mit Betriebssystem. Der PI2 ist mit einem Micro-SD Slot ausgestattet. Ich habe hier eine 4GB Micro SD mit einem raspian-wheezy image bespielt. Um das Imagefile auf einfache Weise auf die SD-Karte zu bekommen, empfiehlt es sich, das Tool win32diskimager zu verwenden. Ist die Speicherkarte dann fertiggestellt, kann man beginnen.
Der Raspberry zeigt nach dem Einschalten kurz seinen Farbverlauf und dann beginnt auch schon der Bootprozess. Ist der dann beendet, so startet das OS am PI erstmal eine Setup Routine.
Hier sind nun folgende Schritte durchzuführen:
- im Menu internationalisation options unter I1 die entsprechenden locals einstellen -> DE_UTF_8
- in advanced options unter A2... einen Hostname vergeben z.Bsp.:"raspisensor", in A4... SSH enablen, in A7 ...I²C enablen und load per default und in A8 ... serial enable und login shell aktivieren
- dann noch expand filesystem wählen damit der Speicherplatz der gesamten SD-Karte genutzt wird
- jetzt noch mit finish -> reboot neu starten
sudo apt-get updateEs empfiehlt sich, die Kernelmodule per Autostart zu laden. Das geht wie folgt:
sudo apt-get install python-smbus (installiert den system management bus)
sudo modprobe i2c_bcm2708 (kernelmodule für I²C von Hand laden)
sudo modprobe i2c_dev
lsmod (geladene Module listen)
sudo i2cdetect -y 1 (I²C ports scannen)
sudo nano /etc/modules (mit dem Nano-Editor die Datei modules öffnen ...)dann folgende Zeilen hinzufügen:
i2c_bcm2708
i2c_dev
dann mit STRG+X den Editor beenden und bei Speichern JA wählen.
danach mit:
sudo nano /etc/modprobe.d/raspi-blacklist.confüberprüfen, ob hier bereits ein Eintrag "blacklist i2c-bcm 2708" existiert.
Falls ja, ist der auszukommentieren oder zu löschen.
jetzt wieder neustarten mit:
sudo shutdown -r nowDa wir später die Daten von den Sensoren in eine Datei loggen wollen und diese Datei auf einem USB-Stick gespeichert werden soll, sind folgende Schritte notwendig:
danach wieder einloggen und mit
lsmod
überprüfen ob die gewünschten Module korrekt geladen sind.
- einen USB-Sick mit FAT32 Filesystem auf einem Windowsrechner formatieren
- auf dem PI das Filesystem FAT32 installieren
- den Stick in den PI stecken und die Mountlist um den Stick erweitern
sudo apt-get -y install ntfs-3g hfsutils hfsprogs exfat-fusedann legen wir folgendes Verzeichnis an:
sudo mkdir /media/usbsticknun öffnen wir folgende Datei mit dem Editor:
sudo blkid -o list -w /dev/null
(listet die IDs der Datenträger auf -> unser Stick sollte in der Liste als vfat mit einer ID in dem Format XXXX-XXXX erscheinen)
sudo mount -t vfat -o utf8,uid=pi,gid=pi,noatime /dev/sda /media/usbstick
sudo nano -w /etc/fstabdie ID des USB-Sticks von vorher tragen wir nun samt folgender Zeile ein und speichern dann wieder ab:
UUID=XXXX-XXXX /media/usbstick/ vfat utf8,uid=pi,gid=pi,noatime 0
weiter gehts mit der Einrichtung der GPIOs und den Python libraries:
sudo apt-get install python-devNoch ein paar allgemeine Einstellungen:
sudo apt-get install python-rpi.gpio
sudo nano /etc/networks/interfaces (Wir wollen eine fixe IP Adresse vergeben, um später einfach per SSH auf den PI zugreifen zu können)folgende Zeile ersetzen:
iface eth0 inet dhcpdurch:
iface eth0 inet staticund wieder speichern:
address xxx.xxx.xxx.xxx
netmask yyy.yyy.yyy.yyy
gateway zzz.zzz.zzz.zzz
Das zu Anfang gestartete Setup Script lässt sich immer über folgenden Befehl aufrufen:
sudo raspi-configDie Systemzeit des Raspi (für meine Anwendung benötige ich auch einen Zeitstempel) lässt sich mit folgendem Befehl stellen:
sudo date "MMTThhmmJJ"
Das war´s für den Anfang. Im zweiten Teil beschreibe ich dann die Sensorhardware und die Python-Scripts, die die Sensoren dann auslesen…
Abonnieren
Posts (Atom)