Projekt Raspberry PI rev. B als Temparaturlogger für 32 oder mehr Sensoren und Webserver

Hallo,

noch ein paar nützliche Sachen:

Wer mit dem Raspi mehr Speicherplatz für Daten braucht, kommt um eine externe USB Festplatte nicht drumherum.
Die USB Festplatte muss eine eigene Stromversorgung haben, oder über einen USB Hub mit eigener Stromversorgung angeschlossen werden.
Die Spannung über den Raspi zu beziehen ist nicht ratsam und kann zu den verschiedesten Problemen führen.

Im Normalfall hat die erste USB Festplatte die Bezeichnung sda und Partitionen sda1, sda2 usw.
Als erstes sollte die Platte eingerichtet werden, ACHTUNG alle Daten auf dieser Festplatte werden gelöscht!!!!!
Ich habe 2 Partitionen eingerichtet, eine Swap(2GB)- und eine Nutzpartition (rest).
Festplatte partitionieren
sudo cfdisk
Danach muss die Festplatte noch formatiert werden, dies mit ext4 Filesystem Partition 2.
mkfs.ext4 /dev/sda2
Jetzt muss die Platte noch "eingehängt" werden.
Dazu einen "Mountpoint" angeben, also ein Verzeichnis wo die Platte zu finden ist.
Üblich ist das Verzeichnis /media
Ein Verzeichnis unter /media anlegen
sudo mkdir /media/usbplatte
und jetzt die Platte/Partition unter /media/usbplatte verfügbar machen
mount /dev/sda2 /media/usbplatte
Jetzt ist die Festplatte bis zum nächsten booten verfügbar
Mit Einstellungen in der fstab machen wir die Platte jetzt auch nach einem Neustart des PI automatisch verfügbar.
sudo nano /etc/fstab
/dev/sda2 /media/usbplatte ext4 rw 0 0
mit STRG + O Änderungen speichern, nächste Abfrage Enter und mit STRG + X Nano verlassen

Jetzt, wo wir genug Speicherplatz haben, können wir auch unsere MySQL Datenbank teilweise auf die USB Festplatte auslagern.
Zuerst MySQL stoppen
sudo /etc/init.d/mysql stop
Nun das MySQL Verzeichnis mit den Datenbanken auf die externe Platee kopieren, auch die Berechtigungen müssen kopiert werden, deshalb wird cpio verwendet.
cd /var/lib
sudo find mysql | sudo cpio -pdmv /media/usbplatte
Wir müssen MySQL noch mitteilen, das wir ein neues Datenbankverzeichnis haben.
sudo nano /etc/mysql/my.cnf
Hier die Zeile -> datadir suchen und das vorhandene Verzeichnis /var/lib/mysql ersetzen durch
/media/usbplatte/mysql
mit STRG + O Änderungen speichern, nächste Abfrage Enter und mit STRG + X Nano verlassen
MySQL Datenbank wieder starten
sudo /etc/init.d/mysql start
Ab jetzt werden alle neu angelegten Datenbanken auf die USB Festplatte geschrieben.

Hallo,

jetzt nach längerer Pause, werde ich mich wieder meinem Projekt widmen.

Was mir beim Raspberry PI gefehlt hat, war die Möglichkeit analoge Sensoren anzuschliessen. Dafür habe ich jetzt die Lösung gefunden.

Von der Firma AB Electronics in Großbritanien gibt es ein 8 Kanal Analog Modul, dass Spannungen von 0V - 5V in ein digitales Signal wandeln kann, und das mit einer brauchbaren Auflösung von bis zu 17 Bit.

Da habe ich mir für umgerechnet 62€ inkl. Versand 2 Module bestellt. Die Module waren innerbalb einer Woche da.

Hier mal ein paar Bilder hierzu:

Das Modul:

Der Raspberry PI Model B:

https://www.holzheizer-forum.d…Raspi-PI-B-mit-ADC-Modul/

Hier mit dem ADC Modul:

Die Belegung des GPIO Pins der Raspberry PI Modell B:

Raspberry PI B mit Hutschienensystem (das ADC Modul passt gut mit hinein):

https://www.holzheizer-forum.de/gallery/index.php/Image/291-Raspi-PI-B-im-Hutschienengehäuse/

Somit ist es Möglich mit dem Raspi PI eine Komplettlösung als Heizungssteuerung ohne zusätzliche Steuermodule zu nutzen. Ebenfalls gibt es Relaisplatinen (8 Relais Karte ca. 10€) zu Kaufen, um Ventile und Pumpen zu steuern. Für die Digitalen Sensoren gibt es auch 1-Wire Aufsteckmodule oder 1-Wire USB Module. Ebenfalls ist es möglich den Raspberry als Impulszähler für Volumenstromgeber zu nutzen (PI als Volkszähler suchen).

Alles in allem kann man für rund 150€ eine völlig frei programmierbare Steuerung zu bauen. Aber es gibt auch einen großen Nachteil. Die Programmierung muss in einer "Hochsprache" wie C, C++, oder Python erfolgen. dafür gibt es aber auch unzählige Anleitungen dafür im Internet.

Zur Einrichtung später mehr.

Hallo,

dieser Raspberry soll uns die ganzen Heizungsdaten zur Verfügung stellen und die erfassten Messwerte in eine externe MySQL Datenbank jede Minute eintragen:
Eine Steuerung der Pumpen erfolgt durch einen eigenen Auswerterechner. Somit entfällt hier die Ansteuerung der Relais.
Die benötigte Hardware:

- 1x Raspberry PI B mit 512 MB RAM, 8 GB SD Karte, Netzteil mit mind. 5V/2A
- 1x ADC PI Modul für 8 analoge Messstellen 0V - 5V
- 2x 1-Wire USB Module für die digitalen 1-Wire Temperatursensoren DS18B20
- 1x Gehäuse für den PI hier ein Hutschienengehäuse

Vorbereiten des PI:

- PI mit dem heimischen Netzwerk verbinden.
- Module am PI anbringen
- Mit dem Win32DiskImager (weiter vorn beschrieben) bringen wir das Linux Betriebssystem auf die SD Karte
- SD Karte in den PI stecken und den PI an die Stromversorgung anschließen.
- Der PI fährt nun hoch, zu sehen, an den blinkenden LEDs. Bleibt nur die rote LED an, stimmt was mit der SD Karte nicht.

Wir haben keinen Monitor an den PI angeschlossen! Wie finde ich nun den PI im Heimnetzwerk, und wie kann ich diesen Einstellen?

- Dafür muss ein freier DHCP Zugang für das Netzwerk (meist im Router) vorhanden sein. Wenn nicht, geht es nur wie weiter vorn beschrieben.
- Wir laden das Tool IPScan.exe aus den Internet herunter (Google Suche bemühen)
- Nun scannen wir damit unser Netzwerk in dem wir den IP Bereich oben wo die Nullen stehen durch unsere IP Adressbereich ersetzen. Bsp: 192.168.178.1 bis 192.168.178.254. Bei dem meisten Routern ist der DHCP Bereich zwischen 100 und 199 (letzte Zahl der IP Adresse) zu finden. Dort den Raspberry ausfindig machen. Ist vieleicht nicht einfach für den unerfahrenen Anwender, aber eine schöne Möglichkeit ohne Maus und Tastatur den PI einzustellen.
- Wenn wir den PI gefunden haben können wir mit Putty und der IP Adresse nun auf den Raspi zugreifen.
- Die Zugangsdaten sind: User -> pi <- und das Passwort -> raspberry <-

Ich gehe nun davon aus, das wir eine Verbindung mit Putty zum PI haben, und die Grundeinstellungen vornehmen:

Achtung!!! Alle eingaben von Ziffern und Sonderzeichen nur über die normale PC Tastatur vornehmen, nicht den Zahlenblock benutzen!

sudo raspi-config eingeben
Die Grundkonfigurationsmaske erscheint.
Alle Einstellungen vornehmen:
- 1 Expand Filesystem
- 2 Passwort des User PI ändern (wenn gewünscht, aber empfehlenswert)
- 3 Hier wird eingestellt, ob die grafische Benutzeroberfläche beim starten des PI geladen werden soll, brauchen wir nicht, also -> No <-
- 4 -> I1 und I2 einstellen. I1 -> de_DE.UTF-8 UTF-8 mit der Leertaste auswählen, OK, dann noch als Default auswählen (wichtig für die Datenbank!). Nun I2 -> Europa und dann Berlin auswählen
- Punkte 5-7 werden nicht benötig
- 8 A2, A4 und A7 -> A2 Hostname -> Hier gebe ich dem PI einen eigenen Namen, bei mir ist es -> Logger1 <-. A4 für den Zugriff auf den PI mit SSH (auch FTP) muss dies eingeschaltet sein. A7 alles -> Ja <-, um den I2C Kernel zu laden
- Die Grundkonfiguration ist nun abgeschlossen, den PI neu starten.

Jetzt geben wir dem PI eine feste IP Adresse und bringen diesen auf den aktuellen Softwarstand:

Einloggen mit der oben ermittelten IP Adresse und Putty
sudo nano /etc/network/interfaces
iface eth0 inet dhcp -> ersetzen durch -> iface eth0 inet static
hinzufügen:
address 192.168.178.33 <- Deine IP Adresse für den PI (diese darf im Heimnetzwerk noch nicht vergeben sein!)
netmask 255.255.255.0
gateway 192.168.178.1 <- Deine Router Adresse
Den PI neu starten
sudo reboot
Den PI auf den neusten Stand bringen:
sudo apt-get update -> Update der ganzen installierbaren Softwarepakete
sudo apt-get upgrade -> Update der Firmware
Den PI neu starten
sudo reboot

Nun richten wir die restliche benötigten treiber und die Software ein:
FTP Zugriff einrichten:
sudo apt-get install proftpd
Abfrage mit Y/J beantworten
Im jetzt geöffneten Fenster -> Servermodus <- wählen und dann OK
Virtuellen User einrichten
sudo nano /etc/proftpd/proftpd.conf
Am Ende der Datei folgendes einfügen:
DefaultRoot ~
AuthOrder mod_auth_file.c mod_auth_unix.c
AuthUserFile /etc/proftpd/ftpd.passwd
AuthPAM off
RequireValidShell off
mit STRG + O Änderungen speichern, nächste Abfrage Enter und mit STRG + X Nano verlassen
cd /etc/proftpd/
sudo ftpasswd --passwd --name raspiftp --uid 1000 --gid 1000 --home /home/pi --shell /bin/false
Jetzt das Passwort vergeben
Jetzt kann man mit dem User raspiftp mit einem FTP-Client auf den Raspi zugreifen
Braucht man Root-Rechte für FTP, muss dem User Root des PI ein Passwort zugewiesen werden (wir brauchen Root Rechte):
sudo su
passwd
Jetzt kann mit dem FTP Programm mit Root-Rechten per SFTP/SSH zugegriffen werden.

Für die digitalen 1-Wire Sensoren Installieren wir Digitemp, eine geniale Software dafür.
sudo apt-get install digitemp
Damit nicht immer Sudo aufgerufen werden muss, den User PI zur tty Gruppe hinzufügen
sudo usermod -G tty pi <- nur bis zum Neustart, dann muss wieder sudo davor
Da wir hier 2 1-Wire USB Module verwenden, und diese beim neustart des Raspi nicht immer dem selben USB Port zugewiesen werden, müssen wir in eine Trickkiste greifen, und den beiden Modulen einen Namen geben.
Dies machen wir mit den Linux UDEV Regeln.
ls -l /dev/ttyUSB* <- welche USB Ports sind belegt

dann sollte als Ausgabe sowas kommen..

Zitat

pi@Logger1 ~ $ ls -l /dev/ttyUSB*
crw-rw---T 1 root dialout 188, 0 Feb 15 08:14 /dev/ttyUSB0
crw-rw---T 1 root dialout 188, 1 Feb 15 08:13 /dev/ttyUSB1
pi@Logger1 ~ $

dann gebt Ihr ein :

udevadm info -n /dev/ttyUSB0 -a
in folgender Ausgabe sucht ihr nach der:
ATTRS{serial}=="DAE0011v" <- DAE0011v ist die Seriennummer des 1-Wire Modul an USB0

Für jedes weitere 1-Wire USB Modul wiederholen:
udevadm info -n /dev/ttyUSB1 -a
ATTRS{serial}=="DAE0011t"
Die Seriennummern notieren!

Jetzt tragen wir die Reglen ein:
cd /etc/udev/rules.d
sudo nano 10-1wire.rules
In dieser Datei schreibt Ihr jetzt folgendes:
SUBSYSTEMS=="usb", KERNEL=="ttyUSB*", ATTRS{serial}=="DAE0011v", SYMLINK+="usb1wire01"
SUBSYSTEMS=="usb", KERNEL=="ttyUSB*", ATTRS{serial}=="DAE0011t", SYMLINK+="usb1wire02"
mit STRG + O Änderungen speichern, nächste Abfrage Enter und mit STRG + X Nano verlassen
PI neu starten.
sudo reboot

Es kann nun kontrolliert werden, ob die Regeln funktionieren:
cd /dev
ls
und nun sollten die usb1wire01 und usb1wire02 angezeigt werden, die Module haben den Namen erhalten (nennt man Alias Namen)

digitemp.conf Dateien erzeugen (je 1-Wire USB eine eigene Datei) Ablage in /home/pi
sudo digitemp_DS9097U -i -s /dev/usb1wire01 -c /home/pi/digitemp0.conf
sudo digitemp_DS9097U -i -s /dev/usb1wire02 -c /home/pi/digitemp1.conf
Damit wir nicht unnötig Text bei den Abfragen der Sensoren ausgegeben wird bearbeite ich die digitemp0.conf dateien.
Damit bei der Ausgabe nur der Temperaturwert in °C angezeigt wird, bearbeiten wir noch die digitemp0.conf und digitemp1.conf
sudo nano /home/pi/digitemp0.conf
und ändern die Zeile ->
LOG_FORMAT "%b %d %H:%M:%S Sensor %s C: %.2C F: %.2F" in -> LOG_FORMAT "%.2C"
mit STRG + O Änderungen speichern, nächste Abfrage Enter und mit STRG + X Nano verlassen
sudo nano /home/pi/digitemp1.conf
und ändern die Zeile ->
LOG_FORMAT "%b %d %H:%M:%S Sensor %s C: %.2C F: %.2F" in -> LOG_FORMAT "%.2C"
mit STRG + O Änderungen speichern, nächste Abfrage Enter und mit STRG + X Nano verlassen
Damit haben wir schon mal die Digitalen Sensoren fertig für die Abfrage.

Jetzt zum ADC PI Modul für die analogen Sensoren:
Das analog Modul wurde die Kanäle 1-4 = I2C Addresse: 0x68 und Kanäle 5-8 = I2C Addresse: 0x69 (Auslieferungszustand) belassen.
Hier brauchen wir für die jeweilige Programmiersprache eine Bibliothek, wir verwenden Python, die Standartsprache des PI.
sudo apt-get install python-rpi.gpio <- ist eventuell schon installiert
und für den MySQL Datenbankzugriff noch:
sudo apt-get install python-mysqldb

Das war es erst mal mit der Einrichtung des PI

Als nächstes beschäftigen wir uns mit dem Testen der Mudule und Sensoren.

Hallo,

und weiter gehts.

Hier folgen noch weitere Grundeinstellungen zum Betreiben des ADC Pi Moduls am I2C Bus nötig sind:

sudo apt-get install i2c-tools -> I2C-Toolkit fuer die Kommandozeile
sudo apt-get install python-smbus -> Python-Bibliothek fuer I2C
sudo nano /etc/modprobe.d/raspi-blacklist.conf
folgendes so eintragen / ändern:
# blacklist spi and i2c by default (many users don't need them)
# blacklist spi-bcm2708
# blacklist i2c-bcm2708
mit STRG + O Änderungen speichern, nächste Abfrage Enter und mit STRG + X Nano verlassen
Damit die Module beim Neuszart des PI wieder mit geladen werden:
sudo nano /etc/modules
Ergänzen mit -> i2c-dev
mit STRG + O Änderungen speichern, nächste Abfrage Enter und mit STRG + X Nano verlassen
Die Module werden geladen mit:.
sudo modprobe i2c-bcm2708
sudo modprobe i2c_dev
Dies können wir mal testen:
lsmod
Die Ausgabe könnte so aussehen, wichtig sind die beiden rot markierten Module für uns:

Zitat

Module Size Used by
i2c_dev 5557 0
spi_bcm2708 4728 0
i2c_bcm2708 3997 0
snd_bcm2835 16165 0
snd_soc_bcm2708_i2s 5474 0
regmap_mmio 2806 1 snd_soc_bcm2708_i2s
snd_soc_core 131268 1 snd_soc_bcm2708_i2s
regmap_spi 1897 1 snd_soc_core
snd_pcm 81593 2 snd_bcm2835,snd_soc_core
snd_page_alloc 5156 1 snd_pcm
regmap_i2c 1645 1 snd_soc_core
snd_compress 8076 1 snd_soc_core
snd_seq 53769 0
snd_timer 20133 2 snd_pcm,snd_seq
snd_seq_device 6473 1 snd_seq
leds_gpio 2059 0
led_class 3688 1 leds_gpio
snd 61291 7 snd_bcm2835,snd_soc_core,snd_timer,snd_pcm,snd_seq,snd_seq_device,snd_compress

Alles anzeigen

und
ls -l /dev/i2c*
Sollte folgende Ausgabe erzeugen:

Zitat

crw-rw---T 1 root i2c 89, 1 Apr 7 14:05 /dev/i2c-1

Mit -> adduser pi i2c
geben wir dem User PI nun die Rechte ohne "sudo" auf den I2C Bus zuzugreifen.

Weiter geht es jetzt, da alle Grundeinstellungen für die Module des Raspi vorgenommen wurden mit der Programmierung in Python.

Hallo,

nun zur Python Programmierung:

Python ist eine "Zicke" in bezug auf Übersichtlichkeit!
Blöcke müssen strickt eingerück werden, sonst hagelt es Fehlermeldungen. Also bitte peniebelst darauf achten.

Für das ADC Pi Modul stellt uns die Fa. AB Electronic 2 Klassen in Python zu Verfügung:
ABE_ADCPi.py und ABE_helpers.py
Diese 3 Dateien, die HIER zu finden sind legen wir beim Pi in das Verzeichis /home/pi

Hier der Quellcode der ABE_ADCPi.py (Groß Kleinschreibung beachten!):

#!/usr/bin/python
"""
================================================
ABElectronics ADC Pi V2 8-Channel ADC
Version 1.0 Created 09/05/2014
Version 1.1 16/11/2014 updated code and functions to PEP8 format
Requires python smbus to be installed
================================================
"""
class ADCPi:
  # internal variables
  __address = 0x68 # default address for adc 1 on adc pi and delta-sigma pi
  __address2 = 0x69 # default address for adc 2 on adc pi and delta-sigma pi
  __config1 = 0x1C # PGAx1, 18 bit, one-shot conversion, channel 1
  __currentchannel1 = 1 # channel variable for adc 1
  __config2 = 0x1C # PGAx1, 18 bit, one-shot conversion, channel 1
  __currentchannel2 = 1 # channel variable for adc2
  __bitrate = 18 # current bitrate
  __pga = float(0.5) # current pga setting
  __lsb = float(0.0000078125) # default lsb value for 18 bit
  # create byte array and fill with initial values to define size
  __adcreading = bytearray()
  __adcreading.append(0x00)
  __adcreading.append(0x00)
  __adcreading.append(0x00)
  __adcreading.append(0x00)
  global _bus
  # local methods
  def __updatebyte(self, byte, bit, value):
    # internal method for setting the value of a single bit within a
    # byte
    if value == 0:
      return byte & ~(1 << bit)
    elif value == 1:
      return byte | (1 << bit)
  def __checkbit(self, byte, bit):
    # internal method for reading the value of a single bit within a
    # byte
    bitval = ((byte & (1 << bit)) != 0)
    if (bitval == 1):
      return True
    else:
      return False
  def __twos_comp(self, val, bits):
    if((val & (1 << (bits - 1))) != 0):
      val = val - (1 << bits)
    return val
  def __setchannel(self, channel):
    # internal method for updating the config to the selected channel
      if channel < 5:
        if channel != self.__currentchannel1:
          if channel == 1:
            self.__config1 = self.__updatebyte(self.__config1, 5, 0)
            self.__config1 = self.__updatebyte(self.__config1, 6, 0)
            self.__currentchannel1 = 1
          if channel == 2:
            self.__config1 = self.__updatebyte(self.__config1, 5, 1)
            self.__config1 = self.__updatebyte(self.__config1, 6, 0)
            self.__currentchannel1 = 2
          if channel == 3:
            self.__config1 = self.__updatebyte(self.__config1, 5, 0)
            self.__config1 = self.__updatebyte(self.__config1, 6, 1)
            self.__currentchannel1 = 3
          if channel == 4:
            self.__config1 = self.__updatebyte(self.__config1, 5, 1)
            self.__config1 = self.__updatebyte(self.__config1, 6, 1)
            self.__currentchannel1 = 4
      else:
        if channel != self.__currentchannel2:
          if channel == 5:
            self.__config2 = self.__updatebyte(self.__config2, 5, 0)
            self.__config2 = self.__updatebyte(self.__config2, 6, 0)
            self.__currentchannel2 = 5
          if channel == 6:
            self.__config2 = self.__updatebyte(self.__config2, 5, 1)
            self.__config2 = self.__updatebyte(self.__config2, 6, 0)
            self.__currentchannel2 = 6
          if channel == 7:
            self.__config2 = self.__updatebyte(self.__config2, 5, 0)
            self.__config2 = self.__updatebyte(self.__config2, 6, 1)
            self.__currentchannel2 = 7
          if channel == 8:
            self.__config2 = self.__updatebyte(self.__config2, 5, 1)
            self.__config2 = self.__updatebyte(self.__config2, 6, 1)
            self.__currentchannel2 = 8
      return
    # init object with i2caddress, default is 0x68, 0x69 for ADCoPi board
  def __init__(self, bus, address=0x68, address2=0x69, rate=18):
    self._bus = bus
    self.__address = address
    self.__address2 = address2
    self.setBitRate(rate)
  def read_voltage(self, channel):
    # returns the voltage from the selected adc channel - channels 1 to
    # 8
    raw = self.read_raw(channel)
    if (self.__signbit):
      return float(0.0) # returned a negative voltage so return 0
    else:
      voltage = float(
        (raw * (self.__lsb / self.__pga)) * 2.448579823702253)
      return float(voltage)
  def read_raw(self, channel):
    # reads the raw value from the selected adc channel - channels 1 to 8
    h = 0
    l = 0
    m = 0
    s = 0
    # get the config and i2c address for the selected channel
    self.__setchannel(channel)
    if (channel < 5):
      config = self.__config1
      address = self.__address
    else:
      config = self.__config2
      address = self.__address2
    # keep reading the adc data until the conversion result is ready
    while True:
        __adcreading = self._bus.read_i2c_block_data(address, config)
        if self.__bitrate == 18:
          h = __adcreading[0]
          m = __adcreading[1]
          l = __adcreading[2]
          s = __adcreading[3]
        else:
          h = __adcreading[0]
          m = __adcreading[1]
          s = __adcreading[2]
        if self.__checkbit(s, 7) == 0:
          break
    self.__signbit = False
    t = 0.0
    # extract the returned bytes and combine in the correct order
    if self.__bitrate == 18:
      t = ((h & 0b00000011) << 16) | (m << 8) | l
      self.__signbit = bool(self.__checkbit(t, 17))
      if self.__signbit:
        t = self.__updatebyte(t, 17, 0)
    if self.__bitrate == 16:
      t = (h << 8) | m
      self.__signbit = bool(self.__checkbit(t, 15))
      if self.__signbit:
        t = self.__updatebyte(t, 15, 0)
    if self.__bitrate == 14:
      t = ((h & 0b00111111) << 8) | m
      self.__signbit = self.__checkbit(t, 13)
      if self.__signbit:
        t = self.__updatebyte(t, 13, 0)
      if self.__bitrate == 12:
        t = ((h & 0b00001111) << 8) | m
        self.__signbit = self.__checkbit(t, 11)
        if self.__signbit:
          t = self.__updatebyte(t, 11, 0)
    return t
  def set_pga(self, gain):
    """
    PGA gain selection
    1 = 1x
    2 = 2x
    4 = 4x
    8 = 8x
    """
    if gain == 1:
      self.__config1 = self.__updatebyte(self.__config1, 0, 0)
      self.__config1 = self.__updatebyte(self.__config1, 1, 0)
      self.__config2 = self.__updatebyte(self.__config2, 0, 0)
      self.__config2 = self.__updatebyte(self.__config2, 1, 0)
      self.__pga = 0.5
    if gain == 2:
      self.__config1 = self.__updatebyte(self.__config1, 0, 1)
      self.__config1 = self.__updatebyte(self.__config1, 1, 0)
      self.__config2 = self.__updatebyte(self.__config2, 0, 1)
      self.__config2 = self.__updatebyte(self.__config2, 1, 0)
      self.__pga = 1
    if gain == 4:
      self.__config1 = self.__updatebyte(self.__config1, 0, 0)
      self.__config1 = self.__updatebyte(self.__config1, 1, 1)
      self.__config2 = self.__updatebyte(self.__config2, 0, 0)
      self.__config2 = self.__updatebyte(self.__config2, 1, 1)
      self.__pga = 2
    if gain == 8:
      self.__config1 = self.__updatebyte(self.__config1, 0, 1)
      self.__config1 = self.__updatebyte(self.__config1, 1, 1)
      self.__config2 = self.__updatebyte(self.__config2, 0, 1)
      self.__config2 = self.__updatebyte(self.__config2, 1, 1)
      self.__pga = 4
    self._bus.write_byte(self.__address, self.__config1)
    self._bus.write_byte(self.__address2, self.__config2)
    return
  def setBitRate(self, rate):
    """
    sample rate and resolution
    12 = 12 bit (240SPS max)
    14 = 14 bit (60SPS max)
    16 = 16 bit (15SPS max)
    18 = 18 bit (3.75SPS max)
    """
    if rate == 12:
      self.__config1 = self.__updatebyte(self.__config1, 2, 0)
      self.__config1 = self.__updatebyte(self.__config1, 3, 0)
      self.__config2 = self.__updatebyte(self.__config2, 2, 0)
      self.__config2 = self.__updatebyte(self.__config2, 3, 0)
      self.__bitrate = 12
      self.__lsb = 0.0005
    if rate == 14:
      self.__config1 = self.__updatebyte(self.__config1, 2, 1)
      self.__config1 = self.__updatebyte(self.__config1, 3, 0)
      self.__config2 = self.__updatebyte(self.__config2, 2, 1)
      self.__config2 = self.__updatebyte(self.__config2, 3, 0)
      self.__bitrate = 14
      self.__lsb = 0.000125
    if rate == 16:
      self.__config1 = self.__updatebyte(self.__config1, 2, 0)
      self.__config1 = self.__updatebyte(self.__config1, 3, 1)
      self.__config2 = self.__updatebyte(self.__config2, 2, 0)
      self.__config2 = self.__updatebyte(self.__config2, 3, 1)
      self.__bitrate = 16
      self.__lsb = 0.00003125
    if rate == 18:
      self.__config1 = self.__updatebyte(self.__config1, 2, 1)
      self.__config1 = self.__updatebyte(self.__config1, 3, 1)
      self.__config2 = self.__updatebyte(self.__config2, 2, 1)
      self.__config2 = self.__updatebyte(self.__config2, 3, 1)
      self.__bitrate = 18
      self.__lsb = 0.0000078125
    self._bus.write_byte(self.__address, self.__config1)
    self._bus.write_byte(self.__address2, self.__config2)
    return

Hier seht Ihr es was ich mit den Einrückungen oben gemeint habe.

Fortsetzung .....

.... Fortsetzung

Jetzt noch die ABE_helpers.py:

#!/usr/bin/python
try:
  import smbus
except ImportError:
  raise ImportError("python-smbus not found. Install with 'sudo apt-get install python-smbus'")
import re
"""
================================================
ABElectronics Python Helper Functions
Version 1.1 Created 20/01/2015
Python 2 only
Requires python 2 smbus to be installed with: sudo apt-get install python-smbus
This file contains functions to load puthon smbus into an instance variable.
The bus object can then be used by multiple devices without conflicts.
================================================
"""
class ABEHelpers:
  def get_smbus(self):
    # detect i2C port number and assign to i2c_bus
    i2c_bus = 0
    for line in open('/proc/cpuinfo').readlines():
      m = re.match('(.*?)\s*:\s*(.*)', line)
      if m:
        (name, value) = (m.group(1), m.group(2))
        if name == "Revision":
          if value[-4:] in ('0002', '0003'):
            i2c_bus = 0
          else:
            i2c_bus = 1
          break
    try:
      return smbus.SMBus(i2c_bus)
    except IOError:
      print ("Could not open the i2c bus.")
      print ("Please check that i2c is enabled and python-smbus and i2c-tools are installed.")
      print ("Visit https://www.abelectronics.co.uk/i2c-raspbian-wheezy/info.aspx for more information.")

Und jetzt noch ein Testprogramm für das ADC Pi Modul adctest.py:

#!/usr/bin/python
from ABE_ADCPi import ADCPi
from ABE_helpers import ABEHelpers
import time
import os
"""
================================================
ABElectronics ADC Pi 8-Channel ADC demo
Version 1.0 Created 09/05/2014
Version 1.1 16/11/2014 updated code and functions to PEP8 format
Requires python smbus to be installed
run with: python demo-read_voltage.py
================================================
Initialise the ADC device using the default addresses and sample rate,
change this value if you have changed the address selection jumpers
Sample rate can be 12,14, 16 or 18
"""
i2c_helper = ABEHelpers()
bus = i2c_helper.get_smbus()
adc = ADCPi(bus, 0x68, 0x69, 12)
while (True):
    # clear the console
    os.system('clear')
    # read from adc channels and print to screen
    print ("Channel 1: %02f" % adc.read_voltage(1))
    print ("Channel 2: %02f" % adc.read_voltage(2))
    print ("Channel 3: %02f" % adc.read_voltage(3))
    print ("Channel 4: %02f" % adc.read_voltage(4))
    print ("Channel 5: %02f" % adc.read_voltage(5))
    print ("Channel 6: %02f" % adc.read_voltage(6))
    print ("Channel 7: %02f" % adc.read_voltage(7))
    print ("Channel 8: %02f" % adc.read_voltage(8))
    # wait 0.5 seconds before reading the pins again
    time.sleep(0.5)

Auch dieses Programm in das /home/pi Verzeichnis legen.

Mit python adctest.py das Testprogramm aufrufen.

Die Ausgabe (abbrechen mit STRG-C

Zitat

Channel 1: 0.000000
Channel 2: 0.000000
Channel 3: 0.000000
Channel 4: 0.000000
Channel 5: 0.000000
Channel 6: 0.000000
Channel 7: 0.000000
Channel 8: 0.000000

Alles anzeigen

So, das war es erst mal, in Kürze, wenn meine Datenbank auf meinem Homeserver läuft mehr.

Hallo,

hier noch das Programm um die Daten von den 1Wire Modulen und dem Analog Modul auszulesen und auf der Standartausgabe (hier der Putty Bildschirm) auszugeben.

#!/usr/bin/python


# Datenlogger Heizung


from ABE_ADCPi import ADCPi
from ABE_helpers import ABEHelpers
import datetime
import time
import os


# Analoge Daten einlesen
i2c_helper = ABEHelpers()
bus = i2c_helper.get_smbus()
adc = ADCPi(bus, 0x68, 0x69, 12)


while (True):
  dbdatum=time.strftime("%Y-%m-%d")
  dbzeit=time.strftime("%H:%M:%S")
  # clear the console
  os.system('clear')
  # read from adc channels and print to screen
  print ("Channel 1: %01f" % adc.read_voltage(1))
  print ("Channel 2: %01f" % adc.read_voltage(2))
  print ("Channel 3: %01f" % adc.read_voltage(3))
  print ("Channel 4: %01f" % adc.read_voltage(4))
  print ("Channel 5: %01f" % adc.read_voltage(5))
  print ("Channel 6: %01f" % adc.read_voltage(6))
  print ("Channel 7: %01f" % adc.read_voltage(7))
  print ("Channel 8: %01f" % adc.read_voltage(8))
  # wait 0.5 seconds before reading the pins again
  # Digitale Sensoren einlesen
  ausgabe = os.popen("digitemp_DS9097U -t 0 -q -c /home/pi/digitemp0.conf")  
  daten2 = ausgabe.read()
  sensor_u0s0=daten2.strip()
  print "Modul 1 Sensor 1: "+dbdatum+","+dbzeit+" "+sensor_u0s0+" C"
  ausgabe = os.popen("digitemp_DS9097U -t 1 -q -c /home/pi/digitemp0.conf")  
  daten2 = ausgabe.read()
  sensor_u0s1=daten2.strip()
  print "Modul 1 Sensor 2: "+dbdatum+","+dbzeit+" "+sensor_u0s1+" C"
  ausgabe = os.popen("digitemp_DS9097U -t 0 -q -c /home/pi/digitemp1.conf")  
  daten2 = ausgabe.read()
  sensor_u1s0=daten2.strip()
  print "Modul 2 Sensor 1: "+dbdatum+","+dbzeit+" "+sensor_u1s0+" C"
  ausgabe = os.popen("digitemp_DS9097U -t 1 -q -c /home/pi/digitemp1.conf")  
  daten2 = ausgabe.read()
  sensor_u1s1=daten2.strip()
  print "Modul 2 Sensor 2: "+dbdatum+","+dbzeit+" "+sensor_u1s1+" C"
  ausgabe = os.popen("digitemp_DS9097U -t 2 -q -c /home/pi/digitemp1.conf")  
  daten2 = ausgabe.read()
  sensor_u1s2=daten2.strip()
  print "Modul 2 Sensor 3: "+dbdatum+","+dbzeit+" "+sensor_u1s2+" C"
  time.sleep(1.0)

Die Ausgabe:

Zitat

Channel 1: 0.000000
Channel 2: 0.000000
Channel 3: 0.000000
Channel 4: 0.000000
Channel 5: 0.000000
Channel 6: 0.000000
Channel 7: 0.000000
Channel 8: 0.000000
Modul 1 Sensor 1: 2015-02-19,10:51:52 17.31 C
Modul 1 Sensor 2: 2015-02-19,10:51:52 17.44 C
Modul 2 Sensor 1: 2015-02-19,10:51:52 17.50 C
Modul 2 Sensor 2: 2015-02-19,10:51:52 17.50 C
Modul 2 Sensor 3: 2015-02-19,10:51:52 17.44 C

Alles anzeigen

Hallo,

und weiter geht es.

Nachdem mir jetzt schon einige SD-Karten kaputt gegangen sind, habe ich mir andere von Intenso bestellt, die sind nicht ganz so anfällig. Die Karten gehen kaputt, oder es entsthen defekte Dateien, wenn der Raspberry während eines Schreibvorganges vom Strom getrennt wird. Ich scheine da immer genau den richtigen Moment erwischt zu haben .
Dadurch empfehle ich auf jeden Fall eine USV für den Raspi einzuplanen. Jedes mal musste ich den PI neu aufsetzen. Dies umgehe ich jetzt, in dem ich einen USB Stick an den PI anschliesse, und die Software soweit es geht auf den Stick auslagere. Das hat auch Vorteile:
- wird die SD Karte zerstört, braucht es nur eine minimale Grundinstallation, die Daten sind ja auf dem Stick
- der Stick kann ein Mehrfaches an Schreibzyklen verarbeiten, als eine SD Karte
- gute USB Sticks sind schneller als SD Karten

Das ganze hat mich ziemlich Zeit gekostet, dass richtige Vorgehen aus dem Internet rauszufiltern.

Hier beschreibe ich, wie der Raspberry mit dem USB Stick betrieben wird.

Mit dem Win32DiskImager.exe das Image auf die SD Karte und den USB Stick aufspielen.
Jetzt erst mal die SD Karte in den PI stecken, Stromversorgung anschliessen, und wie oben beschrieben mit IPScan den Raspi ausfindig machen, und mit Putty verbinden.
Mit raspi-config mind. die Punkte 1 und 3 ausführen. Bei 3 das 2te auswählen. Raspi noch nicht neu starten.
Folgende Pakete installieren:
sudo apt-get install gparted
sudo apt-get install tightvncserver
YES oder Ja zum fortsetzen
vncserver :1 -> eingeben
VNC Passwort setzen
Bei "view-only password" No/Nein
cd /home/pi
cd .config
mkdir autostart
cd autostart
sudo nano tightvnc.desktop
Folgende 5 Zeilen in den Editor eingeben:
[Desktop Entry]
Type=Application
Name=TightVNC
Exec=vncserver :1
StartupNotify=false
mit STRG + O Änderungen speichern, nächste Abfrage Enter und mit STRG + X Nano verlassen
Jetzt den USB Stick anstecken und den PI neu starten
sudo reboot
Mit VNC nun auf den PI einloggen.
Ihr seht nun den PI Desktop
Dort öffnet Ihr ein Terminal
In diesem Terminal gksudo gparted eingeben und ganz rechts (Pfeil nach unten) den USB Stick auswählen -> /dev/sda
Jetzt werden die Partitionen vom Stick angezeigt.
Für uns wichtig ist nur die /dev/sda2. Ist ein Schlüssel zu sehen, mit der rechten Maustaste auf /dev/sda2 klicken und "Aushängen" wählen. Der Schlüssel sollte nun weg sein.
Wenn der Schlüssel nicht zu sehen ist mit der rechen Maustaste auf /dev/sda2 klicken und "Größe ändern/Verschieben" wählen.
In dem Fenster dann die Partition vergrössern, normal den ganzen freien Platz nehmen. Auf "Größe ändern/Verschieben" klicken und dann auf "Ausführen". Je nach Größe des Stick dauert es ein paar Minuten.
Nun alle Fenster schliessen.
Den Raspi vom Strom trennen.
Nun brauchen wir einen Editor für unseren PC, nicht den Windowseigenen nehmen, damit können keine Linuxdateien verändert werden. Kostenlos ist für den PC Notepad+ zu Empfehlen.
Nun die SD Karte in den PC stecken und öffnen mit dem Notepad+ die Datei "cmdline.txt".
Es wird nun root=/dev/mmcblk0p2 ersetzt durch root=/dev/sda2 und speichern unsere Änderung.
Das gleiche machen wir mit dem USB Stick.
Den Stick und auch die SD Karte wieder in den Raspberry stecken und den PI an die Stromversorgung anschliessen.
War alles OK, startet der Raspi nun von der SD, und nach dem Start übernimmt der Stick die Arbeit.
Die SD Karte wir somit nur noch zum Booten verwendet.
Jetzt können die Einstellungen und Einrichtungen am PI fortgesetzt werden.
Die zuvor gemachten Einstellungen und installierte Pake sind nicht mehr verfügbar und müssen neu aufgespielt werden (gparted und vnc) . Bei raspi-config nicht mehr den Punkt 1 ausführen!

Hallo,

jetzt, kurz vor der Fertigstellung meines Raspberry Projektes noch mal einen Zwischenstand.

Inzwischen habe ich mir einen NAS Home Server von QNAP angeschaft. Der Vorteil eines Home Servers, ist der große und sichere Speicherplatz und das ich dort 4 Festplatten einbauen kann (habe ich auch gemacht). Die 4 Festplatten sind in einem RAID 5 Verbund zusammen geschaltet, so kann eine Festplatte kaputt gehen, und das NAS läuft ohne Datenverlust trotzdem weiter. Die defekte Festplatte wird dann einfach durch eine neue Festplatte ersetzt, und das NAS baut diese dann wieder auf.
Das schöne an diesem NAS ist der integrierte MySQL Datenbank Server und der Web Server. Somit brauche ich keinen zusätzlichen Windowsrechner laufen lassen. Die Aufgaben auch für die Heizungssteuerungsdaten übernimmt das NAS.

Die Heizungssteuerung mit meinem Raspberry in nun fast fertig. Die Grundfunktionen sind erstellt, die Komfortfunktionen müssen teilweise noch erstellt werden. Die Digitalen Sensoren sind angeschlossen, die Analogen nocht nicht. Die Sensoren sind aber noch nicht am Einbauplatz sondern liegen nur im Serverschrank.

Hier mal ein paar Bilder der Steueroberfläche.

Im letzten Bild habe ich mal einige Fehler erzeugt.

Hallo Volker,

Danke für die Rückmeldung!

Die analogen Sensoren sind:

2x PI1000 mit Messumwandler (Solarkollektor und D20P AGT)
1x Thermoelement (AGT Kaminofen das die AGT auch über 400°C steigt)
2x Drucksensor (TA mit analog Ausgang)
2x Durchflussmesser (TA mit analog Ausgang)
1x Einfache Spannungsmessung für die Leistungseinstellung der Solarpumpe

Ein NAS sich nur dafür anzuschaffen wäre herausgeschmissenes Geld. Das NAS ist auch gleichzeitig ein Video und Musik Speicher.

Zitat

Geht's um den Dauereinsatz und Stromsparen bei 24/7, gibt es auch hier alternative Lösungen, die einem "Kauf-NAS" überlegen
sind….

Welche sollten das sein?

Zitat

ABER: Datensicherheit geht anders. Wenn NAS, dann muss auch ein Backup sein..

Das ist klar! Von den wichtigen Daten macht man zusätzliche Sicherungen.

Hallo Volker,

die Sensoren bietet TA nicht mehr an, Wollen nur noch die DL-Bus Sachen für die UVR verkaufen, der Rest ist denen egal, suche auch schon nach Alternativen.

Die Durchflusssensoren sind VFS 2-40, die Drucksensoren sind RPS0-6 jeweil mit analogen Signalausgängen. Die anderen Sensorwandler habe ich bei LKM Electronic gekauft.

Hallo,

Danke für die Blumen!

Inzwischen sind es mahr als 3000 Zeilen Java Code

Hallo,

und herzlich Willkommen Winne im Holzheizer Forum.

MySQL, PHP, und PHPMyAdmin wie weiter vorn beschrieben auf den Raspberry aufspielen. Oder einen externen MySQL Server verwenden. Ohne Festplatte oder grossen USB Stick ist die Aufzeichnung nicht möglich, weil Du Dir die SD Karte schnell kaputt machen würdest. Python und die MySQL Anbindung muss auch installiert sein. Auch weiter vorn beschrieben.

Bei Linux immer auf die Groß- Kleinschreibung achten!

Mit PHPMyAdmin eine Datenbank in MySQL Anlegen: zB "Wetter" (in der Beispieldatei ist es heizung)

Unter der Datenbank Wetter eine Tabelle: zB "Wetterdaten" oder "Umwelt" anlegen (in der Beispieldatei ist es umwelt)
.
In dieser Tabelle dann folgende Felder Anlegen:

datumzeit, datum, zeit, rtemp, rrelf, rtp, atemp, arelf, atp, ldrucklokal, ldruckabs, prognose, windchill, windtemp, windboee, windkmh, windrichtung, regen

Jetzt noch den Pythoncode, den Du mit Crontab 1x in der Minute aufrufst:

#!/usr/bin/python


import os
import datetime
import time
import math
import MySQLdb
ausgabe = os.popen("te923con")  
daten2 = ausgabe.read()
daten2=daten2.strip()
daten=daten2.split(":")


dbdatum=time.strftime("%Y-%m-%d")
dbzeit=time.strftime("%H:%M:%S")


druckkorrektur = 1.023403176151918
labs = float(daten[13])*druckkorrektur


ai=7.45
bi=235
z1=(ai*float(daten[1]))/(bi+float(daten[1]))
es=6.1*math.exp(z1*2.3025851)
e0=es*float(daten[2])/100
z2=e0/6.1
z3=0.434292289*math.log(z2)
#dru1=e0*100
#dru1=floor(dru1)/100
tau1=(235*z3)/(7.45-z3)*100
rtp1=math.floor(tau1)/100;
#feu1=(216.7*e0)/(273.15+float(daten[1]))*100
#feu1=math.round(feu1)/100


ai=7.45
bi=235
z1=(ai*float(daten[3]))/(bi+float(daten[3]))
es=6.1*math.exp(z1*2.3025851)
e0=es*float(daten[4])/100
z2=e0/6.1
z3=0.434292289*math.log(z2)
#dru2=e0*100
#dru2=floor(dru2)/100
tau2=(235*z3)/(7.45-z3)*100
rtp2=math.floor(tau2)/100;
#feu2=(216.7*e0)/(273.15+float(daten[3]))*100
#feu2=math.round(feu2)/100


sqlinsert = ("INSERT IGNORE INTO `umwelt` (`datumzeit`, `datum`, `zeit`, `rtemp`, `rrelf`, `rtp`, `atemp`, `arelf`, `atp`, `ldrucklokal`, `ldruckabs`, `prognose`, `windchill`, `windtemp`, `windboee`, `windkmh`, `windrichtung`, `regen`) VALUES ("

      +"'"+daten[0]+"', "+"'"+dbdatum+"', "+"'"+dbzeit+"', "+"'"+daten[1]+"', "+"'"+daten[2]+"', "+"'"+str(rtp1)+"', "+"'"+daten[3]+"', "+"'"+daten[4]+"', "
      +"'"+str(rtp2)+"', "+"'"+daten[13]+"', "+"'"+str(labs)+"', "+"'"+daten[15]+"', "+"'"+daten[20]+"', "+"'"+daten[20]+"', "+"'"+daten[19]+"', "
      +"'"+daten[18]+"', "+"'"+daten[17]+"', "+"'"+daten[21]+"'"+")")


db = MySQLdb.connect("localhost", "root", "nexus", "heizung")
cursor = db.cursor() 
cursor.execute(sqlinsert)
db.commit()
db.close()

db = MySQLdb.connect("localhost", "root", "nexus", "heizung")
localhost = MySQL läuft auf dem Raspi, an sonsten die IP des MySQLServers
root = Dein MySQL Benutzer
nexus = Dein Passwort
heizung = Deine Datenbank

sqlinsert = ("INSERT IGNORE INTO `umwelt` (`datumzeit`, .....
umwelt = Deine Tabelle in Deiner Datenbank

Und schon sollten die Daten in der Datenbank abgelegt werden.