Dies ist eine alte Version des Dokuments!
'Letztes Update 2020/12/07 00:57
'
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 induktive 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 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 vereinfacht 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
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.
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
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.
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.
Ersatzschaltung, wenn I2C verwendet wird.
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.
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
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/
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.
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:
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
sudo mkdir /mnt/qnap
An der QNAP die Systemsteuerung aufrufen und dort einen neuen Freigabeordner mit dem Namen pisicherung erstellen:
In diesem Ordner die NFS Zugriffsrechte einstellen:
sudo mount -t nfs 192.168.20.233:/pisicherung /mnt/qnap
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, Montags um 00:00 und 10 Sekunden auf die QNAP verschieben # und eine neue .log - Datei mit der aktuellen Kalenderwoche anlegen 0 0 * * * 1 sleep 10; mv /mnt/ssd/www/html/cpu_temperatur.png /mnt/qnap/cpu_temperatur_$(/bin/date +\%Y_KW\%V).png 0 0 * * * 1 sleep 12; 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
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.
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.
crontab -e
*/1 * * * * sleep 6; /home/pi/gcfan > /mnt/qnap/casetemp_dwserver.txt
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.
Zur Information alle auf dem Server eingetragenen Cron-Jobs.
# 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, Montags um 00:00 und 10 Sekunden auf die QNAP verschieben # und eine neue .log - Datei mit der aktuellen Kalenderwoche anlegen 0 0 * * * 1 sleep 10; mv /mnt/ssd/www/html/cpu_temperatur.png /mnt/qnap/cpu_temperatur_$(/bin/date +\%Y_KW\%V).png 0 0 * * * 1 sleep 12; mv /mnt/ssd/www/html/cpu_temperatur.log /mnt/qnap/cpu_temperatur_$(/bin/date +\%Y_KW\%V).log