Benutzer-Werkzeuge

Webseiten-Werkzeuge


Seitenleiste


C - Programmierung am Raspberry  Schaltpläne und Bauteilbeschreibungen  Adapterkabel  Mechanik  EDV-Literatur deutsch 



    FIAN Österreich     Imkerei WANKO
    Marktplatz Natur    
    Bäckerei Freitag

rpi_umg

Hardwareumgebung

Letztes Update 2020/12/24 11:45

(CC) BY-SA

Je nach Einsatzzweck Sensoren oder USB-Speicher am Raspberry anbringen. Zum Anschluß von Anzeigen oder Meldern wird ein ULN2803 als Treiber verwendet.

Der ULN2803 ist ein NPN Darlington-Array bestehend aus 8 Darlington Schaltungen mitsamt den nötigen Basiswiderständen. Dieser Baustein wird gerne genutzt um größere Lasten (bis 500mA, max. 50V an Vcc) an einem Mikrocontroller betreiben zu können. Liegt an den Eingängen ein positives Signal an, so schalten die Ausgänge nach Masse durch. Ein Vorteil dieses Bausteins sind die schon integrierten Freilaufdioden für induk­tive Lasten (z.B. ein Relais). Die Masse vom Raspberry und die Masse der Ausgänge muss unbedingt zusammengelegt werden.

In der folgenden Schaltung sind die acht Kanäle mit den von mir benötigten Anzeigen und Lüftern beschalten. Am Raspberry ist am GPIO04, (Pin7), WPi7 ein Temperatursensor zur Messung der Gehäusetemperatur angeschlossen.

         

Zur Ansteuerung der GPIO-Ports wird die WiringPi Libary verwendet. Diese muss vorher installiert werden.

Am USB3 Anschluß ist eine SSD angeschlossen. Der Ein- und Ausschalter ist als Reset-Taster hinter der Frontplatte erreichbar.

WiringPi & die I²C Libary installieren

Logo WiringPi ist ein nützliches Framework um die GPIO Ein-und Ausgänge am Raspberry Pi zu schalten. Natürlich ist das Schalten der GPIO’s auch ohne WiringPi möglich, der Einsatz von WiringPi verein­facht die ganze Sache aber und ist zudem erweiterbar.

Falls GIT noch nicht installiert ist:

sudo apt install git-core -y

Falls die I²C Libary benötigt wird:

sudo apt install libi2c-dev -y

WiringPi aus dem Repository installieren:

sudo apt install wiringpi

Die Version der installierten Version ermitteln:

~ $ gpio -v

gpio version: 2.50
Copyright (c) 2012-2018 Gordon Henderson
This is free software with ABSOLUTELY NO WARRANTY.
For details type: gpio -warranty

Raspberry Pi Details:
  Type: Unknown17, Revision: 01, Memory: 0MB, Maker: Sony
  * Device tree is enabled.
  *--> Raspberry Pi 4 Model B Rev 1.1
  * This Raspberry Pi supports user-level GPIO access.

Die Version 2.50 wird am Raspberry Pi 4 nicht oder nicht richtig funktionieren. Daher muß ein Update installiert werden:

cd /tmp
wget https://project-downloads.drogon.net/wiringpi-latest.deb
sudo dpkg -i wiringpi-latest.deb
~ $ gpio -v

gpio version: 2.52
Copyright (c) 2012-2018 Gordon Henderson
This is free software with ABSOLUTELY NO WARRANTY.
For details type: gpio -warranty

Raspberry Pi Details:
  Type: Pi 4B, Revision: 01, Memory: 4096MB, Maker: Sony
  * Device tree is enabled.
  *--> Raspberry Pi 4 Model B Rev 1.1
  * This Raspberry Pi supports user-level GPIO access.

Falls bereits eine alte Version von WiringPi installiert ist und diese entfernt werden soll, bevor die neue Version übertragen wird:

sudo apt purge wiringpi
hash -r

Damit ist WiringPi installiert. Wie man damit GPIO's schalten kann, wird im Kapitel "Mit WiringPi schalten" und Anschluss eines Summers erklärt.

Info:
Version kontrollieren ⇒ gpio -v
Status anzeigen ⇒ gpio readall
I²C-Treiber laden ⇒ gpio load i2c
weitere Schalter ⇒ gpio -h

Quellen:
Gordons Projects
WiringPi
WiringPi Update


Eine Status-LED beim Start des Pi einschalten

Um nicht nur zu sehen, ob der Pi am Strom angeschlossen, sondern dieser auch betriebsbereit ist, wird am Anschluss GPIO05, WPi21 eine LED mit einem Vorwiderstand angeschlossen. Die Größe des Vorwiderstandes sollte an die Stromaufnahme der LED angepasst werden. In diesem Projekt wird zur Ansteuerung der LED's ULN2803 verwndet, der mit 5V versorgt wird.

FIXME Für weitere Information siehe Schaltplan

WiringPi ist nicht unbedingt notwendig. Da aber WiringPi hier auch für andere Vorhaben notwendig ist, wird es auch zur Ausführung dieses Scripts verwendet.    

Um die LED zum leuchten zu bringen, ist ein kleines Script notwendig. Dieses wird hier in C erstellt.

sudo nano statusled_on.c
#include <wiringPi.h>
int main (void)
{
  wiringPiSetup () ;
  pinMode (21, OUTPUT) ;
  {
    digitalWrite (21, HIGH) ;
  }
  return 0 ;
}

Das Script wird kompiliert:

gcc -o  statusled_on statusled_on.c  -lwiringPi

und in die Verzeichnissse /etc/init.d/ und /bin/ kopiert:

sudo cp statusled_on /etc/init.d/statusled_on
sudo cp statusled_on /bin/statusled_on

Im Verzeichnis /etc/init.d/ wird eine Datei mit dem Namen local.statusled erstellt:

sudo nano /etc/init.d/local.statusled

Es wird die vereinfachte Vorlage /etc/init.d/skeleton verwendet.

#! /bin/sh
### BEGIN INIT INFO
# Provides:          local.autostart
# Required-Start:    $start
# Required-Stop:     $shutdown
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: schaltet die StatusLED ein
# Description:       Lange Bechreibung
### END INIT INFO
# Author: ede
 
# Aktionen
/bin/statusled_on

Der Kopfteil ist sehr wichtig und muss vorhanden sein, denn er wird später vom Befehl update-rc.d verwendet. Er darf nicht gelöscht und sollte entsprechend angepasst werden. Unterhalb von # Aktionen steht der Befehl zur Ausführung des C-Scripts.

Da die GPIO Pins ohnehin beim Abschalten stromlos werden, kann die /etc/init.d/local.statusled einfach gehalten werden.

Die Datei wird nun ausführbar gemacht:

sudo chmod 755 /etc/init.d/local.statusled

Abschließend fügt man das Skript mit dem Befehl update-rc.d in die entsprechenden Runlevel ein.

sudo update-rc.d local.statusled defaults

Ab dem nächsten Reboot wird nun ab der Betriebsbereitschaft des Pi eine LED aktivert.


Quellen:

Autostartskript erstellen und einbinden
Raspberry Pi - run program at start-up


Ein- & Ausschalter aktivieren

Der Taster muss mit GPIO3 & Ground verbunden werden





Ab dem Raspberry Pi3 genügt ein einfacher Taster, der an den GPIO-Pins 5 & 6 (GPIO3 & Ground) angeschlossen wird.
Der Taster muss mit GPIO3 & Ground verbunden werden. Damit der Ein- & Ausschalter funktioniert, muss eine neue Befehlszeile in die Datei /boot/config.txt in der Sektion [pi4] eingefügt werden.

sudo nano /boot/config.txt
dtoverlay=gpio-shutdown,gpio_pin=3, active_low=1,gpio_pull=up
[pi4]
# Enable DRM VC4 V3D driver on top of the dispmanx display stack
dtoverlay=vc4-fkms-v3d
max_framebuffers=2

# GPIO pin3 für Ein- Ausschalter überwachen
dtoverlay=gpio-shutdown,gpio_pin=3, active_low=1,gpio_pull=up

Nach der Änderung der config.txt muss der Raspberry rebootet werden:

sudo reboot

Bei Startproblemen nach dieser Änderung muss eventuell der Bootloader erneuert werden.

Bootloader wiederherstellen

Wenn der Raspberry Pi 4 nicht startet, ist möglicherweise das SPI-EEPROM beschädigt.

Entfernen Sie zur Überprüfung die SD-Karte, trennen Sie das Gerät vom Stromnetz und schließen Sie es erneut an. Wenn die grüne LED nicht blinkt, müssen Sie das EEPROM neu programmieren:

Laden Sie den Bootloader herunter      

SHA-256: 444e0f68aa21d5b4e158259061de55738d36a1986e2ced14bb14d7af1a04881c
Extrahieren Sie es auf eine leere FAT-formatierte SD-Karte und legen Sie es in Ihren Raspberry Pi 4 ein
Schließen Sie die Stromversorgung an und warten Sie, bis die grüne LED schnell blinkt

Anmerkungen:
Der aktualisierte Bootloader verbessert die Kompatibilität mit HATs, indem das Verhalten von HALT geändert wird, um den 3V3-Pin mit Strom zu versorgen (siehe die vollständigen Versionshinweise zum Bootloader). Der vorherige Bootloader steht weiterhin zum Download zur Verfügung

Quelle: https://www.raspberrypi.org/downloads/


Der Ein- / Ausschalter funktioniert nur dann, wenn i2c nicht aktiviert ist. Der Pin 5 [GPIO 3 (SCL1)] ist Teil des I2C Anschlußes. Sobald über raspi-config I2C aktiviert ist, funktioniert die Anwendung nicht mehr. Man kann einen anderen Pin in der /boot/config.txt angeben. Über diesen kann der Raspberry zwar aus- aber nicht mehr eingeschaltet werden kann. Dies geht dann nur mehr durch unterbrechen der Stromversorgung oder mit einem Reset.

FIXME Ersatzschaltung, wenn I2C verwendet wird.


CPU - Lüfter temperaturgesteuert ein- und ausschalten

und die Werte in eine LOG-Datei schreiben, um daraus eine Grafik zu erstellen.

Am Raspberry ist am Pin33, GPIO13, WiringPi23 ein CPU-Lüfter über eine Darlington-Stufe angeschlossen.

Um diesen Lüfter mit dem Raspberry zu steuern, wird ein C-Programm abgearbeitet, welches von cron alle Minuten ausgeführt wird. Zur Steuerung des Lüfters wird die WiringPi Bibliothek verwendet. Dazu muss WiringPi installiert sein. Siehe WiringPi installieren.
Falls kein Lüfter gesteuert werden soll, sondern nur die CPU Temperatur kontrolliert und in einer Grafik angezeigt werden soll, dann sind aus dem Programm alle dahingehende Teile vor dem Kompilieren zu entfernen.

FIXME
Eventuell eine Konfigurationsdatei im Home-Verzeichnis vom User pi anlegen, um die Ein- / Ausschalttemperatur leichter anpassen zu können.

sudo nano ccfan.c
/*###############################################
#    Name: ccfan.c
# Version: 1.00
#   Datum: 04.11.2020
#   Zweck: Lüfter einschalten, wenn
#          CPU-Temperatur zu hoch
# (CC) BY-SA
#################################################*/
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <wiringPi.h>
#define ZEILENLAENGE 256
 
int main(void)
{
    char* device_id = "/sys/class/thermal/thermal_zone0/temp";   // Pfad zur CPU temperatur
    char* line = malloc(sizeof(char)*ZEILENLAENGE);
    FILE *fp;
    float temperatur;
 
    float fan_on = 50.00;   //einschalttemperatur
    float fan_off = 45.00;  //ausschalttemperatu
 
    #define FAN     23      //wiringpi port des lüfters
    #define HIGH    1
    #define LOW     0
 
    struct tm *zeit;
    time_t sekunde;
    char string[80];
    time(&sekunde);
 
    wiringPiSetup ();
    pinMode (24, OUTPUT);
 
    fp = fopen( device_id, "r"); //Temporäre Temperatur-Logdatei zum lesen öffnen
    if(fp == NULL) {
        printf("Datei kann nicht geöffnet werden.\n");
        return EXIT_FAILURE;
    } else {
        fgets(line, ZEILENLAENGE, fp);
    }
//    printf("Temp in m°C: %s", line);
 
    temperatur = atof(line)/1000;
//    printf("CPU-Temperatur = %.2f°C\n", temperatur);
//    printf("        FAN On = %.2f°C\n", fan_on);
 
    fclose(fp);
 
    if (temperatur > fan_on) {
        digitalWrite (FAN, HIGH);
//        printf("FAN HIGH \n");
    }
    else if (temperatur < fan_off) {
        digitalWrite (FAN, LOW);
//        printf("FAN LOW \n");
    }
 
    zeit = localtime(&sekunde);
    strftime(string, 80, "%d.%m.%y  %H:%M",zeit);
    printf("%s  %.1f\n", string, temperatur);
 
    return EXIT_SUCCESS;
}

Nach dem Speichern wird das Programm mit dem Schalter -lwiringPi kompiliert:

 gcc -o ccfan ccfan.c -lwiringPi
Die eingetragenen Temperaturwerte sind vor allem für das Testen von Programm und Hardware verwendet worden. Die tatsächlichen Werte hängen sehr stark von Gehäuse und Umweltbedingungen ab.

Für die nächsten Schritte dem Verzeichnis /mnt/ssd/www/html das Schreibrecht geben:

sudo chmod 0777 /mnt/ssd/www/html/

oder für paranoide Anwender wie mich:

sudo chmod 0757 /mnt/ssd/www/html/

crontab editieren

An der Konsole crontab mit dem Schalter -e eingeben:

crontab -e

und folgenden Eintrag vornehmen, um das Programm cfan zu starten und die Temperaturdaten in ein Logfile zu schreiben. Da eine Festplatte im Verzeichnis /mnt/ssd eingehängt ist wird die LOG Datei auf diese gespeichert. Der printf-Befehl aus dem Programm ccfan wird durch den cron-Job in die Datei umgeleitet. Diese LOG-Datei wird zum Erstellen einer Verlaufsgrafik herangezogen.

  */1 * * * * /home/pi/ccfan >> /mnt/ssd/www/html/cpu_temperatur.log

Es wird nun alle Minuten die Temperatur der CPU in die Datei /mnt/ssd/www/html/cpu_temperatur.log geschrieben und kontrolliert, ob die Gehäusetemperatur unter/über der jeweiligen Schaltschwelle für das Ein- und Ausschalten liegt.

gnuplot installieren und einrichten

Vor der Verwendung von gnuplot muss dieses natürlich vorher installiert werden:

sudo apt install gnuplot -y

Da die Grafik als Überschrift das aktuelle Jahr und die dazugehörige Kalenderwoche enthalten soll, wird ein C-Script erstellt, welches diese Arbeit erledigt. Das kompilierte Script wird jede Woche ausgeführt und ersetzt die Log-Datei der Vorwoche.

sudo nano /home/pi/nano c_genconf.c
/*################################################
#    Name: c_genconf.c
# Version: 1.00
#   Datum: 27.11.2020
#   Zweck: Erzeugen einer .conf Datei für gnuplot
# (CC) BY-SA
##################################################*/
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
int main (void) {
 
        struct tm *zeit;
        time_t sekunde;
        char string[80];
        time(&sekunde);
 
        zeit = localtime(&sekunde);
        strftime(string, 80, "%Y KW%V",zeit);
 
        printf("# cpu-temperatur.conf \n");
        printf("#\n");
        printf("set title \"CPU-Temperatur %s\"\n", string);
        printf("set xlabel \"Minuten\"\n");
        printf("set ylabel \"Temperatur (°C)\"\n");
        printf("set terminal png size 640,480\n");
        printf("set output \"/mnt/ssd/www/html/cpu_temperatur.png\"\n");
        printf("set xdata time\n");
        printf("set timefmt \"%%d.%%m.%%y %%H:%M\"\n");
        printf("set format x \"%%d.%%m\\n%%H:%%M\"\n");
        printf("set xtics rotate by 90 offset 0,-2 out nomirror\n");
        printf("set grid\n");
        printf("set key left box\n");
        printf("plot \"/mnt/ssd/www/html/cpu_temperatur.log\" using 1:3 title \"CPU\"  with lines\n");
 
return EXIT_SUCCESS;
}

Nach dem Kompilieren (gcc -o c_genconf c_genconf.c) wird ein Testausdruck erstellt. Dieser sieht beispielsweise folgendermaßen aus:

# cpu-temperatur.conf
#
set title "CPU-Temperatur 2020 KW48"
set xlabel "Minuten"
set ylabel "Temperatur (°C)"
set terminal png size 640,480
set output "/mnt/ssd/www/html/cpu_temperatur.png"
set xdata time
set timefmt  "%d.%m.%y %H:%M"
set format x "%d.%m\n%H:%M"
set xtics rotate by 90 offset 0,-2 out nomirror
set grid
set key left box
plot "/mnt/ssd/www/html/cpu_temperatur.log" using 1:3 title "CPU" with lines

Die Bedeutung der einzelnen set-Kommandos:

  • set title „CPU-Temperatur“ - Überschrift
  • set xlabel „Minuten“ - Bezeichnung X-Achse
  • set ylabel „Temperatur (°C)„ - Bezeichnung Y-Achse
  • set terminal png size 640,480 - Ausgabegröße der Grafik in Pixel
  • set output „/mnt/ssd/www/html/cpu_temperatur.png“ - Name und Pfad der Grafikdatei
  • set xdata time - Setzt das Format der tic-Labels
  • set timefmt “%d.%m.%y %H:%M“ - Format der Daten
  • set format x „%d.%m n%H:%M“ - Beschriftung der X-Achse,  n = Zeilenumbruch
  • set xtics rotate by 90 offset 0,-2 out nomirror - Beschriftung der X-Achse um 90° drehen und nach unten versetzen, da Beschriftung ansonsten im Bild
  • set grid - Raster zeichnen
  • set key left box - Bezeichnung der Kurve
  • plot „/mnt/ssd/www/html/cpu_temperatur.log“ using 1:3 title „CPU“ with lines

Nochmals die crontab aufrufen (crontab -e)und drei Zeilen einfügen:

  */1 * * * * /home/pi/ccfan >> /mnt/ssd/www/html/cpu_temperatur.log
  */1 * * * *  sleep 3; cat '/home/pi/cpu-temperatur.conf' | /usr/bin/gnuplot
  0 0 * * 1  sleep 15; /home/pi/c_genconf > /home/pi/cpu-temperatur.conf

Nun wird zusätzlich 3 Sekunden nachdem die LOG-Datei geschrieben wird, die Grafik cpu_temperatur.png im Verzeichnis /mnt/ssd/www/html/ erstellt und die /home/pi/c_genconf aufgerufen, welche die neue Konfigurationsdatei /home/pi/cpu-temperatur.conf erstellt.

Die Grafik kann nun im Browser direkt angezeigt werden:

/IP-Adresse/cpu_temperatur.png

Am QNAP-Server einen Sicherungsordner erstellen

Verzeichnis am RPi anlegen

sudo mkdir /mnt/qnap

Ordner an der QNAP anlegen

An der QNAP die Systemsteuerung aufrufen und dort einen neuen Freigabeordner mit dem Namen pisicherung erstellen:

In diesem Ordner die NFS Zugriffsrechte einstellen:

Den Ordner 'pisicherung' am Raspberry einhängen

sudo mount -t nfs 192.168.20.233:/pisicherung /mnt/qnap

Ordner fix in der fstab eintragen

sudo nano /etc/fstab

192.168.20.233:/pisicherung /mnt/qnap nfs rw 0 0

crontab aufrufen und die folgenden Einträge vornehmen:

crontab -e
# Die CPU-Temperatur Logdateien jede Woche, Sonntag um 23:59 und 30/35 Sekunden auf die QNAP verschieben
# und eine neue .log - Datei mit der aktuellen Kalenderwoche anlegen
59 23 * * 0  sleep 30; mv /mnt/ssd/www/html/cpu_temperatur.png /mnt/qnap/cpu_temperatur_$(/bin/date +\%Y_KW\%V).png
59 23 * * 0  sleep 35; mv /mnt/ssd/www/html/cpu_temperatur.log /mnt/qnap/cpu_temperatur_$(/bin/date +\%Y_KW\%V).log

Bei Einträgen in die crontab darauf achten, dass ein %-Zeichen in der crontab eine andere Funktion hat. Daher unbedingt \% (Backslash-Prozent) verwenden. Für die date Funktion unbedingt den absoluten Pfad (/bin/date) verwenden.

Damit werden Grafik und Logdatei, jeweils versehen mit Jahres- und Wochenbezeichnung in das eingerichtete QNAP-Verzeichnis verschoben.

Quelle: Linux nfs mount


Gehäuselüfter temperaturgesteuert ein- und ausschalten

Am RPi 1-Wire einschalten. Dazu raspi-config starten, Punkt5 - Interfacing Options / Punkt P7 - 1-Wire / Enable/Disable one-wire interface, und die 1-Wire Funktion aktivieren.

Am Raspberry ist an Pin7, GPIO4, WiringPi7 ein 18B20 Temperatursensor angeschlossen. An Pin35, GPIO19, WiringPi25 ein Lüfter.


Das 1-Wire Protokoll aktivieren:

sudo modprobe w1-gpio
sudo modprobe w1-therm

Die config.txt wird geöffnet:

sudo nano /boot/config.txt

und am Ende der Datei wird eine Zeile hinzugefügt:

dtoverlay=w1-gpio,gpioin=4,pullup=on

Durch die Eingabe von

lsmod

wird nun überprüft, ob die Module aufgelistet sind. Als Beispiel:

w1_therm               24576  0
w1_gpio                16384  0
wire                   40960  2 w1_gpio,w1_therm

Falls die Module nicht aufgelistet sind, kontrollieren, ob der 18B20 an GPIO04 angeschlossen ist.

Damit beim Start die beiden Module geladen werden, diese in die Datei /etc/modules eintragen:

Datei öffnen:

sudo nano /etc/modules

und am Ende zwei Zeilen einfügen:

w1_gpio
w1_therm

Um den Sensor zu identifizieren, muss seine ID herausgefunden werden. Dazu in das devices-Verzeichnis wechseln:

cd /sys/bus/w1/devices/
ls

Je nach Sensortype beginnen die entsprechenden Dateien mit 10-, 28- oder ähnlich.
Hier lautet die ID 28-000004d90298.

pi@rpi:/sys/bus/w1/devices $ cd /sys/bus/w1/devices/
pi@rpi:/sys/bus/w1/devices $ ls
28-000004d90298  w1_bus_master1
pi@rpi:/sys/bus/w1/devices $

Zur Kontrolle, ob auf der Hardwareseite alles funktioniert, an der Konsole folgende Eingabe vornehmen:

cat /sys/bus/w1/devices/28-000004d90298/w1_slave

In der Ausgabe sehen wir in der zweiten Zeile in den letzten 5 Stellen die Temperatur in m°C (Milligrad Celsius):

pi@rpi:~ $ cat /sys/bus/w1/devices/28-000004d90298/w1_slave
b9 01 4b 46 7f ff 07 10 d1 : crc=d1 YES
b9 01 4b 46 7f ff 07 10 d1 t=27562
pi@rpi:~ $

Der Wert durch 1000 geteilt ergibt die Temperatur von 27.562°C.

Zur Anzeige der Temperatur wird nun eine C Routine geschrieben. Dieses Programm soll in weiterer Folge dazu dienen, bei einer zu hohen Temperatur einen Gehäuselüfter einzuschalten.

Um diesen Lüfter mit dem Raspberry zu steuern, wird ein C-Programm abgearbeitet, welches von cron alle Minuten ausgeführt wird. Im Programm sind die Seriennummer des 18B20, sowie Ein- und Ausschalttemperatur fest Kodiert.

FIXME
Eventuell eine Konfigurationsdatei im Home-Verzeichnis vom User Pi pi anlegen um die S/N des Sensors und die Ein- / Ausschalttemperatur leichter anpassen zu können.

sudo nano gcfan.c
/*###############################################
#    Name: gcfan.c
# Version: 1.01
#   Datum: 27.11.2020
#   Zweck: Lüfter einschalten, wenn
#          Gehäusetemperatur zu hoch
# 27.11.20 Druck der Daten geändert EDE
# (CC) BY-SA
#################################################*/
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <wiringPi.h>
#define ZEILENLAENGE 256
 
int main()
{
    char* device_id = "/sys/bus/w1/devices/28-000004d90298/w1_slave";   // Pfad und S/N 18B20
    char* line = malloc(sizeof(char)*ZEILENLAENGE);
    char string[40];
    char *ptr;
    char tstring[10];
    FILE *fp;
    int i, data;
    float temperatur;
 
    float fan_on = 40.00;   //einschalttemperatur
    float fan_off = 35.00;  //ausschalttemperatu
    #define FAN     24      //wiringpi port des lüfters
    #define HIGH    1
    #define LOW     0
 
    struct tm *zeit;
    time_t sekunde;
    time(&sekunde);
    char pstring[80];
 
    wiringPiSetup ();
    pinMode (24, OUTPUT);
 
    fp = fopen( device_id, "r"); //Temporäre Temperatur-Logdatei zum lesen öffnen
    if(fp == NULL) {
        printf("Datei nicht vorhanden od. kann nicht geöffnet werden.\n");
        return EXIT_FAILURE;
    } else {
        for(i=0; i<2; i++)      // Zur 2. Zeile gehen
        {
            fgets(line, ZEILENLAENGE, fp);
        }
//            printf("%s", line);
    }
 
    ptr = strtok(line, "=");    // String teilen
 
 
    while( ptr ) {
        ptr = strtok( NULL, "=");
        if ( ptr )  {           // Gültiger Wert
//            printf("\n%s\n", ptr);
            strcpy (tstring, ptr);
//            printf("tsring = %s\n", tstring);
        }
    }
 
    temperatur = atof(tstring)/1000;
 
    zeit = localtime(&sekunde);
    strftime(pstring, 80, "%d.%m.%y  %H:%M",zeit);
    printf("%s  %.1f\n", pstring, temperatur);
 
 
//    printf("Temperatur = %.2f°C\n", temperatur);
 
    fclose(fp);
 
    if (temperatur > fan_on) {
        digitalWrite (FAN, HIGH);
    }
    else if (temperatur < fan_off) {
         digitalWrite (FAN, LOW);
    }
 
 
    return EXIT_SUCCESS;
}

Nach dem Speichern wird das Programm mit dem Schalter -lwiringPi kompiliert:

 gcc -o gcfan gcfan.c -lwiringPi

Für die Tests wird die Gehäusetemperatur ausgedruckt. Im cron-job ist der Ausdruck in eine Datei umzuleiten. Es wird keine LOG-Datei erstellt, sondern nur die aktuelle Temperatur in eine Datei (auf der QNAP) geschrieben.

Die eingetragenen Temperaturwerte sind vor allem für das Testen von Programm und Hardware verwendet worden. Die tatsächlichen Werte hängen sehr Stark von Gehäuse und Umweltbedingungen ab.
crontab -e
  */1 * * * *  sleep 6; /home/pi/gcfan > /mnt/qnap/casetemp_dwserver.txt

Signal am Buzzer ausgeben

Für allgemeine Nachrichten kurze Signale am Buzzer ausgeben. Die Anzahl der Signale wird als Parameter beim Start übergeben (Base 0).

/*###############################################
#    Name: buzz.c
# Version: 1.00
#   Datum: 04.11.2020
#   Zweck: Signal am Beeper ausgeben
# (CC) BY-SA
#################################################*/
 
#include <stdio.h>
#include <stdlib.h>
#include <wiringPi.h>
#include <unistd.h>     // für sleep
 
int main(int argc, char* argv[]) {
 
        int i;
        double tim;
 
        #define BEEPER  25      // Beeper an WiringPi 25
 
        tim = strtod(argv[argc-1], NULL);
        tim++;
 
        wiringPiSetup ();
        pinMode (BEEPER, OUTPUT);
 
        for(i=0; i < tim; i++) {
                digitalWrite (BEEPER, HIGH); delay (100); sleep(0.10);
                digitalWrite(BEEPER, LOW);  delay (100);
        }
 
        return 0;
}

Compilieren ces Programms mit

gcc -o buzz buzz.c  -lwiringPi

Der Buzzer ist an GPIO26, (Pin37) WPi25 angeschlossen. Beim Aufruf mit ./buzz oder./buzz 0 wird ein Signal gesendet, bei ./buzz 1 sind es 2 u.s.w.

crontab mit allen Einträgen

Zur Information alle auf dem Server eingetragenen Cron-Jobs.

crontab.cf
# m h  dom mon dow   command
 
# Alle Minuten die CPU Temperatur kontrollieren, loggen und Grafik erstellen
*/1 * * * * /home/pi/ccfan >> /mnt/ssd/www/html/cpu_temperatur.log
*/1 * * * *  sleep 3; cat '/home/pi/cpu-temperatur.conf' | /usr/bin/gnuplot
 
# Gehäusetemperatur kontrollieren und alle Minuten an die QNAP senden
*/1 * * * *  sleep 6; /home/pi/gcfan > /mnt/qnap/casetemp_dwserver.txt
 
# Einmal wöchentlich die Konfigurationsdatei neu erstellen (Jahr / KW)
0 0 * * 1  sleep 15; /home/pi/c_genconf > /home/pi/cpu-temperatur.conf
 
# Die CPU-Temperatur Logdateien jede Woche, Sonntag um 23:59 und 30/35 Sekunden auf die QNAP verschieben
# und eine neue .log - Datei mit der aktuellen Kalenderwoche anlegen
59 23 * * 0  sleep 30; mv /mnt/ssd/www/html/cpu_temperatur.png /mnt/qnap/cpu_temperatur_$(/bin/date +\%Y_KW\%V).png
59 23 * * 0  sleep 35; mv /mnt/ssd/www/html/cpu_temperatur.log /mnt/qnap/cpu_temperatur_$(/bin/date +\%Y_KW\%V).log
 
# Täglich um 04:00 eine Sicherung des Dokuwiki-Servers durchführen und auf die NAS verschieben
00 04 * * * /home/pi/sicherdw.sh
rpi_umg.txt · Zuletzt geändert: 2020/12/24 11:52 von administrator