Aquariumcomputer Marke Eigenbau mit Raspberry Pi

Der Filter filtert nicht mehr? Heizstab heizt nicht mehr? Du bastelst gerne? Hier bist du richtig für deine Technikfragen
  • Aquariumforum - Aquaristikfreaks

Willkommen im Aquariumforum der Aquaristikfreaks
Warum geisterst du hier eigentlich noch als Gast herum?
Hast du keine Lust, dich mit gleichgesinnten zu unterhalten, sei es nun im Forum oder auch im Chat?
Wir sind ein kleiner netter Haufen mit dem gleichen Hobby, der Aquaristik. Egal ob es um Zwergbuntbarsche, Guppys, Welse oder Salmler geht, egal ob Züchter, Profi, Händler oder Anfänger, egal ob Süß- oder Meerwasser:
Jeder ist Willkommen!
Hast du vielleicht auch Lust an der Fischdatenbank der Aquaristikfreaks mitzuarbeiten?
Anmelden und helfen! Eine Fischdatenbank von erfahrenen Usern für Anfänger
Die Anmeldung ist komplett kostenlos und dauert keine 3 Minuten

Aquariumcomputer Marke Eigenbau mit Raspberry Pi

Beitragvon Christian » 21.04.2014 11:14

Hallo

Diskussion und fragen hier



da es sich doch langsam weiter entwickelt und immer mehr wird, möchte ich das ganze hier mal vorstellen und immer mal wieder erweitern, wenn auch am Aquariumcomputer weitergearbeitet wird. Ein Bekannter hat dem Gerät den Namen "Eselsbeere" verpasst, so dass ich den nun auch so nennen werde ;) Der Name enstand aus meinen Nachnamen "Dresel" wobei das D&r geklaut wurde. "Beere" kommt aus dem Namen des "Computers" Raspberry Pi ;)

Ein Live generiertes Bild sieht aktuell so aus:

Bild


Da das ganze doch etwas komplizierter ist, möchte ich zuerst mal sagen, wobei man sich auskennen sollte, um sowas nachzubauen.

- Zuerst muss man Grundkenntnisse in Sachen Linux & Netzwerk haben. Das Raspberry Pi läuft unter Linux (Bei mir in der Kommandozeile und kein Klicki Bunti Windows ;)) und hängt per Netzwerkkabel am Internet. Um von meinem VServer (worauf auch das Forum läuft) Zugriff auf die Daten zu erhalten, wurde im Router ein Port auf das Raspberry Pi weitergeleitet. Wer keinen Webspace/VServer hat, kann das ganze durchaus auch auf dem Raspberry Pi speichern und von dort in das Internet stellen.
- Grundkenntnisse in PHP, MySQL und Apache sollten ebenfalls vorhanden sein. Die Daten werden per PHP eingelesen, später in eine MySQL Datenbank geschrieben und das Bild wird wiederrum per PHP erzeugt. Apache ist insofern wichtig, da man PHP+Apache auf der Eselsbeere zum laufen bekommen muss. Das ganze ist aber relativ einfach. Es ist zumindest sinnvoll zu wissen, was Python ist und wie man es verwendet. Kenntnisse sind aber unnötig (und hab auch ich nicht ;)). Auch einfache bash Scripte unter Linux sollte man etwas kennen sowie vielleicht einen Cronjob anlegen können.
- Elektronikkenntnisse sollten auch vorhanden sein, zumindest kleine Grundkenntnisse um Datenblätter lesen zu können und zu verstehen. So setze ich als Sensor zum Beispiel für Luftdruck und Raumtemperatur einen BMP085 ein, welcher per i²c Bus an der Eselsbeere hängt. Als Unterwassertemperatursensoren kommen DS18(b)20 zum Einsatz, welche per 1wire Bus an der Eselsbeere hängen.
- Geplant ist noch ein PH Sensor, welchen ich wohl fertig kaufen werde und ebenfalls per i²c an die Eselsbeere hänge. Ich hab zwar schon einen hier, der ist aber leider defekt. Weiteres dazu folgt demnächst
- Leitwert wurde mir ein "Trick" zugespielt. Mit einen ICM7555 ein Rechtecksignal erzeugen und einfach mit einer Eigenbausonde aus Edelstahl das Rechtecksignal "kurzschließen". Anschließend über einen Widerstand die Spannung messen und mit einen Leitwertmessgerät kalibrieren. Das ganze werde ich zuerst mal intensiv an einem Arduino testen da mir selbst die Schaltung noch nicht 100%ig klar ist. Sollte es klappen, wird das Analoge Signal mit einem PCF8591 über den i²c Bus eingelesen. Wer hier einen besseren Trick hat, darf ihn mir gerne nennen ;) Die Genauigkeit wird damit nicht extrem gut sein, aber auf die paar µS/cm kommt es mir nicht an. Mir ist eher wichtig, steigt der LW über die Zeit oder fällt er? ist das Wasser "hart" (700µS/cm was bei mir aus der Leitung kommt) oder nahezu reines Osmosewasser (20µS/cm)? Und ich denke das sollte mit so einer Eigenbausonde durchaus messbar sein.

Ich werde alle Sourcecodes hier veröffnlichten. Wer nachbauen will, darf dies tun sollte sich aber bewusst sein, das ich nicht alles von 0 an erkläre. Etwas Eigeninitiative oder auch Grundverständis sollte da sein und nicht wegen jeder Zeile Code nachgefragt werden, was sie macht. Klar erkläre ich gerne mal einzelne Codezeilen wenn sie unverständlich sind aber den ganzen Code werde ich nicht von 0 an erklären ;) Ich versuche aber das ganze etwas anfängerfreundlich zu lösen und keinen komplexen Syntax oder Formel zu verwenden.

Ebenso werde ich es immer wieder Stück für Stück hier posten. Den Thread mach ich oben fest und schließe ihn für die Diskussion, Fragen und weiteres werde ich einen weiteren Thread eröffnen den ihr hier finden werdet. Ich hoffe damit, das ganze etwas übersichtlich zu halten :)

mfg

Christian
Zuletzt geändert von Christian am 23.06.2014 12:15, insgesamt 7-mal geändert.
Benutzeravatar
Christian
-
-
 
Beiträge: 1773
Registriert: 20.07.2013 12:12
Wohnort: 90768 Fürth
Hat sich bedankt: 163 mal
erhaltene Bedankungen: 163 mal
AIPD: Zu meinem Fischbesatz

Re: Aquariumcomputer Marke Eigenbau mit Raspberry Pi

Beitragvon Christian » 21.04.2014 14:20

Hallo

so hier will ich mal eine Liste erstellen mit Zubehör was ich verwendet habe:

- Raspberry Pi Version B (A Version hat keinen Netzwerkascnhluss ich empfehle dringend die B Version)
- passendes Netzteil
- je nach Wunsch ein tolles Gehäuse
- mindestens 4GB SD Karte für das Betriebssystem, mehr Speicher ist eher unnötig, kostet aber auch nicht die Welt falls man mal doch noch was drauf ablegen will.
- nach Wunsch ein Breakoutboard um nicht auf dem Raspberry Pi rumlöten zu müssen
- Netzwerkkabel zum Router/Switch

somit kann man das Raspberry Pi in Betrieb nehmen.

Um jetzt Temperaturen zu messen nutzte ich DS18B20. Diese gibt es bei ebay sehr günstig. Ich hab meine selbst vergossen da ich noch welche rumliegen hatte, denke aber das auch diese hier sehr gut funktionieren dürften:
http://www.ebay.de/sch/i.html?_odkw=ds1 ... t&_sacat=0
achtet darauf, das Sendungen aus China bis zu 6 Wochen brauchen können, dafür aber wesentlich günstiger sind.
Man brauch dann nur noch einen 4,7kOhm Widerstand, welchen ich aus meiner Bastelkiste geklaut habe ;) Paar Lüsterklemmen, evtl. ein Lötkolben und ein bisschen 0,5mm² Einzeladern sind sinnvoll, wenn man später alles verdrahten will.

Für den Luftdruck und die Raumtemperatur nutzte ich einen BMP085. Da dieser Chip nahezu unmöglich selbst zu löten ist, hab ich mir ein günstiges fertiges Board gekauft. Diese tun es ebenfalls wunderbar.
Hier gibt es eine große Auswahl diverser Boards, sucht euch einfach eins aus. Beachtet wieder, alles aus China ist günstig und funktioniert, nur der Versand kann durchaus mehrere Wochen dauern! Falls in der Beschreibung was von Arduino steht, ist dies kein Problem, die Boards funktionieren auch wunderbar am Raspberry Pi :) Dies werde ich euch später erklären wie.

Für den PH Wert teste ich aktuell folgendes Modul:
http://www.sparkyswidgets.com/portfolio ... interface/ (Der Sourcecode dort ist für den Arduino angegeben, ich hab aber auch was für das Raspberry Pi, das zeig ich euch später mal)
Es kann auch von dort bezogen werden. Es wird dann noch eine PH Elektrode benötigt. Diese gibt es relativ günstig bei ebay:
http://www.ebay.de/sch/i.html?_odkw=ds1 ... e&_sacat=0
Wichtig ist ein BNC Anschluss, welche von denen gut oder schlecht ist, kann ich leider nicht sagen. Ich werde auf jeden Fall mal die günstigste testen ;)

Für den Leitwert habe ich noch nicht wirklich angefangen. Daher wird die Bauteilliste demnächst erst mal folgen.

Der nächste Beitrag wird sich dann um die Installation des Betriebssystem auf das Raspberry Pi drehen.

mfg

Christian
Zuletzt geändert von Christian am 22.04.2014 19:39, insgesamt 2-mal geändert.
Benutzeravatar
Christian
-
-
 
Beiträge: 1773
Registriert: 20.07.2013 12:12
Wohnort: 90768 Fürth
Hat sich bedankt: 163 mal
erhaltene Bedankungen: 163 mal
AIPD: Zu meinem Fischbesatz

Re: Aquariumcomputer Marke Eigenbau mit Raspberry Pi

Beitragvon Christian » 22.04.2014 19:29

Hallo

heute geht es darum, auf das Raspberry Pi ein Betriebssystem zu bekommen, es zu booten und über das Netzwerk vom PC darauf zuzugreifen.

Als erstes nehmen wir die SD Speicherkarte und stecken sie in den Kartenleser am PC. Folgende Programme werden nun benötigt:

Debian Wheezy dies ist das eigentliche Betriebssystem
Um das OS (=Operation System -> Betriebssystem) nun auf die Speicherkarte zu bekommen benötigen wir unter Windows noch Win32DiskImager.
Als erstes installieren wir Win32DiskImager auf dem PC und starten es, indem wir es mit der rechten maustaste anklicken und "als Administrator ausführen" auswählen. Dies ist nötig damit wir richtig auf die SD Karte schreiben können.
Das zuvor herunergeladene OS auswählen, das Laufwerk mit der SD Karte wählen (nochmal darauf achten, das auch das richtige ausgewählt ist, später ist ohne weitere Nachfrage alles auf dem Laufwerk gelöscht! Wer versehentlich seinen USB Stick mit Urlaubsbilder erwischt, hat danach ein Problem!) und auf "Write" klicken. Nun wird das Image auf die SD Karte geschrieben und wenn der PC fertig ist, kann die SD Karte entfernt werden.

Wenn man nun die SD Karte in das Raspberry Pi steckt, das RPI (nutzt ich jetzt als Abkürzung für Raspberry Pi) mit Strom versorgt, sollte es schon starten. Am besten zuvor noch mit einem Netzwerkkabel mit dem Router verbinden, damit es gleich im Netzwerk ist. Über den Router sollte man nun die IP des Raspberry Pi herausfinden können (je nach Routermodell sehr unterschiedlich, google oder Handbuch helfen da oder einfach mal bisschen ausprobieren ;)).

Wir brauchen jetzt noch für den PC das Tool Putty um uns mit dem Raspberry pi zu verbinden.

Wenn nun die IP des Raspberry Pi bekannt ist, kann man das Tool Putty starten und erhält dann folgenden Screen:

putty1.png
putty1.png (20.85 KiB) 20320-mal betrachtet


In der Zeile "Host Name (or IP Adresse)" muss die IP Adresse des RPI eingetragen werden. In meinen Fall ist es die 192.168.0.133 (wie auf den Screenshot zu erkennen)

Danach beherzt auf "Open" klicken, eventuelle Nachfragen zum Zertifikat bestätigen und schon sollte ein schwarzes Fenster aufgehen mit der Nachfrage nach dem Benutzername:

putty2.png
putty2.png (8.2 KiB) 20320-mal betrachtet


Als Benutzername geben wir direkt "root" ein drücken Enter und das Passwort lassen wir leer. Schon sind wir als "root" eingeloggt.
Ich übergehe hier mal diverse Sicherheitseinstellungen, welche durchgeführt werden sollten, wenn das RPI später über das Internet erreichbar gemacht wird. Falls du dein RPI später über das Internet erreichbar machen willst, gibt es diverse Tutorials im Netz was zu beachten ist, wie zum Beispiel das root Passwort ändern!

Mit dem Befehl raspi-config (ich schreibe absofort alle Befehle, welche man in die Konsole eingeben kann kursiv) kann ein kleines Hilfstool gestartet werden. Man kann dort diverse Sachen einstellen. Für uns ist dies aber erst mal uninteressant. Zunächst sollten wir unser OS mal auf den aktuellsten Stan bringen. Dazu geben wir folgende Befehle nacheinander ein:

apt-get update
apt-get upgrade
reboot

dies kann durchaus einige Zeit dauern. Nach reboot bootet das RPI neu und man muss sich auch neu mit Putty verbinden! Beachtet das nach reboot das RPI durchaus bis zu 30 Sekunden brauchen kann, bis es wieder gebootet hat. In dieser Zeit ist kein Verbinden möglich, nicht Nervös werden ;)

Jetzt installieren wir noch Apache und PHP:

apt-get install apache2
apt-get install php (evtl. muss auch apt-get install php5 eingegeben werden, bin mir jetzt nicht sicher, falls wer Infos hat was richtig ist bitte melden!)

Wenn dies abgeschlossen ist, können wir im Browser (Firefox, Internet Explorer, etc) am PC mal http://ip_des_raspberry_pi eingeben, in meinen Fall http://192.168.0.133 . Hier sollte nun ein Testseite von Apache erscheinen.

Um Dateien auf das RPI zu kopieren nutze ich WinSCP und spare mir so einen ftp Server auf dem RPI und kopiere die Files direkt per SSH. Das Programm sollte relativ selbsterklärend sein. Falls Fragen dazu entstehen, beschreibe ich es gerne später hier einmal.

Wir öffnen nun auf unseren PC Notepad und schreiben in die Datei unseren ersten Test PHP Code:

Code: Alles auswählen
<?php
echo phpinfo();
?>


dies speichern wir als test.php (achtet darauf das kein .txt mehr hinten dran ist!) ab und kopieren es mit WINSCP auf das RPI in das Verzeichnis /var/www/

Wenn wir nun auf dem PC http://ip_des_raspberry_pi/test.php aufrufen, sollte eine Testseite von PHP erscheinen und wir können nun sicher sagen, das auch php läuft.

Damit ist unser RPI fertig und wir können uns dem nächsten Schritt annehmen. Wir schließen den ersten 1wire Temperatursensor (DS1820 oder DS18b20) an. Dies beschreibe ich dann im nächsten Beitrag.

mfg

Christian
Zuletzt geändert von Christian am 22.04.2014 19:33, insgesamt 3-mal geändert.
Benutzeravatar
Christian
-
-
 
Beiträge: 1773
Registriert: 20.07.2013 12:12
Wohnort: 90768 Fürth
Hat sich bedankt: 163 mal
erhaltene Bedankungen: 163 mal
AIPD: Zu meinem Fischbesatz

Re: Aquariumcomputer Marke Eigenbau mit Raspberry Pi

Beitragvon Christian » 10.05.2014 10:57

Hallo

so endlich kam ich mal wieder dazu, bisschen was zu schreiben. Heute zeig ich, wie man die DS18(b)20 Temperatursensoren am Raspberry Pi anschließt und in Betrieb nimmt. Da die Art des Anschlusses je nach Breakoutboard etwas unterschiedlich ist, zeig ich nur einen Schaltplan, der Anschluss ist relativ simpel man braucht nur einen 4,7kOhm Widerstand, um das Signal auf VCC zu ziehen. Im Test hab ich anfangs wegen Mangel eines 4,7kOhm Widerstandes einen 10kOhm verwendet, welcher mit 2 Sensoren auch noch funktioniert hat. Bei mehr Sensoren war er dann zu groß und ich hab einfach einen 2. 10kOhm pararell geschaltet. Man sieht also, der Wert muss nicht exakt eingehalten werden. Anschließen bitte nur bei ausgeschalteten Raspberry Pi um es nicht zu beschädigen.

Auch verwende ich für die Sensoren nicht die parasitäre Stromversorgung. Ich schließe die Sensoren also mit 3 Leiter an und nicht mit 2 was durchaus möglich wäre. Der Grund ist ganz einfach, als ich anfangs aus faulheit die parasitäre Stromversorgung verwendet habe, sind mir immer einzelne Sensoren ausgestiegen und haben Fehlmessungen produziert. Seit ich nun die Sensoren direkt mit Strom versorge, klappt es deutlich besser :)

So genug geredet, hier kommt mein Paint-Schaltplant ;)



- Jeder VDD Eingang des Sensors wird auf 3,3V des Raspberry Pi gelegt
- Jeder GND Eingang des Sensors wird auf GND des Raspberry Pi gelegt
- Der 4,7kOhm Widerstand verbindet den Eingang 7 mit VCC des Raspberry Pi
- Jede DQ (Datenleitung) des Sensors wird mit Eingang 7 des Raspberry Pi verbunden

mehr muss auf der elektrischen Seite nicht gemacht werden. Die Reihe der Sensoren kann theoretisch unendlich erweitert werden maximal auf 100 Sensoren erweitert werden was wohl auch techn. im Bereich des machbaren liegt. in der Praxis bricht der Bus aber ab so ca. 10 Sensoren zusammen, getestet habe ich es noch nicht ;)

Jetzt können wir das Raspberry Pi wieder einschalten und warten bis es gestartet ist. Der Zugriff auf die Temperaturen ist nun relativ einfach.

Zuerst aktivieren wir den 1wire Treiber:

sudo modprobe w1-gpio pullup=1
sudo modprobe w1-therm

diese 2 Befehle nacheinander eingeben, wenn man schon als root eingeloggt ist, kann man sich das sudo sparen ;)

die Sensoren sind nun unter /sys/bus/w1/devices zu finden, wir geben also ein:

cd /sys/bus/w1/devices
ls

und es sollten nun Ordner zu sehen sein, die etwa so aussehen (jeder Sensor hat seinen eigenen Ordner):
28-000005ac7cc3 oder 10-0008025b951a
die ersten 2 Ziffern zeigen an, was für ein Sensor es ist (DS1820 und DS18b20 haben z.b. andere Codes), alles nach den Bindestrich gibt den einzigartigen Code des Sensors an. In meinen Beispiel mit 5 Sensoren sieht es also so aus (bei mir lief das Raspberry Pi schon, und ich musste dann natürlich die 2 Befehle zum Treiber aktivieren nicht eingeben, dies muss man nur nach jedem Neustart des Raspberry Pi. Wie man sich das ersparen kann, zeig ich später!):



wie man sieht, hab ich ds18b20 und ds1820 Sensoren gemischt, was ebenfalls kein Problem ist. Dies hat hier keinen weiteren Grund und liegt nur daran, das in meiner Kraffelkiste wohl 2 verschiedene Sensoren drinnen lagen ;)

So nun wollen wir die Temperatur eines Sensors auslesen. Dazu "öffnen" wir den Ordner des Sensors:

cd 28-000005acd689 (Die Zahlenkombination passen wir natürlich an unseren Sensor an!)
cat w1_slave

es folgt nun eine Ausgabe die etwa so aussieht:

Code: Alles auswählen
4d 01 4b 46 7f ff 03 10 d8 : crc=d8 YES
4d 01 4b 46 7f ff 03 10 d8 t=20812


hinter crc=d8 steht YES, dies bedeutet, das die Übertragung funktioniert hat und der Temperaturwert richtig ist. In der letzten Zeile finden wir t=20812 was nun unsere Temperatur ist. Wir müssen den Wert nun durch 1000 teilen und haben unsere Temperatur in °C also in diesem Fall 20,812. Der Rest sind die Rohdaten und für uns uninteressant, da das Raspberry Pi daraus ja schon die Temperatur gemacht hat ;)

Das ganze sieht dann etwa so aus:



auch wenn es nun den anschein hat, die Sensoren wären auf das tausendstel Grad genau, ist dies natürlich nicht richtig. Im Datenblatt sind die Sensoren mit +-0,5°C Toleranz angegeben. In meinen Fall kann man also "nur" sagen, die Temperatur liegt zwischen 20,312 und 21,312. Genauer geht es rein technisch nicht. Für meine Zwecke ist das aber locker ausreichend.

So jetzt haben wir also die Temperatursensoren ausgelesen. Im nächsten Schritt fangen wir dann damit an, die Daten in ein PHP Script einzulesen und ein Bild zu bauen damit man auch so eine schöne Ausgabe hat, wie ich oben. Aktuell ist es ja noch sehr umständlich die Temperatur auszulesen.

mfg

Christian
Zuletzt geändert von Christian am 11.06.2014 22:10, insgesamt 5-mal geändert.
Benutzeravatar
Christian
-
-
 
Beiträge: 1773
Registriert: 20.07.2013 12:12
Wohnort: 90768 Fürth
Hat sich bedankt: 163 mal
erhaltene Bedankungen: 163 mal
AIPD: Zu meinem Fischbesatz

Re: Aquariumcomputer Marke Eigenbau mit Raspberry Pi

Beitragvon Christian » 10.05.2014 17:50

hi

hier poste ich mal den aktuell laufenden Quellcode, welcher folgendes Bild generiert. Beachtet bitte, das der Quellcode noch relativ zusammengebastelt ist und auch nichts optimiert oder gecached wird, weshalb das Bild relativ langsam läd:

Bild

Auf dem Raspberry Pi liegt eine index.php im Homeverzeichnis des http Servers /var/www/

Code: Alles auswählen
<?php
echo "Temp1:<br>";
echo system("cat /sys/bus/w1/devices/10-0008025b951a/w1_slave"); //oben mitte
sleep(1);
echo "<br>";
echo "Temp1:<br>";
echo system("cat /sys/bus/w1/devices/10-0008025b9794/w1_slave"); //mitte links
sleep(1);
echo "<br>";
echo "Temp1:<br>";
echo system("cat /sys/bus/w1/devices/28-000005ac7cc3/w1_slave"); //mitte rechts
sleep(1);
echo "<br>";
echo "Temp1:<br>";
echo system("cat /sys/bus/w1/devices/28-000005acd689/w1_slave"); //unten links
sleep(1);
echo "<br>";
echo "Temp1:<br>";
echo system("cat /sys/bus/w1/devices/28-000005ad4044/w1_slave"); //unten rechts
sleep(1);
?>

hiermit werden alle Sensoren abgefragt und ausgegeben, natürlich müssen hier auch die Sensorids wieder angepasst werden. Die Ausgabe sieht dann so aus:

Code: Alles auswählen
Temp1:
37 00 ff bf ff ff 04 10 c5 : crc=c5 YES 37 00 ff bf ff ff 04 10 c5 t=27500 37 00 ff bf ff ff 04 10 c5 t=27500
Temp1:
38 00 4c 53 ff ff 0e 10 7d : crc=7d YES 38 00 4c 53 ff ff 0e 10 7d t=27875 38 00 4c 53 ff ff 0e 10 7d t=27875
Temp1:
5d 01 4b 46 7f ff 03 10 8c : crc=8c YES 5d 01 4b 46 7f ff 03 10 8c t=21812 5d 01 4b 46 7f ff 03 10 8c t=21812
Temp1:
4a 01 4b 46 7f ff 06 10 f7 : crc=f7 YES 4a 01 4b 46 7f ff 06 10 f7 t=20625 4a 01 4b 46 7f ff 06 10 f7 t=20625
Temp1:
74 01 4b 46 7f ff 0c 10 55 : crc=55 YES 74 01 4b 46 7f ff 0c 10 55 t=23250 74 01 4b 46 7f ff 0c 10 55 t=23250


Ausgegeben wird diese dann auf http://ip_des_raspberry_pi/index.php

jetzt haben wir schon mal alle Temperaturen auf einen Blick im Browser ohne jedes mal umständlich per ssh auf das Raspberry Pi verbinden zu müssen.

Das Bild, welches ihr oben seht, wird dann mit einen weiteren PHP Script auf meinen VServer generiert. Das Raspberry Pi ist durchaus schnell genug um auch diese Aufgabe zu übernehmen. Es muss nur die Bibliothek gdlib installiert werden. Das Script sieht so aus:

Code: Alles auswählen
<?php
//Daten einlesen
$url = "http://ip_des_raspberry_pi/index.php"; //hier die IP des Raspberry Pi anpassen.
$datei = fopen($url, "rb");
$inhalt = stream_get_contents($datei);
fclose($datei);



//erster t= suchen
$blu = strpos($inhalt, "t=")+2;
$anfang_weg = substr($inhalt, $blu);
$restleng = strlen($anfang_weg);
$temp1 = round((substr($anfang_weg, 0,5)/1000)*2)/2; //HIER IST DIE ERSTE TEMPERATUR GERUNDET!!
//Bis Temp1: suchen
$blu = strpos($anfang_weg, "Temp1:")+6;
$anfang_weg = substr($anfang_weg, $blu);
//wieder bis t= suchen
$blu = strpos($anfang_weg, "t=")+2;
$anfang_weg = substr($anfang_weg, $blu);
$restleng = strlen($anfang_weg);
$temp2 = round((substr($anfang_weg, 0,5)/1000)*2)/2; //HIER IST DIE ZWEITE TEMPERATUR GERUNDET!!
//Bis Temp1: suchen
$blu = strpos($anfang_weg, "Temp1:")+6;
$anfang_weg = substr($anfang_weg, $blu);
//wieder bis t= suchen
$blu = strpos($anfang_weg, "t=")+2;
$anfang_weg = substr($anfang_weg, $blu);
$restleng = strlen($anfang_weg);
$temp3 = round((substr($anfang_weg, 0,5)/1000)*2)/2; //HIER IST DIE DRITTE TEMPERATUR GERUNDET!!
//Bis Temp1: suchen
$blu = strpos($anfang_weg, "Temp1:")+6;
$anfang_weg = substr($anfang_weg, $blu);
//wieder bis t= suchen
$blu = strpos($anfang_weg, "t=")+2;
$anfang_weg = substr($anfang_weg, $blu);
$restleng = strlen($anfang_weg);
$temp4 = round((substr($anfang_weg, 0,5)/1000)*2)/2; //HIER IST DIE VIERTE TEMPERATUR GERUNDET!!
//Bis Temp1: suchen
$blu = strpos($anfang_weg, "Temp1:")+6;
$anfang_weg = substr($anfang_weg, $blu);
//wieder bis t= suchen
$blu = strpos($anfang_weg, "t=")+2;
$anfang_weg = substr($anfang_weg, $blu);
$restleng = strlen($anfang_weg);
$temp5 = round((substr($anfang_weg, 0,5)/1000)*2)/2; //HIER IST DIE FÜNFTE TEMPERATUR GERUNDET!!

//Raumtemp + Luftdruck lesen!
$url = "http://ip_des_raspberry_pi/test.html";
$datei = fopen($url, "rb");
$inhalt = stream_get_contents($datei);
fclose($datei);

$anfang_weg = substr($inhalt, 13);
$raumtemp = substr($anfang_weg, 0,4); //HIER STEHT DIE RAUMTEMP
$blu = strpos($anfang_weg, "Pressure:")+9;
$anfang_weg = substr($anfang_weg, $blu);

$luftdruck1 = ltrim(substr($anfang_weg, 0, 7)); //HIER STEHT DER LUFTDRUCK




   Header ("Content-type: image/jpeg");
   $img_handle = imageCreateFromJPEG("bg.jpg");
   
   $schwarz = ImageColorAllocate ($img_handle, 0,0,0);
   $weiss = ImageColorAllocate ($img_handle, 255,255,255);
   
   //Luftdruck und Raumtemp zeichnen
   imagefilledrectangle ($img_handle, 320 , 10 , 480 , 70 , $weiss ); 
   $gross = "3";        // Schriftgröße
   $randl = "330";        // Ausrichtung von Links
   $rando = "20";        // Ausrichtung von Obén
   $t1 = "Raumtemp.: $raumtemp °C";            // Text der Angezeigt werden soll
   $t2 = "Luftdruck: $luftdruck1 hPa";            // Text der Angezeigt werden soll
   ImageString ($img_handle, $gross, $randl, $rando, $t1, $schwarz);
   ImageString ($img_handle, $gross, $randl, $rando+15, $t2, $schwarz);
    
   //Becken oben Daten zeichnen 
   imagefilledrectangle ($img_handle, 20 , 50 , 180 , 110 , $weiss ); 
   $gross = "3";        // Schriftgröße
   $randl = "30";        // Ausrichtung von Links
   $rando = "60";        // Ausrichtung von Obén
   $t1 = "Temperatur: $temp1 °C";            // Text der Angezeigt werden soll
   $t2 = "PH-Wert: NoData";            // Text der Angezeigt werden soll
   $t3 = "Leitwert: NoData";            // Text der Angezeigt werden soll
   ImageString ($img_handle, $gross, $randl, $rando, $t1, $schwarz);
   ImageString ($img_handle, $gross, $randl, $rando+15, $t2, $schwarz);
   ImageString ($img_handle, $gross, $randl, $rando+30, $t3, $schwarz);
   
   //Becken mitte links Daten zeichnen 
   imagefilledrectangle ($img_handle, 20 , 340 , 180 , 400 , $weiss ); 
   $gross = "3";        // Schriftgröße
   $randl = "30";        // Ausrichtung von Links
   $rando = "350";        // Ausrichtung von Obén
   $t1 = "Temperatur: $temp2 °C";            // Text der Angezeigt werden soll
   $t2 = "PH-Wert: NoData";            // Text der Angezeigt werden soll
   $t3 = "Leitwert: NoData";            // Text der Angezeigt werden soll
   ImageString ($img_handle, $gross, $randl, $rando, $t1, $schwarz);
   ImageString ($img_handle, $gross, $randl, $rando+15, $t2, $schwarz);
   ImageString ($img_handle, $gross, $randl, $rando+30, $t3, $schwarz);
   
   //Becken mitte rechts Daten zeichnen 
   imagefilledrectangle ($img_handle, 320 , 340 , 480 , 400 , $weiss ); 
   $gross = "3";        // Schriftgröße
   $randl = "330";        // Ausrichtung von Links
   $rando = "350";        // Ausrichtung von Obén
   $t1 = "Temperatur: $temp3 °C";            // Text der Angezeigt werden soll
   $t2 = "PH-Wert: NoData";            // Text der Angezeigt werden soll
   $t3 = "Leitwert: NoData";            // Text der Angezeigt werden soll
   ImageString ($img_handle, $gross, $randl, $rando, $t1, $schwarz);
   ImageString ($img_handle, $gross, $randl, $rando+15, $t2, $schwarz);
   ImageString ($img_handle, $gross, $randl, $rando+30, $t3, $schwarz);
   
   
   //Becken unten links Daten zeichnen 
   imagefilledrectangle ($img_handle, 2 , 540 , 162 , 600 , $weiss ); 
   $gross = "3";        // Schriftgröße
   $randl = "12";        // Ausrichtung von Links
   $rando = "550";        // Ausrichtung von Obén
   $t1 = "Temperatur: $temp4 °C";            // Text der Angezeigt werden soll
   $t2 = "PH-Wert: NoData";            // Text der Angezeigt werden soll
   $t3 = "Leitwert: NoData";            // Text der Angezeigt werden soll
   ImageString ($img_handle, $gross, $randl, $rando, $t1, $schwarz);
   ImageString ($img_handle, $gross, $randl, $rando+15, $t2, $schwarz);
   ImageString ($img_handle, $gross, $randl, $rando+30, $t3, $schwarz);
   
   //Becken unten mitte Daten zeichnen 
   imagefilledrectangle ($img_handle, 165 , 540 , 325 , 600 , $weiss ); 
   $gross = "3";        // Schriftgröße
   $randl = "175";        // Ausrichtung von Links
   $rando = "550";        // Ausrichtung von Obén
   $t1 = "Temperatur: NoData";            // Text der Angezeigt werden soll
   $t2 = "PH-Wert: NoData";            // Text der Angezeigt werden soll
   $t3 = "Leitwert: NoData";            // Text der Angezeigt werden soll
   ImageString ($img_handle, $gross, $randl, $rando, $t1, $schwarz);
   ImageString ($img_handle, $gross, $randl, $rando+15, $t2, $schwarz);
   ImageString ($img_handle, $gross, $randl, $rando+30, $t3, $schwarz);
   
   //Becken unten rechts Daten zeichnen 
   imagefilledrectangle ($img_handle, 328 , 540 , 488 , 600 , $weiss ); 
   $gross = "3";        // Schriftgröße
   $randl = "340";        // Ausrichtung von Links
   $rando = "550";        // Ausrichtung von Obén
   $t1 = "Temperatur: $temp5 °C";            // Text der Angezeigt werden soll
   $t2 = "PH-Wert: NoData";            // Text der Angezeigt werden soll
   $t3 = "Leitwert: NoData";            // Text der Angezeigt werden soll
   ImageString ($img_handle, $gross, $randl, $rando, $t1, $schwarz);
   ImageString ($img_handle, $gross, $randl, $rando+15, $t2, $schwarz);
   ImageString ($img_handle, $gross, $randl, $rando+30, $t3, $schwarz);
   
   //Generiercode
   imagefilledrectangle ($img_handle, 260 , 710 , 500 , 750 , $weiss ); 
   $gross = "3";        // Schriftgröße
   $randl = "280";        // Ausrichtung von Links
   $rando = "720";        // Ausrichtung von Obén
   $t1 = "Christian Dresel";            // Text der Angezeigt werden soll
   $t2 = "http://www.aquaristikfreaks.de";            // Text der Angezeigt werden soll
   ImageString ($img_handle, $gross, $randl, $rando, $t1, $schwarz);
   ImageString ($img_handle, $gross, $randl, $rando+15, $t2, $schwarz);

    
   Imagejpeg ($img_handle);
   ImageDestroy ($img_handle); 


?>


In diesem Code ist auch schon die Ausgabe des Luftdrucks und der Raumtemperatur des BMP085 Sensors enthalten. Wie dieser angeschlosse und konfiguriert wird, zeige ich im nächsten Beitrag.

Der Code ist relativ umfangreich, wer sich mit php+gdlib nicht auskennt, wird sich durchaus schwer tun. Hier ist wirklich etwas wissen erforderlich. Das aufwendigste ist, dem Script zu sagen wo es welchen Text genau anzeigen soll. Daher die vielen Berechnungen.

mfg

Chris
Zuletzt geändert von Christian am 10.05.2014 18:04, insgesamt 2-mal geändert.
Benutzeravatar
Christian
-
-
 
Beiträge: 1773
Registriert: 20.07.2013 12:12
Wohnort: 90768 Fürth
Hat sich bedankt: 163 mal
erhaltene Bedankungen: 163 mal
AIPD: Zu meinem Fischbesatz

Re: Aquariumcomputer Marke Eigenbau mit Raspberry Pi

Beitragvon Christian » 23.06.2014 12:08

Hallo

so nun möchte ich mal kurz erklären, wie ich den Luftdruck und die Temperatur des BMP085 einlese. Angeschlossen wird der BMP085 am Raspberry Pi ganz einfach so (ich spar mir mal die Grafik, da hier kein Kunststück dahinter ist):

SDA des BMP085 an SDA0 des Raspberry Pi
SCL des BMP085 an SDL0 des Raspberry Pi
VIN des BMP085 an 3,3V des Raspberry Pi
GND des BMP085 an GND des Raspberry Pi
die anderen Pins bleiben unbelegt.

Danach starten wir das Raspberry Pi. Da wir nun 1wire und i²c (sowie evtl. später die Kamera) gleichzeitig nutzen wollen, müssten wir etwas tricksen, da der 1wire Treiber den i²c Treiber überschreibt. Dazu müssen wir ein paar Dateien am Raspberry Pi ändern. Durch diese Änderung muss auch nach dem Neustart des Raspberry Pi nicht mehr der 1wire Treiber neu geladen werden.

Zuerst allerdings müssen noch ein paar Pakete für den i2c installiert werden:

apt-get install python-smbus
apt-get install i2c-tools


damit werden die wichtigen i2c Pakete installiert.

Folgende 2 Dateien müssen danach so bearbeitet werden:

/etc/modprobe.d/raspi-blacklist.conf
# blacklist spi and i2c by default (many users don't need them)
blacklist spi-bcm2708
blacklist i2c-bcm2708

meist sind hier die 2 Treiber auskommentiert, (mit einer Raute vorstehend) dies muss entfernt werden.

/etc/modules
w1-therm
w1-gpio pullup=1
i2c-dev
i2c-bcm2708
spi-bcm2708
snd-bcm2835

die Reihenfolge muss zwingend eingehalten werden! Zuerst den 1wire laden, danach i2c.

Wenn wir nun das Raspberry Pi neu booten, sollten der 1wire (die Temperaturfühler) direkt wieder funktionieren ohne den Treiber per Hand zu laden (dies darf nicht mehr geschehen, da sonst wieder der i2c Treiber überschrieben wird!)

Anschließend sollten wir mit dem Komando:

i2cdetect -y 1

folgende Ausgabe erhalten:

root@raspberrypi:~# i2cdetect -y 1
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- 77
root@raspberrypi:~#


Hier sehen wir auf Adresse 77 den BMP085, das heißt das Raspberry Pi kommuniziert schon mal mit dem BMP085.

Da zum auslesen der Temperatur und des Luftdruckes einige komplizierte Berechnungen erfolgen müssen, hab ich mir die Arbeit erspart und das fertige Pythontool Adafruit-Raspberry-Pi-Python-Code verwendet.

Dieses Tool kan sehr leicht mehr Git-Hub installiert werden:

git clone https://github.com/adafruit/Adafruit-Ra ... n-Code.git
cd Adafruit-Raspberry-Pi-Python-Code/Adafruit_BMP085
./Adafruit_BMP085_example.py

und schon sollten wir als Ausgabe die Raumtemperatur und den Luftdruck sehen. Die angebene Höhe ü. NN (normal null). (Altitude) ist hinfällig da wir sie nicht konfiguriert haben, wir werden dies auch nicht nutzen. Der angegeben Luftdruck ist nicht auf NN bezogen sondern der wirkliche Luftdruck auf der aktuellen Höhe.

Damit wir uns die Daten im Browser am PC angucken können, müssen wir einen kleinen Umweg gehen:

Wir legen uns ein kleines Bashscript an, das die genannten Werte in eine Datei ins www Verzeichnis des Raspberry Pi schreibt:

/root/test.sh
#/bin/bash
/root/Adafruit-Raspberry-Pi-Python-Code/Adafruit_BMP085/Adafruit_BMP085_example.py


diese Datei machen wir nun ausführbar:
chmod +x /root/test.sh


wenn wir die Datei nun ausführen sollten wir direkt wieder den Luftdruck sehen. Nun legen wir einen Cronjob an, der 1x pro Minute diese Daten in eine Datei ins www Verzeichnis des Raspberry Pi schreibt:

crontab -e
* * * * * /root/test.sh > /var/www/test.html


Wenn wir nun (1 Minute warten, bis der Cron das 1. mal lief ;)) http://ip_des_raspberry_pi/test.html am Computer aufrufen, sollten wir die Ausgabe von oben nun im Webbrowser sehen. Durch den Cronjob wird die Datei minütlich mit den aktuellen Werten gefüttert.
Das ganze sollte dann etwa so aussehen: http://chrisi01.no-ip.org/test.html (wie schon gesagt, der Altitue Wert ist hinfällig und darf nicht beachtet werden!)

mfg

Christian
Zuletzt geändert von Christian am 23.06.2014 12:10, insgesamt 2-mal geändert.
Benutzeravatar
Christian
-
-
 
Beiträge: 1773
Registriert: 20.07.2013 12:12
Wohnort: 90768 Fürth
Hat sich bedankt: 163 mal
erhaltene Bedankungen: 163 mal
AIPD: Zu meinem Fischbesatz


Zurück zu Technik

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 1 Gast

cron
<