Linux-Workshop 2017

Übersicht der Artikel:

* Dokumentation über BASH
* eMail-Programm installieren
* Linux-online-WS KW49/17 Dateibearbeitung
* Lösung der Hausaufgabe
* Linux-online-WS KW48/17 Useradministation
* Linux-online-WS KW47/17 Netzwerk
* Linux-online-WS KW46/17
* Linux-online-WS KW45/17
* Linux-Workshop am 3.11.17
* Zugriff von PC auf Raspberry ohne Netzwerk
* WLAN: SSID und Passwort eintragen
* Änderungen in Raspian-Jessie
* RasPi als RMS
* RaspPi als Terminalserver
* Anzeige und Speicherung der Temperatur
* SD-Karte schonen
* Installation eines Web-Servers
* Sicherung der SD-Karte
* Anwendung: Ausschalten über GPIO
* Wichtige Dateien: crontab
* Konfiguration der GPIO-Ports
* Raspberry Pi
* Linux-Befehle
* Linksammlung

*Bash-Dokumentation

Deutschsprachige Dokumentation über die Bash:
Buch: Shell-Programmierung
Web: Bash-Grundkurs

*eMail-Programm installieren

Um vom RaspberryPi direkt auf sein eMail-Postfach zugreifen zu können kann man Thunderbird installieren:
sudo apt-get install thunderbird
Die CPU wird stark belastet, wenn man dem Rechner aber Zeit läßt, läuft es auch auf dem Zero.

*Linux-online-WS KW49/17 Dateibearbeitung

Hallo, hier einige zusätzliche Befehle zur Arbeit mit Dateien:

Suche nach einer Datei

find . -print | grep -i dateiname # Suche nach Datei (-i: unabhängig ob gross oder klein geschrieben) im aktuellen Verzeichnis (.) und tiefer. Für Suche im kompletten Rechner den Punkt durch / ersetzen.

Suche nach einem String in einer oder mehreren Dateien

grep „such-string mit Leerzeichen“ dateiname # dateiname durch * ersetzt: Suche in allen Dateien im Verzeichnis und Anzeige der Zeilen, die den String enthalten.

Ausschneiden einzelner Felder in csv-Dateien

cat dateiname| cut -d“;“ -f1,9- >>datei_neu # Trennzeichen zwischen den Feldern: ; In die neue Datei werden die Felder 1 sowie 9 und alle folgenden geschrieben

Anzeige der ersten oder letzten Zeilen einer Datei

head -3 dateiname # die ersten 3 Zeilen
tail -5 dateiname # die letzten 5 Zeilen werden angezeigt

Mehrere Dateien zusammenfassen

cat datei*.txt >> neudatei # Alle Dateien, die mit „datei“ beginnen und mit „.txt“ enden werden in der Reihenfolge, die mit „ls“ angezeigt wird, hintereinander in die „neudatei“ geschrieben.
cat datei >> neudatei # Inhalt von datei an bisherigen Inhalt in neudatei anhängen
cat date > neudatei # Inhalt von neudatei durch Inhalt von datei überschreiben

Sortieren

sort -u datei >> dateineu # die Zeilen in der Datei sortieren und doppelte Zeilen nur einfach anzeigen (-u) + Schreiben der Zeilen in dateineu
sort -t”:” -k4 -n /etc/passwd # -t: Feldtrenner, -k: Feld, nach dem sortiert wird , -n numerisch sortiert (9 < 10)

Lösung der Hausaufgabe

sudo apt-get install apache2
sudo mkdir /var/www/html/pdf
sudo mv Downloads/datei.pdf /var/www/html/pdf
Aufruf: http://Raspi-ip/pdf

*Linux-online-WS KW48/17 Useradministation

Hallo, hier einige zusätzliche Befehle zur User-Administration:

User und HOME-Verzeichnis anlegen

sudo useradd -s /bin/bash -G sudo -m -d /home/neuuser neuuser

-s : verwendete Shell	( siehe /bin/false, /usr/sbin/nologin)
-G: zusätzliche Gruppe
-u: uid (User-ID), wenn nicht angegeben, automatisch vergeben
-m: Anlegen des HOME-Verzeichnisses mit Vorgaben in /etc/skel
-d: HOME-Verzeichnis
-c: Kommentar
neuuser: username

sudo passwd neuuser #Passwort vergeben

Identität abfragen, wechseln

su – neuuser # User wechseln
id #Anzeige des aktuellen User mit den zugeordneten Gruppen
who #Anzeige aller aktiven User
who am i #Anzeigen, als wer man eingeloggt ist
env #Anzeige der Umgebungsvariablen

Interessante Dateien

/etc/passwd #Eingerichtete User
/etc/shadow #Passworte
$HOME/.bashrc #Userspezifische Einstellungen
$HOME/.bash_history #Alte Eingaben

Interessante Variablen

echo $VISUAL #Anzeige des Inhalt der Variable VISUAL
export VISUAL=vi #oder export VISUAL=nano #setzen des Editors z.B. für crontab
$PS1 #Bash-Prompt: Beginn der Eingabezeile
$HOME #Heimatverzeichnis

*Linux-online-WS KW47/17

Hallo, hier einige zusätzliche Befehle, mit denen man das Netzwerk, in das der eigene Rechner eingebunden ist, genauer kennenlernt:

IP-Adresse anzeigen

ip a
ip -br a #Kurzfassung (erst in neuen Versionen enthalten)
ip route #welches Netz über welches Interface

Erreichbarkeit eines Rechners überprüfen

ping rechnername/ip-adr #Antwortet der Rechner?
traceroute rechnername/ip-adr #Welchen Weg nimmt das IP-Paket?

WLAN einrichten:

#SSID und Passwort abspeichern:
sudo wpa_passphrase ssid passphrase >> /etc/wpa_supplicant/wpa_supplicant.conf

Netzwerk-Konfigurationsdateien

/etc/network/interfaces
/etc/hostname #Rechnername
/etc/hosts #IP-Adresse zu Rechnername
/etc/dhcpcd.conf #z.B. zur Verwendung von statischen IP-Adressen

    interface eth0
    static ip_address=192.168.1.202/24
    static routers=192.168.1.1
    static domain_name_servers=192.168.1.1

/etc/resolv.conf #enthält die IP-Adresse des Name-Server

/etc/ntp.conf #Uhrzeit aus dem Netz beziehen
/etc/timezone

*Linux-online-WS KW46/17

Hallo, hier einige zusätzliche Befehle, mit denen man Dateien handhaben kann:

Kopieren einer Datei

cp vorhandene_datei neue_datei
cp -R /etc/skel $HOME/test #recursives Kopieren

Verschieben einer Datei

mv alter_standort neuer_standort

Anlegen einer leeren Datei

touch dateiname

Anlegen eines Link

ln -s /etc/skel $HOME/skellink

Sichern auf anderen Rechner

sudo rsync -avz /var/www/html pi@rechnername:/home/pi/web_sicherung

Berechtigungen einer Datei ändern

chmod +x datei #datei ausführbar machen
chown neuuser datei #meistens mit sudo
chgrp neuuser datei

Testet doch mal dies an euren Rechnern aus und werft einen Blick in die man-pages.

Erklärungen:
# : alles was in der Zeile nach dem „#“ kommt ist ein Kommentar
$HOME : Default-Directory des aktuellen Users
pi@rechnername : auf den fremden Rechner als User pi einloggen

*Linux-online-WS KW45/17

Hallo, hier einige zusätzliche Befehle, mit denen man sich einen Überblick über seinen Raspberry verschaffen kann:

Speicherbelegung der einzelnen Verzeichnisse/Dateien ermitteln:

du -hs .
du -hs *

Informationen über die Hardware:

cat /proc/cpuinfo
cat /proc/meminfo

Board-Temperatur ermitteln:

sudo vcgencmd measure_temp
cat /sys/class/thermal/thermal_zone0/temp
(sudo vcgencmd commands: z.B. measure_volts)

CPU-Takt auslesen:

sudo vcgencmd measure_clock arm
cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq

RAM-Speicher:

free -h
sudo vcgencmd get_mem arm
sudo vcgencmd get_mem gpu

Betriebsversion anzeigen:

cat /proc/version
uname -a

Zeit seit letztem Boot:

uptime

Auslastung des Rechner:

top

Testet doch mal dies an euren Rechnern aus.

*Linux-Workshop am 3.11.17

Hier die Mitschrift der vorgestellten Befehle und Dateien.
Nähere Informationen erhält man über “man Befehl” oder “man Dateiname”.
cd
script
df bzw. df -h (um die Wirkung der Schalter (hier h für human readable) zu erkennen)
ls bzw. ls -lisa
cat /etc/fstab
sudo less /var/log/messages (Datei kann nicht mit den normalen User-Rechten gelesen werden)
| (Pipe) z.B. ls -lisa /etc | less
mount
dmesg
lsusb

Vertiefende Übungen:
Erkenne den Unterschied zwischen “ls -lisaR” , “ls -lisar” , “ls -lisatr” , “ls -lisat”.
Stecke einen USB-Stick ein und vergleiche die Ausgabe von “df -h” ohne und mit USB-Stick.
Wie macht sich das Stecken (und Entfernen) des USB-Stick bei “dmesg” und “lsusb” bemerkbar.

*Zugriff von PC auf Raspberry ohne Netzwerk

Mit einem USB zu Seriell-TTL 3,3 V Adapterkabel kann man sich von eiem PC auf einen Raspberry einloggen, selbst wenn er keine Netzwerkverbindung hat.
Hierzu muß das Adapterkabel folgendermaßen an die GPIO-Pins des Raspberry angeschlosen werden:
Masse an Pin 6
RX und TX an Pin 8 und 10 (notfalls tauschen)
Unbedingt darauf achten, daß das Adapterkabel 3,3V-Logikpegel an RX und TX aufweist.
Putty starten mit
Connection-Typte: Serial
entsprechender COM-Port (bei mir COM15)
Speed: 15200
Data bits: 8
Stop bits: 1
Parity: None
Flow control: None
Nach einigen Tastatureingaben erscheint das Login.

*WLAN: SSID und Passwort eintragen

Die Zugangsdaten zu einem WLAN liegen beim Raspi unter /etc/wpa_supplicant/wpa_supplicant.conf.
Man kann diese Datei auch vom Terminal aus befüllen:

sudo bash
cd /etc/wpa_supplicant
wpa_passphrase SSID >> wpa_supplicant.conf
Passwort

Danach evtl. mit einem Texteditor die Zeile mit dem Klartext-Passwort aus der Datei löschen.

*Änderungen in Raspian-Jessie

Grundkonfiguration

Die Tastatur-Einstellung wird zur Zeit nur übernommen, wenn sie über “raspi-config” in einer Shell erfolgt.

Verwenden einer statischen IP-Adresse

Da ein DHCP-Client aktiv ist, sollte man die statische IP-Adresse in der Datei /etc/dhcpcd.conf konfigurieren:

interface eth0
static ip_address=192.168.1.9/24
static routers=192.168.1.1
static domain_name_servers=192.168.1.1

cgi-Scripte in Apache2 aktivieren:

  • Scripte in  /usr/lib/cgi-bin ablegen
  • sudo a2enmod cgi
  • sudo service apache2 restart

*RasPi als RMS

RMS: Rack Monitoring System

Ein RMS dient zur Überwachung der in einem Schaltschrank eingebauten Komponenten. Dies kann beinhalten:

  • Temperatur der einzelnen Systeme bzw. des kompletten Systems
  • Luftfeuchtigkeit
  • Zugriff zum System: Türen, Gehäusedeckel
  • Spannungsversorgung
    1. Temperaturmessung

Hierzu kann man den Temperatursensor DS18S20 verwenden. Dieser Sensor für den 1-wire-Bus hat den Vorteil, daß man mit nur 3 Anschlüssen mehrere Messstellen überwachen kann, da die einzelnen IC mit ihren Seriennummern angesprochen werden können. Die Sensoren werden parallel geschaltet:

  • Pin 1 an Masse
  • Pin 2 an GPIO 4 (Pin7)
  • Pin 3 an 3,3V
  • Widerstand mit 4k7 zwischen Pin 2 und 3

Software

Entgegen älteren Beschreibungenn müssen folgende Änderungen eingebracht werden:

zusätzlich in /boot/config.txt:

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

zusätzlich in /etc/modules:

wire
w1_gpio pullup=1
w1_therm

Die Messwerte findet man in /sys/bus/w1/devices/Seriennummer/w1_slave in der 2. Zeile hinter “t=” als Angabe in °mC

*RaspPi als Terminalserver

Man kann einen RaspberryPi als Terminal-Server für andere Pi einsetzen.

Über diesen Terminal-Server kann man die Boot-Meldung des zu überwachenden Pi mitlesen und sich auch auf den Pi einloggen, wenn keine Netzwerkverbindung besteht.

Der Einsatz von Terminal-Servern ist im professionellen Bereich weit verbreitet (entweder externe Terminal-Server oder im Server eingebaute Überwachungsrechern (z.B. ILO)).

Konfiguration des RaspberrryPi:

  • Wheezy:

In der Datei „/etc/inittab“ folgende Zeile auskommentieren:

T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

  • Jessie:

systemctl stop serial-getty@ttyAMA0.service #kurzzeitig deaktivieren

bzw.

systemctl disable serial-getty@ttyAMA0.service #auch nach Neustart deaktiviert

In der Datei „/boot/cmdline.txt“ folgenden String löschen:

console=ttyAMA0,115200 kgdboc=ttyAMA0,115200

damit folgende Zeile übrigbleibt:

dwc_otg.lpm_enable=0 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

Installation einer Terminal-Emulation
apt-get install screen

Nun kann man den Pi herunterfahren und die Serielle Verbindung zwischen Terminal-Server und zu überwachendem Pi herstellen:

GPIO-Pin der beiden Pi folgdendermaßen verbinden:

6 mit 6 8 mit 10 10 mit 8

Nach dem Einschalten des Terminal-Servers startet man das Terminal mit:

sudo screen /dev/ttyAMA0 115200 8N1

Beendet wird das Terminalfenster mit:

STRG+A K y

Erweiterungsmöglichkeiten:

Über die GPIO kann z.B. auch die Spannungsversorgung geschaltet werden.

Hiermit ist eine Fernentstörung eines abgesetzt betriebenen RaspberryPi möglich.

* Anzeige und Speicherung der Temperatur

Nachdem wir beim letzten Mal die Software für den Temperatur-Sensor BMP180 installiert haben, wollen wir nun die gemessenen Werte anzeigen und Speichern.
Zum Anzeigen benötigen wir zusätzlich „xterm“, das uns die Möglichkeit bietet, das Terminalfenster offen zu halten.
sudo apt-get install xterm
Die Anzeige der Messwerte erfolgt durch aufruf folgender Befehlsfolge:
xterm -hold -e sudo python /home/adafruit/Adafruit_Python_BMP/examples/simpletest.py 2>/dev/null &

Nun Wollen wir die Werte speichern.
Zunächst legen wir ein Script mit dem Namen temperatur.sh im Verzeichnis /home/pi/bin an:
(Falls dieses Verzeichnis noch nicht besteht: mkdir /home/pi/bin)

#!/bin/bash
druck=`/usr/bin/python /home/adafruit/Adafruit_Python_BMP/examples/simpletest.py | grep Pressure| grep -v Sea| cut -d” ” -f3`
zimmer_temp=`/usr/bin/python /home/adafruit/Adafruit_Python_BMP/examples/simpletest.py | grep Temp| cut -d” ” -f3`
zeit=`date +”%F %T”`
echo “$zeit;$zimmer_temp;$druck” >> /tmp/temperatur.txt

chmod +x /home/pi/bin/temperatur.sh

Als nächstes wird in die crontab des User root folgende Zeile eingefügt, damit das Script regelmäßig (hier alle 5 min) aufgerufen wird:
echo “*/5 * * * * /home/pi/bin/temperatur.sh” >> /var/spool/cron/crontabs/root
/etc/init.d/cron restart

Die Messwerte können wir nun mit
cat /tmp/temperatur.txt
anzeigen

* SD-Karte schonen

Man kann Daten zwischenspeichern, ohne sie auf die SD-Karte zu schreiben. Dies ist angebracht, wenn oft Daten geschrieben werden, die aber nach einem reboot nicht mehr zur Verfügung stehen müssen.

Hierfür ist das Verzeichnis /tmp vorgesehen.

Damit /tmp nicht die SD-Karte nutzt, sondern den Speicher des Rechners, muß in der /etc/fstab folgende Zeile hinzugefügt werden:

tmpfs     /tmp    tmpfs   defaults     0    0

* Laß den Raspberry reden

Zur Sprachausgabe kann man “espeak” verwenden.

Installation als root:

apt-get install espeak

Aufruf:

espeak “0 1 2 3 4 5 6 7 8 9 10”

espeak -v de “0 1 2 3 4 5 6 7 8 9 10”

Erläuterungen sind zu finden unter:

http://espeak.sourceforge.net/

* QR-Code erzeugen

Zum Erzeugen der pixeligen Quadrate kann man “qrencode” verwenden:
sudo apt-get install qrencode
Aufruf:
qrencode -t ANSI “http://www.z64.vfdb.org”
Näheres siehe “man qrencode”

* Installation eines Web-Servers

Heute wollen wir einen Apache2-WebServer installieren.

Zusätzlich wollen wir ihn um ein CMS auf Basis von Joomla ergänzen.

Hierfür müssen wir uns das Joomla-Paket aus dem Internet laden und in /tmp zwischenspeichern.
Benötigt werden noch php und mysql, die via apt-get installiert werden.

sudo bash
apt-get update
apt-get upgrade
apt-get install apache2
apt-get install php5
apt-get install mysql-client mysql-server
apt-get install php5-mysql php5-curl

cd /var/www
mkdir joomla
mv /tmp/Joomla_3.3.4-Stable-Full_Package.zip joomla
cd joomla
unzip *
cd ..
chmod 755 joomla -R

Die Dateien der Web-Site liegen unter /var/www.
Der User, unter dem der Web-Server läuft lautet www-data.
Wir können als User root die Dateien bearbeiten oder mit “su – www-data” den User wechseln.
In einem ersten Schritt passen wir die Datei /var/www/index.html an.

* Sicherung der SD-Karte

Es gibt mehrere Möglichkeiten, seine konfigurierte SD-Karte zu sichern:

  1. Auf dem Winows-Rechner mit dem Imageing-Tool, mit dem man auch das Grundimage auf die Karte gespielt hat.
  2. Auf einen Linux-Rechner mittels des Befehls “dd”
  3. Die Sicherung der Daten mit “tar”
  4. Sicherung einzelner Verzeichnisse/Dateien mit “rsync”

Hier jetzt eine genauere Beschreibung der verschiedenen Abläufe:

1.wie beim ersten Aufspielen eines Images auf die SD-Karte, aber nicht “restore” sondern “backup”

Hierbei kann es vorkommen (ist mir passiert), daß das Image, das von einer 8GB-SD-Karte gezogen wurde, nicht auf eine andere 8GB-SD-Karte gepaßt hat; daher am Besten gleich von der Sicherung eine neue SD-Karte erstellen.

2. dd if=”xxx” of=”yyy”
Hierbei ist “xxx” die zu sichernde Partition und “yyy” der Dateiname, unter dem diese Partition gesichert wird.

3. Mit “tar” wird kein Abbild der SD-Karte (wie bei den beiden erstgenannten Punkten) erzeugt; es werden nur die Dateien gesichert, was zu einer Platzersparnis auf dem Zielsystem führt.
Ich verwende folgendes Script zur Sicherung:

#!/bin/bash
# 2014_01_25

d=`mount | grep “/dev/sdb1″| cut -d” ” -f3`
e=`mount | grep “/dev/sdb2″| cut -d” ” -f3`

ln -s $d /media/boot_tmp
ln -s $e /media/data_tmp

b=`cat /media/data_tmp/etc/hostname`
mkdir /media/hd1/IMAGES/$b
c=`date +%Y%m%d`
mkdir /media/hd1/IMAGES/$b/$c

cd /media/boot_tmp
tar -cf /media/hd1/IMAGES/$b/$c/boot.tar .
cd /media/data_tmp
tar -cf /media/hd1/IMAGES/$b/$c/data.tar .

cd /media
rm /media/data_tmp
rm /media/boot_tmp

Hierbei wird der Rechnername aus der Datei /etc/hostname ausgelesen und die beiden Partitionen der Raspian-SD im Verzeichnis /media/hd1/Images/Rechnername/Datum gespeichert.

Zum Zurückspielen der Daten muß die neue SD-Karte zwei Partitionen enthalten, kann aber auch kleiner sein, als die ursprüngliche SD-Karte (sollte aber die gespeicherten Daten aufnehmen können).

#2 Partitionen anlegen
sfdisk /dev/sdb << EOF
,8,c
,,83
EOF
#2.Partition als ext4 formatieren
mkfs.ext4 /dev/sdb2
#Partition 1 mit dd zurückspielen
cd /media/hd1/IMAGES/org
dd if=sdb1 of=/dev/sdb1
#Partition 2 mit tar zurückspielen
mkdir /media/restore_2
mount /dev/sdb2 /media/restore_2/
cd /media/restore_2/
tar -xf /media/hd1/IMAGES/raspberrypi/20141001/data.tar .
#Aufräumen
cd /
umount /dev/sdb1
umount /dev/sdb2
rmdir /media/restore_2

4. “rsync” ist ein kleines Tool, mit dem man einfach den Datenbestand zwischen zwei Rechnern abgleichen kann:
/usr/bin/rsync -av 192.168.1.2:/home/wetter /HD/WetterServer
Hier wird z.B. vom Rechner mit der IP-Adresse 192.168.1.2 das Verzeichnis (mit all seinen Dateien) /home/wetter auf den lokalen Rechner in das Verzeichnis /HD/WetterServer kopiert.
Genaueres siehe “man rsync”

* Anwendung: Ausschalten über GPIO

Zum Ausschalten eines Linux-Rechners sollte man ihn nicht direkt von der Spannungsversorgung trennen, sondern vorher alle laufenden Programme definiert beenden.

Hierfür gibt es in Linux mehrere Möglichkeiten:

  • shutdown
  • init 0

Wenn man sich jedoch nicht in den Rechner einloogen will, um das Kommando einzugeben, kann man die GPIO des RaspberryPi verwenden.

Hierzu wird ein Schalter zwischen Pin 5 und 6 montiert, dessen Stellung über ein Script abgefragt wird und bei entsprechendem Zustand den Rechner definiert herunterfahren läßt.

Zuerst muß die GPIO-Schnittstelle als Input konfiguriert werden:

echo “3” > /sys/class/gpio/export
echo “in” > /sys/class/gpio/gpio3/direction

Da dies nur beim ersten Aufruf geschehen muß, wird über eine “if-Abfrage” geprüft, ob die Schnittstelle schon konfiguriert ist oder nicht:

if [ ! -e /sys/class/gpio/gpio3 ]
then
……
fi

Danach wird der Wert eingelesen (1=high, 0=low) und der Variablen a zugewiesen:

a=`cat /sys/class/gpio/gpio3/value `

Wenn der Wert “0” ist, wird der Befehl zum Herunterfahren des Rechners erteilt:

if [ $a = 0 ]
then
/sbin/shutdown -h now
fi

Da nur ein User mit root-Rechten diesen Befehl absetzten darf, muß der User root dieses Script ausführen. Der Rechner soll aber nicht nur damit beschäftigt sein, die Schnittstelle abzufragen. Deshal soll das Script nur einmal pro Minute laufen.

Dies wird erreicht durch folgenden Eintrag in der crontab des Users root:

* * * * * /root/bin/gpio3.sh

Hier nochmals das Script  “/root/bin/gpio3.sh”:
#!/bin/bash
if [ ! -e /sys/class/gpio/gpio3 ]
then
echo “3” > /sys/class/gpio/export
echo “in” > /sys/class/gpio/gpio3/direction
fi
a=`cat /sys/class/gpio/gpio3/value `
if [ $a = 0 ]
then
/sbin/shutdown -h now
fi

Für das Programm kann jeder GPIO verwendet werden.

Der Vorteil von Pin3 und 5 ist, daß hier die Pins schon intern mit einem Pull-Up-Widerstand nach high gezogen werden und daher eine sehr einfache Beschaltung mit nur einem Schalter, der die Verbindung zu Masse herstellt, möglich ist.

Bei Verwendung eines anderen Pins bitte an einen externen Widerstand zwischen Schalter und 3,3V denken.

* Wichtige Dateien: crontab

Verwendungszweck

Starten von zu bestimmten Zeiten auszuführenden Programmen

Ort: /var/spool/cron/crontabs  ; je User eine eigene Datei

Anzeige des Dateiinhaltes: crontab -l
(eigene crontab, ist aus jedem Verzeichnis aufzurufen)

Bearbeiten des Dateiinhaltes: crontab -e
Es wird der Defaulteditor geöffnet; wenn man einen anderen Editor verwenden will, muss man diesen der globalen Variable VISUAL übergeben z.B. export VISUAL=vi

Beschreibung:

Es werden sechs Werte in eine Zeile eingetragen:

  1. Minute
  2. Stunde
  3. Tag des Monats
  4. Monat
  5. Wochentag (1=Montag)
  6. auszuführender Befehl (bis Zeilenende, auch mit Leerzeichen)

Beispiel:

33 12 * * 6 /home/bin/jobs
Am Samstag um 12:33 wird der Befehl ” /home/bin/rsync_jobs ” ausgeführt

*/3 * 1-7 * 1 /testbefehl
Alle 3 Minuten (0, 3, 6, 9, 12, …) wird am ersten Montag jedes Monats  “/testbefehl” ausgeführt.

* Konfiguration der GPIO-Ports

Zur Konfiguration der GPIO-Ports gibt es Module u.a. in Python.
Man kann aber auch direkt aus der bash heraus auf die Ports zugreifen.
Die entsprechenden Dateien befinden sich im Verzeichnis /sys/class/gpio
Zuerst gibt man an, welchen GPIO-Port man konfigurieren will (hier als Beispiel Nr.17, Pin 11):

echo “17” > /sys/class/gpio/export

Danach gibt man an, ob dieser Port Output oder Input ist:

echo “in” > /sys/class/gpio/gpio17/direction

echo “out” > /sys/class/gpio/gpio17/direction

Danach kann man bei Input auslesen, ob High oder Low anliegt:

cat /sys/class/gpio/gpio17/value

bzw. den Port auf High oder Low schalten:

echo “1” > /sys/class/gpio/gpio17/value

echo “0” > /sys/class/gpio/gpio17/value

Abschließend kann man den Port wieder dekonfigurieren:

echo “17” > /sys/class/gpio/unexport

GPIO-Tabelle

GPIOPinPinGPIO
3,3V125V
SDA12345V
SCL1356GND
PCLK047814TX
GND91015RX
17111218PCM_CLK
PCM_DOUT271314GND
22151623
3,3V171824
SPI_MOSI101920GND
SPI_MISO9212225
SPI_SCLK1123248CE0
GND25267CE1
ID_SD2728ID_SC
52930GND
6313212
133334GND
19353616
26373820
GND394021

* Raspberry Pi

Der Raspberry Pi ist ein kleiner, preiswerter Einplatinencomputer der in England entwickelt wurde, um Schulkindern die Computertechnik näherzubringen.

Von den großen Desktop-PC unterscheidet er sich durch:

  1. Betriebssystem: Linux
  2. Kosten: z.Zt. ca 30€
  3. Externes Netzteil (Handynetzteil mit 5V/1,5A)
  4. Massenspeicher: (Mikro-)SD-Karte
  5. GPIO-Leiste: IO-Anschlüsse, die über eine 26- (40-)polige Steckerleiste nach Außen geführt sind und folgende Schnittstellen zur Verfügung stellt:
    1. I2C-Bus
    2. SPI
    3. UART
    4. digitale IO mit 3,3V
  6. Anschluß für eine 5MPixel Kamera
  7. Ein gemeinsamer Chip für USB und 100Mb/s-LAN-Anschluß, daher nicht für hohen Datendurchsatz geeignet.

Es gibt 7 verschiedene Modelle des Raspberry Pi (die roten werden nicht mehr hergestellt)

  1. Model A:  256 MB RAM, kein LAN-Anschluß, nur 1 USB, 26-polige GPIO-Leiste
  2. Model B v1: 256 MB RAM, LAN-Anschluß, 2 USB, 26-polige GPIO-Leiste
  3. Model B v2: 512 MB RAM, LAN-Anschluß, 2 USB, 2 Befestigungslöcher, 26-polige GPIO-Leiste, SD-Kartenleser
  4. Model B+: 512 MB RAM, LAN-Anschluß, 4 USB, 4 Befestigungslöcher, 40-polige GPIO-Leiste, microSD-Kartenleser
  5. Model 2 B: 1 GB RAM, ARM Cortex-A7, microSD-Kartenleser, sonst wie B+
  6. Model 3 B: 1 GB RAM, ARM Cortex-A53, 2,4GHz WLAN b/g/n, Bluetooth 4.1 Low Energy, sonst wie B+
  7. Model ZERO: 512 MB RAM, Kein LAN! microSD-Kartenleser, je eine Micro-USB Buchse für Stromversorgung und Daten [über Micro-USB Adapter (OTG)], voll 40-polige GPIO-Leiste, Mini-HDMI

Zum Betrieb wird noch folgendes benötigt:

  1. Spannungsversorgung: 5V über USB-Mikro-Anschluß (z.B. Handy-Ladegerät, ab 1A)
  2. (Mikro-)SD-Karte ab 2 GB für das Betriebssystem
  3. LAN-Kabel oder USB-WLAN-Stick
  4. Monitor mit HDMI- oder Cinch-Anshluß (oder Fernseher mit einem dieser Anschlüsse)
  5. USB-Tastatur und -Maus

Zum Betreiben als Server (z.B. Webserver, WLAN-Cam) werden nur 1 bis 3 benötigt.

Installation des Betriebssystem

  1. Download von http://www.raspberrypi.org/downloads/
  2. Verschiedene Distributionen:
    1. Raspbian (Debian)
    2. Raspbmc (XBMC Media Center)
    3. Pidora (Fedora)
    4. u.a.
  3. Image auf SD-Karte spielen z.B. mit Win32DiskImager
  4. Erstkonfiguration durchführen
    1. raspi-config: Tastatur, Ortszeit, aktivierte Schnittstellen
    2. apt-get update: Vorstufe zu apt-get upgrade
    3. apt-get upgrade: installierte SW-Pakete werden auf den aktuellen Stand gebracht
  5. Sicherung der SD-Karte
    1. Wenn man die SD-Karte mit dem DiskImager sichert, kann es passieren, daß man es auf eine gleichgroße Karte nicht installieren kann, da diese um einige Byte kleiner sein kann.

* Linux-Befehle

Hilfe:
man apropos help whatis info

Zu fast jedem Befehl existieren Schalter, die ihm mit einem “-” angefügt sind.
Am Besten die verschiedenen Befehle mit “man Befehl” erkunden.

Einloggen und Filetransfer:
ssh rechnername/-ip   bzw. ssh username@rechnername/-ip
sftp rechnername/-ip  bzw. sftp username@rechnername/-ip

Passwortloses Einloggen: ssh-keygen ssh-copy-id

Dateibearbeitung:
ls                          Anzeige des Verzeichnisinhaltes
cd                         Wechseln in Verzeichnis
cat, less, more    Anzeige des Inhaltes einer Datei
mv, cp                  Datei/Verzeichnis verschieben, kopieren
find                      Datei finden
ln                          Link anlegen
file                        Emitteln der Art einer Datei

Datensicherung:
tar
dd
rsync

* Linksammlung

Hier einige Links, die beim Arbeiten mit dem Raspberry Pi helfen können:

  • http://www.raspberrypi.org/         Die Raspberry Pi Foundation
  • http://www.themagpi.com/           Online-Magazin in englischer Sprache mit Anleitungen
  • http://www.adafruit.com/              Tutorials und Bauanleitungen
  • http://www.gtkdb.de/                     Good to know database in deutscher Sprache hilft bei vielen Problemen mit Computern