Schlagwort-Archive: HYT939

HYT939 und NTC an Matlab über Arduino

DSC_2311In den letzten Blogeinträgen habe ich mit dem Arduino einen NTC-Widerstand  über einen Spannungsteiler an den Analogeingang des Arduino-UNO angeschlossen und ihn als eigenständiges Programmchen am Arduino als Temperatursensor laufen lassen. Die aktuellen Messwerte wurden auf einem LC-Display angezeigt. Dann habe ich die selbe Hardware über die Matlab Software und das „Arduino for Matlab“-Package betrieben und mittels Matlabcode direkt den Temperaturverlauf geloggt. Im vorhergehenden Blog war dann ein kombinierter Temperatur und Luftfeuchtigkeitssensor (Type HYT939) an der Reihe, der über den I²C Bus am Arduino seine Daten lieferte und wieder am LCD ausgegeben hat.

In diesem Bericht kommt nun wieder Matlab ins Spiel. Hier habe ich versucht, beide Sensoren, den NTC am Analogeingang und den HYT am I²C Bus, gleichzeitig auszulesen. Das sollte über einen mehrere Minuten andauernden Zeitraum passieren, wobei die Messwerte gleich mitgeloggt werden, um sie danach in einem Vergleichsdiagramm zu plotten. Der Hardwareaufbau ist wieder ganz einfach. Der NTC ist in Serie mit einem 2k2 Widerstand geschaltet. Die Enden des Spannungsteilers gehen an die +5V Versorgung und GND und der Teilerpunkt wird an den A0 – Eingang des Arduino Uno angeschlossen. Der HYT bekommt ebenfalls seine 5V vom Arduino selbst und an A4 und A5 ist der I²C anzuschließen (genaue Pinbelegung s. vorgehenden Bericht). Jetzt fehlt noch das Matlab-Script. Es ist hier einzusehen:

 

 

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Beispielscript um mit ArduinoUno einen Temperaturverlauf aufzuzeichnen
% Sensoren an A0 (Spannungsteiler mit NTC) und HYT939 an I2C
% 03/2016 by I.Bihlo
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
a = arduino('com4','Uno','libraries','I2C')
analogpin=0; %Anschlusspin analog des UNO
analog=0; %Variable für den Analogwert festlegen
nn=600; %anzahl der messpunkte
addr='0x28'; %addresse für digitalsensor
bus=i2cdev(a, addr) %i2c object erzeugen
%ein paar konstanten für die weiteren berechnungen
r=2200; %Spannungsteilerwiderstand
rt=0; %das wird der errechnete widerstand des NTC
urt=0; %das wird der errechnete Spannungsabfall am NTC
% konstanten für berechnung der Temperatur aus NTC Widerstand
% B25=3977K
a1=3.354016E-03;
b1=3.2569850E-04;
c1=2.61013E-06;
d1=6.38309e-08;
rref=2200;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Lesen des I2C Bus
% Lesen eines Temperaturabhängigen Widerstandes am Analog Eingang A0
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for x=1:nn
%%%% Analog 
analog(x)=readVoltage(a, analogpin); %Liest den AnalogIn von A0 und gibt in Volt aus
urt(x)=5-analog(x); %spannungsabfall am NTC 
rt(x)=(r/analog(x))*urt(x); %widerstand des NTC
pause(0.5);
%%%%Digital
data = read(bus, 4); %4 byte von i2c auslsesen
pause(0.5);
%Rohdaten aus Puffer lesen und zusammenbauen
humrawh=dec2bin(data(1),8); %byte 1 auf 8bit festlegen in binär wandeln
humrawl=dec2bin(data(2),8); %byte 2 auf 8bit festlegen in binär wandeln
humrawall=strcat(humrawh,humrawl); % beide bins concentenaten
humraw=bin2dec(humrawall); % die ganze kette wieder in dec wandeln
%tempraw=uint16(data(3))*256+uint16(data(4));
temprawh=dec2bin(data(4),8);
temprawl=dec2bin(data(3),8);
temprawall=strcat(temprawl,temprawh);
temprawall=temprawall(1:14); %% die letzten beiden bits abschneiden
tempraw=bin2dec(temprawall);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Humidity berechnen lt. Datenblatt
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
hum(x)=double(100/(16384-1))*double(humraw);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Temperatur berechnen lt. Datenblatt
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
temp(x)=double(165/(16384-1))*double(tempraw)-40.0;
%berechung der analogtemperatur
rvsrref(x)=rt(x)/rref; 
tempa(x)=1/(a1+(b1*log(rvsrref(x)))+(c1*(log(rvsrref(x)^2)))+(d1*(log(rvsrref(x)^3))));
tempc(x)=tempa(x)-273.15 %Kelin in Celsius umrechnen
pause(1);
end
clear a;
time=1:nn;
%plotten der daten
figure(1);
subplot(2,1,1);
plot(time,tempc,'m');
grid on; hold on;
%plot(time,analog,'b');
%plot(time,rt/1000,'r');
%plot(time,urt,'g'); 
plot(time,temp,'g');
legend('Temperatur NTC[°C]','Temperatur HYT939 [°C]');
%legend('Analogspannung des ADC','Widerstand des NTC in kOhm','Spannung am NTC','Temperatur [°C]');
subplot(2,1,2);
plot(time,hum,'m');
grid on; hold on;
legend('Rel Luftfeuchtigkeit HYT939 [%RH]');
%ende

Nachdem der Code nun nach einigen Anpassungen läuft, habe ich beide Sensoren (wie am Titelbild zu sehen) nebeneinander angeordnet und vor Beginn der Messung mit Kältespray (Kälte75 von KontaktChemie) heruntergekühlt. Dann startete das Script und begann aufzuzeichnen. Im Ergebnis sollte der Verlauf der Erwärmung auf die Raumtemperatur zu sehen sein. Da die Kälte am Metallgehäuse des HYT sofort eine Schicht aus gefrorenem Kondensat bildet die langsam taut, erwartete ich mir einen Luftfeuchtigkeitswert im Bereich der Sättigung. (was dann auch deutlich im Plot zu sehen ist).

HYTvsNTC

Feuchtesensor am Arduino

DSC_2268In den letzten Blog-Einträgen habe ich mit Hilfe des Arduino Uno – Experimentierboards auf unterschiedliche Weise einen NTC-Widerstand zur Messung der Temperatur eingesetzt. Aus einem anderen Projekt habe ich auch noch einen Feuchte/Temperatursensor der Firma IST (Innovative Sensor Technologie) zur Verfügung, der mit einem Raspberry und in Python ausgelesen wurde. Es handelt sich um den digitalen Sensor HYT939, der über den I²C Bus ausgelesen wird. Er zeichnet sich laut Datenblatt mit folgenden Merkmalen aus:

  • DSC_2269chemisch sehr resistent
  • sehr weiter Temperatur- und Feuchtigkeitsmessbereich (-40°C .. +125°C, 0% ..100% RH)
  • mechanisch robuste Bauform
  • kalibriert und temperaturkompensiert
  • sehr geringer Drift
  • einsetzbar bis zu einem Umgebungsdruck von 16bar
  • Versorgungsspannung von 2.7 bis 5.5V
  • Auflösung von +/- 0.02% RH und 0.015°C
  • Genauigkeit von +/- 1.8% RH bei +23°C und +/-0.2K

Also wollte ich diesen Sensor auch mit dem Arduino betreiben und vielleicht in weiterer Folge auch den NTC parallel auslesen und die Ergebnisse vergleichen. Aber zurerst einmal wird der HYT an den Arduino angeschlossen.

hytpinDas Bild zeigt das Pinout des HYT in der Ansicht von unten. Die Belegung der Pins lautet:

  • 1…SCL
  • 2…VCC
  • 3…GND
  • 4…SDA

Somit lässt sich der Sensorchip ganz einfach an den Arduino anschließen, wobei die Pins SDA auf den Arduino Pin A4 und SCL auf den Pin A5 gelegt sind. Die Ausgabe der ausgelesenen Werte soll wieder wie beim NTC auf dem LC-Display stattfinden. Nachstehend ist der Code gelistet:

 

/*
   HYT939 bei Arduino UNO an:
   SDA pin A4
   SCL pin A5
   HYT939 bei MEGA2560 an:
   SDA pin 20
   SCL pin 21
   LCDisplay
   Pinzuordnungen allgemein für LCD
   RS to digital 12
   EN to digital 11
   D4 to digital 5
   D5 to digital 4
   D6 to digital 3
   D7 to digital 2
   R/W to ground
   VSS to ground
 */
 //I2C Addresse festlegen
 #define ADDR 0x28
 
 //Variablen und Datentypen festlegen
 double temp;
 double hum;
 unsigned int tempraw;
 unsigned int humraw;
 int x;
 unsigned char buffer[4];
 
 //Libraries laden
 #include <Wire.h>
 #include <LiquidCrystal.h>
 
 // interfacepins initialisieren
 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
 
   void setup()
   {
   //I2C und LCD Interface initialisieren,
   Wire.begin();
   lcd.begin(20, 4);
   
   Serial.begin(9600);
   lcd.println("HYT939-Sensor");
   }
 
 void loop()
   {
   //I2C auselesen
   Wire.beginTransmission(ADDR); 
   Wire.endTransmission();
   delay(200);
 
   //4 Bytes auslesen
   Wire.requestFrom(ADDR, 4,true);
   x=0;
   while(Wire.available()) 
   { char c = Wire.read(); buffer[x]=c; x++; }
 
 //Rohdaten aus Puffer lesen
 tempraw=buffer[2]*256+buffer[3];
 humraw=buffer[0]*256+buffer[1];
 
 //Daten laut Datenblatt maskieren
 tempraw&=0xfffc;
 humraw&=0x3fff;
 tempraw=tempraw/4;
 
 //Rohdaten in Ausgabeformat umrechnen
 temp=(double)tempraw/99.2909;  //skalieren laut datasheet
 temp=temp-40.0;
 hum=(double)humraw/163.83;
 
 //Daten auf LCD schreiben
   lcd.setCursor(0, 2);  
   lcd.print("Temperatur =");
   lcd.setCursor(11, 2);
   lcd.print(temp);
   
   lcd.setCursor(0, 3);  
   lcd.print("Humidity =");
   lcd.setCursor(14, 3);
   lcd.print(hum);
 //lcd.setCursor(0, 2);
 //lcd.print('Buffer0 =');
 //lcd.setCursor(11, 2);
 //lcd.print(buffer[2]);
 //lcd.setCursor(0, 3);
 //lcd.print('Buffer1 =');
 //lcd.setCursor(11, 3);
 //lcd.print(buffer[3]);
 }

 

Raspberry als Datenlogger Teil2…Die Sensoren und Python

DSC_4789
Raspberry PI samt Powerbank im Gehäuse

In Teil1 dieses Projektes haben wir dem Raspberry ein Betriebssystem verpasst und das ein wenig für die Anwendung aufbereitet. Wir wollen ja an den PI mehrere Sensoren anschließen und diese dann zyklisch auslesen und die Daten in einer Datei auf einem USB-Stick speichern. Die Aufzeichnung soll so lange laufen, bis ein Taster gedrückt wird, der den Prozess beendet. Die einzige Anzeige des PI sind zwei Leuchtdioden, die, sowie auch der Taster, an die GPIOs des PI angeschlossen sind. Darum haben wir folgende Punkte bereits erledigt:

  • 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 außen 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, sowie Python geladen werden.
DSC_4790
Raspberry PI im Plastikgehäuse

Der Pi sieht fertig zusammengebaut nun so aus (siehe Bild rechts). Nun können die Sensoren angeschlossen werden. In diesem Fall handelt es sich um Luftfeuchtigkeits-/Temperatursensoren mit der Bezeichnung HYT939 des Herstellers Hygrochip. Hier ein Auszug der technischen Daten aus dem Datenblatt des Herstellers:

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

DSC_4792
HYT939 Sensor

Eine kleine Platine dient als „Sensorboard“. Hier besteht die Möglichkeit, vier HYT´s anzustecken. Natürlich müssen auch die Adressen der Sensoren unterschliedlich sein. Der HYT939 ist per default auf hex 0x28 eingestellt. Will man diese Deviceadresse ändern, so muss der der HYT in den Command-Mode versetzt werden, um dann die Konfigurationsdaten empfangen und in sein EEprom schreiben zu können. Dazu muß der Sensor innerhalb der ersten 10ms nach seinem PowerUp in den Command-Mode gebootet werden. Das lässt sich am einfachsten mit einem ArduinoUno bewerkstelligen… Dabei wird der Powerpin des HYT über einen Digital Out Pin des Arduino versorgt. So ist es möglich, das Timing genau einzuhalten und den Command Mode zu erreichen.

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: addressiert 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. Hier sind die Temperaturwerte der Sensoren dargestellt. (Die Daten vom USB-Stick wurden mit Matlab importiert und daraus ein Plot erstellt.)

temperature_3sensoren

Raspberry als Datenlogger Teil1…Das Betriebssystem 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…

DSC_4789Wir 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…) ist auf einen RJ 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 Verbinung 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

Jetzt fährt der PI wieder hoch und bleibt beim Login-Prompt stehen. Mit login: pi und dem passwort: raspberry loggt man sich nun ein. Mit den folgenden Kommandos werden Updates und benötigte Module installiert:

sudo apt-get update
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)

Es empfiehlt sich, die Kernelmodule per Autostart zu laden. Das geht wie folgt:

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 now

danach wieder einloggen und mit

lsmod

überprüfen ob die gwünschten Module korrekt geladen sind.

Da 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:

  • 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

Zuerst laden und installieren wir das Filesystem:

sudo apt-get -y install ntfs-3g hfsutils hfsprogs exfat-fuse

dann legen wir folgendes Verzeichnis an:

sudo mkdir /media/usbstick (usbstick dient hier als beispielname…)

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

nun öffnen wir folgende Datei mit dem Editor:

sudo nano -w /etc/fstab

die 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 geht’s mit der Einrichtung der GPIOs und den Python libraries:

sudo apt-get install python-dev
sudo apt-get install python-rpi.gpio

Noch ein paar allgemeine Einstellungen:

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 dhcp

durch:

iface eth0 inet static
address xxx.xxx.xxx.xxx
netmask yyy.yyy.yyy.yyy
gateway zzz.zzz.zzz.zzz

und wieder speichern:

Das zu Anfang gestartete Setup Script lässt sich immer über folgenden Befehl aufrufen:

sudo raspi-config

Die 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…