Apr 02

OpenwebRX / WebSDR aufsetzen

Elektronik, Fun, Ham, Linux Kommentare deaktiviert für OpenwebRX / WebSDR aufsetzen

Ziel: Einen SDR aufsetzen, der per Browser erreichbar ist.

Am Ende dieser Anleitung hat man einen WebSDR wie bspw. diesen: https://sdr.dj7nt.de

Neben der eigentlichen WebSDR-Funktionalität, bietet openwebRX u.a. die Möglichkeit, dass WSPR/FT8/FT4/etc. Signale automatisch im Hintergrund dekodiert und auch an die entsprechenden Portale wie pskreporter.info / wspr.rocks weitergeleitet werden. Sehr schön um Langzeitstudien des eigenen QTHs / der eigenen Antenne durchzuführen.

Zutaten:

  • Raspberry Pi 3 oder 4
  • Netzteil für den Pi (5V / 1,5A)
  • SD-Karte (min. 4 GB)
  • SDR-Hardware (Auswahl)
    • RTL-SDR (Für den Anfang ok, aber recht instabil / unsensitiv)
    • SDRPlay (RSPdx bspw.)
    • HackRF
    • PlutoSDR
    • …
  • PanAdapter, sofern der SDR an derselben Antenne wie der Shack-TRX betrieben werden soll
  • USB-Kabel
  • Antennenkabel

Kochrezept:

Zunächst openwebrx herunterladen und das ZIP entpacken. Anschliessend den “Raspberry Pi Imager” herunterladen und starten. Dort dann unter “OS wählen” die image-Datei aus dem openwebrx-ZIP auswählen. Da es einige – wenige – Dinge gibt, die wir direkt auf dem Pi ohne das WebInterface zu Anfang erledigen müssen nun auf das Zahnrad unten rechts clicken.

Hier kann bspw. der Hostname u.a. angegeben werden. Wichtig ist aber, dass ein Haken bei “SSH aktivieren” angeclickt wird, und bei “Benutzername und Passwort setzen”. Benutzername/PW ist frei wählbar, sollte man sich jedoch merken 😉

Wer fit in der Linux-Welt ist, kann natürlich auch seinen SSH-PublicKey hinterlegen. WiFi-Konfiguration kann man machen, muss man aber nicht. Ich bin ein Freund von LAN-Kabeln. Ist stabiler als WLAN.

Nun kann man die SD-Karte einlegen und im Imager die korrekte Karte auswählen. Anschliessend auf “schreiben” drücken. Jetzt wird das openwebrx-Image auf die Karte geschrieben.

Aufbau der Hardware hier wie folgt:

Während all das passiert können wir uns der Hardware widmen. Ich nutze hier einen SDRPlay-RSPdx, aber wie oben beschrieben funktioniert auch ein günstiger (<20 Euro) RTL-SDR-Stick. Beim RTL-SDR wird – um die Kurzwellenbänder zu Empfangen – noch ein UpConverter benötigt. Beispielsweise der HamItUp von Nooelec.

Szenario: SDR soll die selbe Antenne wie der Transceiver nutzen:

Blockschaltbild

Kurze Erklärung: Der Panadapter sorgt dafür, dass der SDR zur Antenne durchgeschaltet wird, so lange der TRX nicht auf Sendung ist. Wird am TRX PTT gedrückt, trennt der Panadapter instant das Signal zum SDR. Wird nicht gesendet, so bekommen sowohl SDR als auch TRX das Antennensignal. Ich habe mich für einen simplen Panadapter aus China entschieden. Bei meinem Model musste noch ein Jumper umgesteckt werden, damit die Trennung auch vollzogen wird. Der Adapter verfügt über eine HF-VOX (ich traue diesen VOX-Dingern nicht) oder aber über einen PTT-Cinch-Anschluss womit man den Adapter mit dem TRX verbinden kann (die aktuellen Transceiver haben alle ein PTT-Out). Es empfiehlt sich das ganze unbedingt vor Anschluss des SDRs zu testen. Im Worstcase geht die volle Leistung des TRX nämlich sonst in den SDR – und das wird der garantiert nicht mögen

Szenario: SDR bekommt eine eigene Antenne:

Das alles entfällt natürlich, wenn man dem SDR eine eigene Antenne gönnt. In dem Falle wird die (eigene) Antenne einfach an das SDR-Gerät geklemmt, und der SDR per USB an den RaspberryPi und fertig.

Der erste Start / Boot:

Nachdem alles wie oben beschrieben verkabelt/angeschlossen ist (LAN nicht vergessen ;), können wir den Pi das erste mal mit Strom über die USB-Buchse versehen. Sobald der Raspberry hochgefahren ist, suchen wir uns die IP-Adresse die das Gerät bekommen hat. Hier gibt es mehrere Wege, die von der Architektur des (Heim-)Netzwerks abhängen:

  • Suchen des Geräts in der Fritzbox/Speedport/Plastikrouter der die IPs im LAN vergibt und jeweilige IP merken.
  • Je nach Netzwerk ist der Pi sogar schon über den o.g. Hostnamen (siehe Kochrezept, zweiter Absatz) erreichbar.

Ein kurzer Test ob das Gerät anpingbar ist (ping [hostname] (s.o.) bzw. ping [IP] auf der Kommandozeile des PC’s/Mac) gibt Aufschluss ob die Maschine erreichbar ist. Jetzt wird es – für nicht Linuxer – ganz kurz etwas komplexer, denn wir müssen auf dem Pi einen neuen Nutzer/Kennwort für das Websdr anlegen.

Nutzer anlegen

Linux und Mac-User haben es einfach, hier wird ein Terminal/Shell aufgemacht und anschliessend kann man sich per ssh [user]@[hostname] (user/hostname bitte den verwenden, der unter Kochrezept Absatz 2 vergeben wurde) auf den Pi verbinden.

Als Windowsnutzer wird noch ein SSH-Client benötigt. Als Leichtgewichtig hat sich Putty herausgestellt. Also herunterladen und unter Host den Hostnamen bzw. die IP-Adresse eintragen, sowie anschliessend unten im Fenster auf “Connect”/”Verbinden” drücken.

Ist man auf der Shell des Pis angekommen, lässt sich nun ein Nutzer anlegen. Das geschieht durch die Eingabe des folgendes Befehls/Kommandos:

sudo openwebrx admin adduser adminuser

Es wird also ein neuer (Web-)Nutzer mit dem Namen “adminuser” angelegt. Andere Namen sind natürlich auch möglich. Nach dem Abschicken des Befehls fragt das Tool nach einem zu vergebenden Passwort. Ist das erledigt, kann man die Shell wieder schliessen (logout).

Damit wäre das komplizierteste geschafft.

Login/SetUp/Test

Unter http://[hostname oder IP] kann man sich nun auf dem WebSDR einloggen. Der zuvor genannte Admin-Nutzer wird für den Login der Settings-Seite (oben rechts im Webinterface) benötigt. Dort lassen sich Bänder/Profile und Co. für die jeweiligen SDR-Empfänger einstellen. Wer hier tiefer einsteigen mag, dem sei die Doku von openwebRX ans Herz gelegt. Auch Funktionen wie die eingangs erwähnte Dekodierung der DigiModes ist dort erklärt.

Weitere Dinge, wie bspw. Update des Raspberries oder explizite Konfiguration der SDRs sind in der Regel nicht erforderlich. Die Images von openwebRX werden sehr häufig aktualisiert, sodass man an sich immer eine aktuelle Version bei der Installation vorfindet. Die SDRs werden direkt beim booten erkannt, Feineinstellungen können über die bereits erwähnte Settings-Seite (Zahnrad oben rechts) erledigt werden.

Settings-Seite von openwebRX

Viel Spass mit dem eigenen WebSDR

Fallstricke:

Ein kleiner “Annex” über die Fallstricke, die es beim aufsetzen geben kann:

Problemggf. Abhilfe
Stick wird nicht erkannt– Stick im Webinterface nicht aktiv(iert) -> Aktivieren
– Pi neu booten
– tiefere Analyse auf der Shell durchführen (lsusb, syslog, etc.)
– Stick ggf. inkompatibel
WebSDR nicht aus dem Internet erreichbarWar auch nicht Teil dieser Anleitung 😉
Stichpunkte zum googlen / selber erarbeiten:
portforwarding, fritzbox, dyndns, ...
Bänder in der Auswahl fehlenBänder unter Setttings / passender SDR hinzufügen
Wasserfall zu “rot”/”dunkel”In Settings / “SDR Devices & Profiles” / passender SDR mit dem Wert “Gain” herumspielen
SDR wird erkannt, aber es wird kein/ein zu gedämpftes Signal angezeigtIn Settings / “SDR Devices & Profiles” / passender SDR über “Additional / Optional Settings” den richtigen Antenneneingang wählen (bspw. bei SDRPlay oder Geräten mit mehreren Antenneneingängen)
Dekodierung/Spotting funktioniert nicht.In Settings die Einstellungen zum “Background-Decoding” sowie “Spotting und Reporting” prüfen. Ferner unter “SDR Devices & Profiles” / passender SDR einen “Scheduler” hinzufügen und bei “Run Background-Services” einen Haken setzen.
Tagged with: • • • • • • • • • •
Nov 16

POSTDATA mit mod_perl im Falle von chunked Posts

Allgemein, Linux, Work Kommentare deaktiviert für POSTDATA mit mod_perl im Falle von chunked Posts

Eure modperl2-Scripte verschlucken im Legacy-Mode (CGI-Emulation) POSTDATA wenn der Client den Payload mit “Transfer-Encoding: chunked” abkippt und ihr diesen per “my $payload=$cgi->param(‘POSTDATA’)” einsammelt?

Probiert mal folgendes: ($r ist das Apache::RequestRec-Object, dass Ihr per “shift” am Anfang des Scripts einsammelt könnt)

        my $content = '';
        my $cnt=0;
        my $offset=0;
        do {
                $cnt = $r->read($content,8192,$offset);
                $offset += $cnt;
        } while($cnt > 0);

Bei mir hats geholfen. Wenn man den Payload per read einsammelt, dann “dechunked” mod/perl den Kram automagisch.

Tagged with: • • • • • •
Apr 15

LongMessages vs Concatenated via SMSC

Linux, Netz, Work No Comments »

Kurzer Merker für mich (Bezgl.: Endgeräte werden in bestimmten Konstellationen bei überlangen SMS zugespammt.)

Beim Versand von SMSsen über UCP/EMI (Command 51) gibt es zwei Möglichkeiten wie man mit “überlangen” SMS (>160 GSM-Chars) umgehen kann:

  1. Concatenated Messages. Man teilt die Messages in 160er Chunks auf und sendet im UDH (User Data Header) folgendes für die Einzelteile:
    1. 0x00 = Concatenated Message
    2. 0x03 = Länge des Infoelements (Folgt jetzt)
    3. 0xC0 = Referenz-ID (kann ausgewürfelt werden. Ist Unique auf Receipient und diese ID)
    4. 0x02 = Anzahl der einzelnen Mulitpart-SMSsen
    5. 0x01 = Diese Message ist Part 1 von dem was in Byte 4 steht.
  2. LongMessage (Feature muss SMS-C seitig aktiviert sein). In dem Falle geht das Ding mit dem Standard UDH in einem Block raus (Maximale Länge ist beim SMSC zu erfragen – in meinem Fall waren 550 Chars durchaus machbar)

So, und nun wird es spannend.

Acknowledgehandling

Im Fall 1 wird

  • jeder einzelne Part fein vom SMSC eingequed,
  • ans SS7 überstellt und
  • für jeden einzelnen Part ein ACK generiert – SS7 generiert das Acknowledge, wenn die (Teil-)Message beim Empfänger angekommen ist, und übergibt das ACK dann ans SMSC welches dieses per UCP/EMI an mich weitergibt.

Das ist ne ziemlich zeitaufwendige Angelegenheit, die man wirklich extrem spürt. Der Durchsatz SMS/sec ist halt nur 1/n so groß wie wenn ich nur eine 160er Nachricht versende (n=Anzahl der Parts).

Fall 2 ist da schon (vermeintlich) eleganter. Wir überstellen den “Blob” ans SMS-C und bekommen (bei erfolgreicher delivery) genau ein ACK zurück. Und hier liegt der Hase im Pfeffer. Aufgefallen ist mir das ganze, weil es Empfänger gibt, die sich bei mir über nicht aufhörend wollende SMSsen beschwert haben (Empfänger bekommt die selbe SMS wieder und wieder. Hört so gut wie nicht auf. 2000 sind keine seltenheit). Also der Sache auf den Grund gegangen:

  1. die LongMessages werden per UCP/EMI mit ACK-Req (ohne geht nicht) ans SMSC übergeben.
  2. SMSC schiebt die LongMessage ans SS7 durch.
  3. SS7 merkt “Oh, ne LongMessage” und splitted die in 160er Chunks (Auch wenn es LongMessages gibt. GSM/SMS kann – egal wie – nur 160er Chunks)
  4. Gleichzeitig schiebt das SS7 ein(!) ACK ans SMS-C zurück, wenn der erste Part zugestellt wurde.
  5. ACK kommt via UCP/EMI bei mir an

Schaut man sich das jetzt genauer an, stellt man fest, dass das ACK schon beim ersten erfolgreichen Zustellversuch des ersten Chunks kommt. Jetzt gibt es da draussen irgendwelche irren Endgeräte, die das ACK in genau diesem Fall nicht sauber senden. Mit dem unschönen Nebeneffekt, dass das SMSC für die nicht geackten Chunks immer wieder dem SS7 auf die Füße tritt (“Send nochmal”). Je nach unglücklicher Konstellation ist das Endgerät nun in einem ewigen loop.

Fragt mich bitte nicht, warum das im Fall 1 nicht auch passiert. Laut meinem SMSC Kontakt liegt es am Zusammenspiel SMSC/SS7. Einzige Abhilfe war, alles auf MuPart umzustellen. Mit all den häßlichen Nebenwirkungen bezgl. Durchsatz und Co.

Ich denke die einzige Alternative dagegen wäre es, sich selbst ein SS7-Account zu besorgen. Ob man das aber will (zum rumspielen bestimmt mal gerne – aber produktiv)…

 

Vielleicht hat ja einer meiner Leser da ein paar mehr Hintergründe (Jetzt bitte kein: Nimm doch SMPP. Hat sich nämlich rausgestellt, dass überall wo “Simple” im Protokollnamen vorkommt, es alles andere als Simpel ist. Stehe nicht so auf irre XML/SOAP-Requests)

Tagged with: • • • • • • • • • • •
Mai 25

MX Master Scrollwheel unter Linux

Linux 1 Comment »

Die Logitech MX-Master ist eine echt nette Maus, die ich im täglichen Job schon seit letztem Jahr nutze. Unter Linux gefiel mir allerdings das Scrollverhalten der Ratte nie so richtig (zu langsam). Zeit sich damit mal auseinander zu setzen. Alle Ansätze mit “installiere imwheel” oder irgendeine andere Zusatzsoft waren nicht zufriedenstellend. Da ich eh mit xbindkeys arbeite muss es auch damit gehen. Die Lösung dazu also wie folgt:

Über die ~/.profile remappen wir die “Buttons” die beim betätigen des Scrollwheels (Bt. 4 und 5) gefeuert werden auf die nicht existenten Buttons 10 und 11:

logitech_mouse_id=$(xinput | grep "Logitech MX Master" | sed 's/.*id=([0-9]+).*/1/')
xinput set-button-map $logitech_mouse_id 1 2 3 10 11 6 7 8 9

In die ~/.xbindkeysrc folgendes (Handler, der auf den virtuellen Mousebuttons 10 und 11 – die wir vorher remapped haben, das Scrolling legt):

# Mouse Scroll up
"xdotool click --repeat 3 --delay 1 4"
b:10

# Mouse Scroll Down
"xdotool click --repeat 3 --delay 1 5"
b:11

Tagged with: • • • • • • • • • • • •
Apr 23

Websockets behind Apache

Linux, Work No Comments »

node.js ist nett. Vor allem, wenn man auf WebRTC/Sockets setzt. Komplex wird es, wenn man das ganze hinter einem Apache betreibt. Habe jetzt 2h damit verbracht die WS irgendwie an den internen node prozess weiterzuleiten, ohne dass socket.io sich verschluckt. Damit nicht der Nächste vor dem selben Problemchen steht und Stunden versenkt, hier der relevante Teil der apache-conf:

Annahmen:

  • Der interne node.js-prozess horcht auf Port 6543
  • Alles was Websocket ist, wird via /socket.io abgewickelt und hat auch den Transportheader auf “websocket”

<IfModule mod_proxy.c>
  RewriteEngine On
  ProxyVia On
  ProxyRequests Off
  ProxyPreserveHost on
  
  RewriteCond %{REQUEST_URI}  ^/socket.io            [NC]
  RewriteCond %{QUERY_STRING} transport=websocket    [NC]
  RewriteRule /(.*)           ws://internal.etherpad.ip:6543/$1 [P,L]
  ProxyPassReverse /socket.io ws://internal.etherpad.ip:6543/socket.io
  
  RewriteCond %{REQUEST_URI} !^/p/
  RewriteCond %{REQUEST_URI} !^/static/
  RewriteCond %{REQUEST_URI} !^/ep/
  RewriteCond %{REQUEST_URI} !^/minified/
  RewriteCond %{REQUEST_URI} !^/api/
  RewriteCond %{REQUEST_URI} !^/ro/
  RewriteCond %{REQUEST_URI} !^/error/
  RewriteCond %{REQUEST_URI} !^/jserror
  RewriteCond %{REQUEST_URI} !/favicon.ico
  RewriteCond %{REQUEST_URI} !/robots.txt
  
  ProxyPass / http://internal.etherpad.ip:6543/ 
  ProxyPassReverse / http://internal.etherpad.ip:6543/
  <Proxy *>
    Options +FollowSymLinks -MultiViews
    AllowOverride All
    Order allow,deny
    allow from all
  <Proxy>
<IfModule>

Tagged with: • • • • • • • • •
Dez 13

ipv6 via SIXXS und Telekom // Multihoming

Linux, Netz No Comments »

Hat man zwei ipv6-uplinks ist es wichtig, dass Connections die über Provider “A” reinkommen, auch über Provider “A” wieder rausgehen. Mit den default-settings ist das nicht der Fall. Wenn dort etwas via “A” reinkommt, die default-route aber “B” ist, versucht der Router die Antwortpakete via “B” rauszurouten. Das geht idR schief, da der ISP meint man würde die IP faken. Aber es gibt Abhilfe:

Folgendes SetUp nehmen wir mal an:

ppp0 (Telekom): 2003:1::2 mit aktiver default gw ppp0
eth0 (sixxs): 2001:2::2 mit NICHT aktiver default-GW 2001:2::1

Alles was nun via eth0 (hinter dem der sixxrouter irgendwo hängt) reinkommt, will linux via ppp0 beantworten.

Lösung: Eine rule anlegen:

echo "100 sixxs" >> /etc/iproute2/rt_tables
/sbin/ip -6 rule add from 2001:2::/64 lookup sixxs
/sbin/ip -6 route add default via 2001:2::1 dev eth0 table sixxs

Der Output von route und rule sollte am Ende dann wie folgt aussehen:

router:~# ip -6 rule
0:  from all lookup local 
16383:  from 2001:2::/64 lookup sixxs 
32766:  from all lookup main

router:~# ip -6 route
2001:2::/64 dev eth0  proto kernel  metric 256 
2003:1::2 dev ppp0  proto kernel  metric 256 
default via fe80::10ca dev ppp0  metric 1024  initcwnd 10 initrwnd 10

router:~# ip -6 route list table sixxs
default via 2001:2::1 dev eth0  metric 1024

 

Tagged with: • • • • • •
Mai 31

Ganze Netze bei ipv6 mit fail2ban blocken

Allgemein, Linux, Netz No Comments »

ipv6 ist nett. Aber der User bekommt halt jedes mal idR ein /64 Subnet. Für so Tools wie fail2ban, die einzelne IPs blocken, wenn irgendetwas komisches auftaucht irgendwie schlecht. Der Angreifer schnappt sich halt irgendeine neue IP, denn die unteren 64bit stehen ja voll zu seiner Verfügung.

Jetzt verhält es sich mit dem originalen fail2ban so, dass das nicht mal ipv6 kann. Zeit sich auf die Suche zu machen. In einem github-Repo bin ich fündig geworden. Der gute Mensch hat fail2ban so erweitert, dass es v6-fähig wird. Also flugs mal installiert, um direkt die Ernüchterung zu spüren: Es blockt mit /128 🙁

Also erweitern:

Die /etc/fail2ban/action.d/iptables-46-multiport-log.conf passen wir wie hier in diesem gist sichtbar an. Hinzugekommen ist lediglich <mask> bei der ban und unban-Regel sowie unter init. Das bedeutet, dass – sofern nicht anders angegeben – immer eine /32er CIDR-Mask gelegt wird, also die gesamte v4-IP (bei v6 halt ebenfalls /32 – aber dazu später mehr) geblockt wird.

Da die fail2ban-Variante von “usrweiss” im Wrapperscript nicht so granular zwischen v4 und v6 differenzieren kann, als dass wir da andere cidr-Masken drauflegen könnten, legen wir einfach in der /etc/fail2ban/jail.conf ZWEI Jails an:

[web_v4]
enabled = true
filter  = web_v4
action = ip64tables-multiport-log[name=web_v4, protocol="tcp", port="80,443", mask=32]
logpath = /var/log/apache2/web_f2b/fails.log
maxretry= 5
bantime = 60
findtime= 60

[web_v6]
enabled = true
filter  = web_v6
action = ip64tables-multiport-log[name=web_v6, protocol="tcp", port="80,443", mask=64]
logpath = /var/log/apache2/web_f2b/fails.log
maxretry= 5
bantime = 60
findtime= 60

Die benötigen wiederrum auch 2 Configs in der /etc/fail2ban/filter.d:

/etc/fail2ban/filter.d/web_v4.conf:

# Fail2Ban configuration file
#
#
# $Revision: 250 $
#

[INCLUDES]

[Definition]

failregex = Applikation: v4 (<HOST>) Detaillierte Fehlermeldung .*

/etc/fail2ban/filter.d/web_v6.conf:

# Fail2Ban configuration file
#
#
# $Revision: 250 $
#

[INCLUDES]

[Definition]

failregex = Applikation: v6 (<HOST>) Detaillierte Fehlermeldung .*

Der Haken ist, dass unsere Applikation, die die Events auslöst (hier eine Loginseite, die die Fehlversuche nach /var/log/apache2/web_f2b/fail.log wegschreibt) an die Zeile dranschreiben muss, ob es sich um v4 oder v6 handelt. Bezogen auf die o.g. Configs sieht das in dem fail.log der App so aus (Von der Applikation generierte Einträge. Erster: v6, zweiter v4)

[May 31 10:08:12] Applikation: v6 (2a03:2880:2130:cf05:face:b00c:0:1) fehlerhafter Loginversuch blabla
[May 31 10:09:12] Applikation: v4 (173.252.120.6) fehlerhafter Loginversuch blabla

Von nun an blockt fail2ban die Ports 80 und 443 sobald in der Logdatei der Applikation (/var/log/apache2/web_f2b/fail.log) 5 mal innerhalb von 60 Sekunden die selbe IP mit einem Fehler aufschlägt für 60 Sekunden. Und zwar bei einer v4 halt die v4, bei einer v6 das /64er Subnet der v6. Die gerade greifende Netzmaske wird in der/etc/fail2ban/jail.conf als Variable “mask” in der action mit angegeben – sollte dort nichts stehen, gilt der Defaultwert von /32 aus der iptables-46-multiport-log.conf

 

Wie üblich, geht das sicherlich noch eleganter. Bin gespannt, wann fail2ban endlich eine v6-Variante releast.

Tagged with: • • • • • • • • • • • • • • • • • •
Mai 24

Raspberry A Bewegungsmelder reloaded

Allgemein, Linux No Comments »

Wie hier im Blog schon beschrieben, habe ich mir mit einem Pi A einen kleinen Statusscreen gebastelt, der sich immer dann anschaltet, wenn jemand in die nähe des Pi’s kommt. Realisiert wurde das mit der PiCam – basierend auf Helligkeitsänderungen beim Snapshot. Soweit so gut. Seit 2 Monaten hängt sich der olle Pi jedoch regelmässig auf. So schlimm, dass ich Ihm einen crontab-Eintrag verpasst habe, mit dem er jede Nacht neu bootet.

Zeit der Sache mal auf den Grund zu gehen. Das Problem war: Zu wenig RAM. Der Pi A hat gerade 256MB davon (eigentlich mehr als genug, für soetwas). Dummerweise hängt in PiCam direkt an der GPU des kleinen Rechners. Was bedeutet, dass man dem Ding in der /boot/config.txt den Parameter gpu_mem=128 mitgeben muss. Heisst: 128MB für die GPU (drunter funktioniert die cam nicht) und 128MB für das OS. Sofern man nun nicht eine extraschlanke Distribution mit busybox und dem ganzen Small-Mem-Footprint-gedönse nutzt, ist das verdammt mau. Erst recht mit der extrem aufgeblasenen Raspianedition.

Also mussten Lösungsansätze her. Die Cam mit weniger als 128MB GPU-RAM zu betreiben funktioniert also schon mal nicht. Dann halt komplett anders.  Für gerade mal 1,10 Euro/Stück gibt es bei Amazon PIR-Sensoren. PIR steht für Pyroelektrische Passive Infrarot Sensoren. Die Dinger, die man aus den Bewegungsmeldern an Aussenlampen kennt. Das besondere an diesen PIRs ist, dass sie out-of-the-box mit dem Pi über GPIO spielen können.

Obwohl das Chinaware ist, ist es relativ gut dokumentiert. In dieser Grafik findet sich alles, was man wissen muss:

Wir sehen zwei Potentiometer, mit denen man die Empfindlichkeit und eine Art “Nachlaufwert” einstellen kann. Den Timer stellt man am besten auf “0” (Anschlag ganz links), das “Distanz”-Poti nach Gusto. Nun zum elektrischen:

  • VCC bei dem Ding ist 5V – der kommt also an PIN2 des GPIO’s (+5V OUT)
  • GND auf GND – PIN 6
  • OUT ist der PIN, der “HIGH” wird, wenn sich was vor dem Sensor bewegt. Und coolerweise spuckt das Ding ca. 3,3V aus – also genau richtig für den GPIO. Den hängen wir an GPIO18 (PIN 12)

Hier eine Übersicht der GPIO-PINs des raspis:

Nach dem das nun alles Erledigt ist, geht es zum simpleren Teil. Der Software. Ich habe das ganze, wie bereits beim Cam-Script in Python realisiert:

#!/usr/bin/python
import subprocess
import os
import time
import RPi.GPIO as io
from datetime import datetime
delay=60
monitor='on'
pir_pin = 18
io.setmode(io.BCM)
io.setup(pir_pin, io.IN)         # activate input

def turnMonitorOn(extrarg):
  global monitor
  monitor='on'
  subprocess.call("/usr/bin/screen.sh on "+extrarg, shell=True)

def turnMonitorOff(extrarg):
  global monitor
  monitor='off'
  subprocess.call("/usr/bin/screen.sh off "+extrarg, shell=True)
   
# Reset last capture time
lastCapture = time.time()
# added this to give visual feedback of camera motion capture activity.  Can be removed as required

while True:
  time.sleep(0.5)
  if io.input(pir_pin):
    lastCapture = time.time()
    if (monitor == 'off'):
      turnMonitorOn("y")

  if (time.time()-lastCapture > delay):
    if (monitor == 'on'):
      turnMonitorOff('x')

In der Variable “delay” kann man einstellen, wie lange der Screen nach einer Bewegungserkennung angeschaltet bleiben soll. Es sind natürlich auch andere Pins als GPIO18 möglich (bspw. GPIO4 / Pin7)

Das Shellscript, “screen.sh” ist dasselbe, wie im Cam-Post:

#!/bin/bash
tvstat=$(tvservice -s |grep off)
if [[ $tvstat == *off* ]]; then
TV=OFF
else
TV=ON
fi

if [ "$1" == 'on' ] && [ "$TV" == "OFF" ]; then
/usr/bin/tvservice -p;
#fbset -depth 8;
#fbset -depth 16;
chvt 2;
sleep 1
chvt 1;
chvt 2;
chvt 1;
#echo 'Switched Screen ON!'
fi
if [ "$1" == 'off' ] && [ "$TV" == "ON" ]; then
/usr/bin/tvservice -o
echo 'Switched Screen OFF!'
fi

Nun noch in der /boot/config.txt den Wert gpu_mem auf 32 oder gar 16 stellen, rebooten, und wir haben wieder mehr als genug RAM. Dass die CAM nun nicht mehr funktioniert, sollte jedem klar sein – aber das war ja auch Sinn und Zweck der Sache.

Tagged with: • • • • • • • • • • • • • • •
Apr 26

1wire mit dem Pi

Allgemein, Linux, Wetterstation No Comments »

Ich betreibe hier seit über einem Jahrzehnt ein paar von diesen netten günstigen Dallas-1-Wire Dingern (DS1820) an einer Linuxkiste mit samt USB-Host-Adapter im sog. “Parasite-Mode” (Ausser GND und Data benötigt man da nichts, und kann ein paar von den Sensoren – an bspw. im Haus liegenden Telefonkabeln – abfragen).

Der USB-Host-Adapter ist eigentlich überflüssig, da der Pi das mit seinen GPIO’s von Haus aus kann. Und das ganze ist derartig trivial, dass ich es hier kurz erklären will. Man nehme:

  • den o.g. DS1820 (da gibts div. Variationen von, die sich in der Präzision unterscheiden – kosten ca. 2 Euro)
  • Einen Pi – mit Linux drauf.

 

Den 1820 wie folgt mit dem Pi verbinden:

GND auf GND // Vdd auf 3,3V // VDQ (Data) auf GPIO 4

(Hier eine Ansicht des 1820, und hier eine des GPIO-Ports vom Pi)

Dann ab auf die Shell und kurz 2 Kernel-Module nachladen:

 pi@rasbberrypi ~ $ sudo modprobe w1-gpio pullup=1
 pi@rasbberrypi ~ $ sudo modprobe w1-therm

Wenn alles richtig gelaufen ist, gibt es unter /sys/bus/w1/devices nun ein neues Verzeichnis mit der Unique-ID des 1820 (Die haben alle eine Art Mac-Adresse, die die einmalig macht) in dem wiederum eine Datei mit dem Namen “w1_slave” liegt. Angenommen der 1820 hat die ID “28-0000041234567” so heisst unsere Datei : “/sys/bus/w1/devices/28-000004593386/w1_slave”. Wenn man sich diese anzeigen lässt (zB via cat), kommt (etwas unsexy) der platte Temperaturwert als ASCII zum Vorschein.

Den hübschen wir nun noch auf, und schon haben wir einen Wert, den man weiterverarbeiten kann (snmp, website, wo auch immer):

cat /sys/bus/w1/devices/28-000004593386/w1_slave |\
grep -e 't=' | \
awk -F't=' '{print $2}'

Günstiger kann man keine Temperaturen messen – und erweiterbar und flexibel ist es auch noch. (Es sei denn man will unbedingt 100 Euro für das neueste, hippe, bunte Temperaturmessdevice, dass nur mit App läuft, ausgeben und die Werte alle Nasen lang in die Cloud pumpen…)

Tagged with: • • • • • • • • • • • • • • •
Dez 26

Logging auf dem PiStatus-Monitor

Linux No Comments »

In einem der tmux-Fenster des letzten Beitrags läuft ein tail auf das squid-access.log.
Dummerweise zeigt das tail nach einem logrotate nichts mehr an, da das Filehandle vom tail ja auf das “rotierte” log zugreift.
Fein wäre doch ein kleines Script, dass, sobald im geöffnet Filehandle nichts mehr kommt, die Datei “reopened” und dann weiter anzeigt.

Bitte sehr (Perl // Modul File::Tail vorrausgesetzt):

#!/usr/bin/perl
use File::Tail;
use Socket;
use strict;
$|=1;
my $logfile="/var/log/squid-access.log";
my $file=File::Tail->new(name=>$logfile, maxinterval=>300, adjustafter=>7);
while (defined(my $line=$file->read)) {
        my @liner=split(' ',$line,-1);
        my $host='';
        $host=gethostbyaddr(inet_aton($liner[8]), AF_INET) or $host=$liner[8];
        my @hostname=split(/./,$host); # Split FQDN at dots
        $host=$hostname[0];             # Get Lowest Domainname
        my @hosts=split(/./,$liner[8]);# Split IP at dots
        my $loctet=$hosts[3];           # Get last Octet
        printf "%s %3s %st%sn",$liner[2],$loctet,$host,$liner[12];
}

Das Ding zieht gleichzeitig die wichtigsten Infos aus dem Log. Nämlich den Timestamp, das letzte Octet der IP, sowie den ersten Part des Reverse-DNS-Namens.

Tagged with: • • • • • •
Dez 23

Statusscreen mit dem Pi und Bewegungserkennung

Linux No Comments »

Es ist mal wieder Zeit für ein kleines Urlaubsprojekt.
Hier lag seit 3 Jahren, neben einem RaspberryPi und nem alten 17″ Eizo-Screen, so ein Wandhalter für TFT-Screens herum. Da kann man doch was raus machen.

Also fix den Wandhalter an die Wand gedübelt und den Pi mit NFS-Root (siehe Eintrag hier) aufgesetzt.
Der Pi selbst ist mit dem Cam-Modul ausgestattet, und hängt per HDMI 2 DVI an dem o.g. Eizo.

Folgende Ziele habe ich verfolgt (und umgesetzt):
– Autologin nach reboot, sowie automatisches einloggen auf nem Server und attachen an tmux
– Sobald sich was vor der Cam bewegt, soll der Monitor “aufwachen”, nach 60s. wieder ausgehen.

Ist an sich recht einfach. Fangen wir mal mit dem Autologin an:
via /etc/inittab sagen wir dem Pi, dass er sich – anstelle des logins – auf dem tty1 als “pi” einloggen soll:

#1:2345:respawn:/sbin/getty --noclear 38400 tty1
1:2345:respawn:/bin/login -f pi tty1 /dev/tty1 2>&1

Dazu die obere Zeile auskommentieren, und die untere einfügen.
Nach einem reboot sollte der pi nun direkt auf der Shell als User “pi” landen.
Alles weitere (ssh-login) und Co. machen wir in der ~pi/.bashrc (letzte Zeile einfach anfügen)

ssh -t [user]@[machine wo tmux rennt] "tmux att"

Nun sollte nach dem Reboot (ssh-keys und laufender tmux auf “machine” vorrausgesetzt) direkt der tmux erscheinen. Den kann man dann vom “normalen” Rechner aus mit content bestücken (top, iftop, tail aufs log, etc.)

Wer noch Hintergrundbild und höhere Auflösung auf dem pi haben möchte, dem seit fbterm ans Herz gelegt.

Weiter gehts mit der “Motiondetection”. Dazu habe ich mir erstmal ein kleines Shellscript gebaut, welches den Monitor an/ausschalten kann, und dieses unter /usr/bin/screen.sh abgelegt:

#!/bin/bash
tvstat=$(tvservice -s |grep off)
if [[ $tvstat == *off* ]]; then
TV=OFF
else
TV=ON
fi

if [ "$1" == 'on' ] && [ "$TV" == "OFF" ]; then
/usr/bin/tvservice -p;
#fbset -depth 8;
#fbset -depth 16;
chvt 2;
sleep 1
chvt 1;
chvt 2;
chvt 1;
#echo 'Switched Screen ON!'
fi
if [ "$1" == 'off' ] && [ "$TV" == "ON" ]; then
/usr/bin/tvservice -o
echo 'Switched Screen OFF!'
fi

Nicht von den chvt verwirren lassen. mit tvservice wird der Monitor an/ausgeschaltet, mit chvt auf das entsprechende (Virtuelle) Terminal umgeschaltet. Quasi das Shell-pendant zu “ALT-F1 bis ALT-F10” zum Console wechseln. Ohne das hin- und herschalten via chvt geht der Moni zwar an, aber es wird nichts angezeigt.

Die eigentlich Motiondetection ist in Python gebastelt (wie üblich: Kurz und schmutzig):

#!/usr/bin/python
import StringIO
import subprocess
import os
import time
from datetime import datetime
from PIL import Image
threshold = 10
sensitivity = 180
monitor='on'

# Capture a small test image (for motion detection)
def captureTestImage():
    command = "raspistill -n -w %s -h %s -t 1 -e bmp -o -" % (100, 75)
    imageData = StringIO.StringIO()
    imageData.write(subprocess.check_output(command, shell=True))
    imageData.seek(0)
    im = Image.open(imageData)
    buffer = im.load()
    imageData.close()
    return im, buffer

def turnMonitorOn():
  global monitor
  monitor='on'
  subprocess.call("/usr/bin/screen.sh on", shell=True)

def turnMonitorOff():
  global monitor
  monitor='off'
  subprocess.call("/usr/bin/screen.sh off", shell=True)

# Get first image
image1, buffer1 = captureTestImage()
# Reset last capture time
lastCapture = time.time()
# added this to give visual feedback of camera motion capture activity.  Can be removed as required
while (True):
    # Get comparison image
    image2, buffer2 = captureTestImage()
    # Count changed pixels
    changedPixels = 0
    for x in xrange(0, 100):
        # Scan one line of image then check sensitivity for movement
        for y in xrange(0, 75):
            # Just check green channel as it's the highest quality channel
            pixdiff = abs(buffer1[x,y][1] - buffer2[x,y][1])
            if pixdiff > threshold:
                changedPixels += 1
        # Changed logic - If movement sensitivity exceeded then
        # Save image and Exit before full image scan complete
        if changedPixels > sensitivity:   
            print "change "+monitor
            lastCapture = time.time()
            if (monitor == 'off'):
                turnMonitorOn()
            break
        continue
    if (time.time()-lastCapture > 60):
  if (monitor == 'on'):
          turnMonitorOff()

    # Swap comparison buffers
    image1  = image2
    buffer1 = buffer2

Wenn man das Ding nun laufen lässt, macht es im dauerloop ein Bild in niedriger Auflösung von der Cam, und vergleicht die Helligkeitswerte mit denen des vorherigen Pics. Ist der Unterschied grösser als “threshold”, dann macht das Script den Monitor an. Nach 60s ohne Bewegung wird er wieder ausgeschaltet.
Jetzt nur noch das Script mit “start-daemon” in ein init.d Script packen und beim booten automatisch starten, und fertig.

Wie immer gibt es zig Wege dahin, dies ist nur einer von vielen. Das ganze kann man sicher noch immens optimieren. Für hier ist es mehr als in Ordnung.

Tagged with: • • • • • • • •
Jun 10

Umstieg auf Android // Ein paar Erfahrungen

Allgemein, Linux, Netz 6 Comments »

Schreibe hier mal nach und nach ein paar hilfreiche Erfahrungen auf, wenn man – wie ich – den Schritt von IOS nach Android wagt, und von der ganzen Cloud-Struktur nicht so viel hält.

Ein wenig eigene Infrastruktur je nach Geschmack (Mailserver, CAL-/CARDDAV-Server, Proxy mit adblocker nach gusto, eigener DNS) sollte es jedoch schon sein, wenn man die wichtigsten Daten von der Cloud fernhalten möchte. Das war unter ios so, und gilt unter Android mehr denn je. Also los gehts mit den Basics:

  • Mails: Da eignet sich K9-Mail ganz gut – ist etwas anders als Mail.App zu bedienen, kann aber nach meinen Vertestungen am meisten
  • Kalendersync: CalDAV-Sync integriert den eigenen CalDAV zu 100% in die Android-Welt, und das ganz ohne gmail-Kalender. Reminder und Co. funktionieren sauber!
  • Telefonbuch: CardDAV-Syncfree synct wunderfein die Kontakte mit dem heimischen CardDAV-Server (zum einsatz kommt hier übrigens davical)
  • Notizen: Werden bei ios/osx als “spezielle Mail” in einem Subfolder mit Namen “Notes” abgelegt. Da gibts was günstiges für den Droiden: iNotes – nicht von der Beschreibung im Store verwirren lassen, der spielt echt mit jedem imap (hier ist der gute alte cyrus im Einsatz)
  • Twitter: Tja. Da bin ich noch nicht so ganz weiter. Tweetbot gilt nach wie vor als ungeschlagen. Aber Tweetveo kommt zumindest schon mal etwas dran. [Update 10.06.14] Plume isses ! Tweetmarker-Support. Suchen nach Antworten – also all das was Tweetbot auch kann – zumindest auf den ersten Blick. Danke an @bridgerdier [Update 05.12.2014] Fenix ist der Twitterclient der Wahl
  • Newsreader: Original tt-rss Client für tinytiny – geht doch 🙂

Nun bringt das alles herzlich wenig, wenn man die Äpps auf dem Device, sowie das OS nicht einigermassen abschotten kann. Und an dem Punkt kommt Cyanogenmod – das mich überhaupt bewegt hat, von IOS nach Android zu wechseln – ins Spiel. Nicht ganz trivial zu installieren (Grobe Vorgehensweise: Bootloader unlocken, CWM/TWM aufspielen, Image installieren) aber in der Version 11 (Analog KitKat) sehr empfehlenswert. So lässt sich jede Äpp beliebig kastrieren (Bis hin zu: “Darf die App vibrieren?” und so). Ein Feature das google seit 4.4.2 wieder ausgebaut hatte. Hier isses drin. Und das ganze CM11 ist echt stabil.

Wer dann den Droiden noch weiter abschotten möchte, dem sei (CM11 bzw. root vorrausgesetzt) noch Droidwall ans Herz gelegt. Ganz platt gesagt ist Droidwall ein Frontend für iptables mit dem man pro Äpp sagen kann, ob diese überhaupt ins Netz darf. Heisst: Wenn ich bspw. ne Taschenlampe installiere, dann braucht die mal definitiv keinen Netzzugriff… Logging gibts gratis obendrauf.

Ansonsten macht AdFree von BigTinCan noch den solidesten Eindruck. Warum das Teil von einer sehr dubiosen Website kommt, nicht im Playstore verfügbar ist und überhaupt, weiss wohl niemand. Habe dieses Ding ausgewählt, weil es ganz simpel die /etc/hosts um einschlägige Werber ergänzt, und echt nicht mehr anstellt. Alles andere wollte direkt Nutzungsdaten und Co. nach Hause funken. Dieses schicke kleine APK macht genau das was es soll (Werbung fernhalten – und das auch noch relativ elegant).

[Update 11.06.14] Mit IOS8 soll es ein Update geben, bei dem das iPhone die Mac-Adresse des WLAN-Interfaces randomisiert während es keinerlei Connect zu einem WLAN hat. Löbliches Feature. Geht mit dem Droiden natürlich auch. Guckst du Pry-Fi im Playstore. Das das Teil root-Rechte benötigt, liegt auf der Hand.

Am meisten weggetan hat das Messaging. Kenne ich doch recht viele ios-iMessage Menschen. Da gibt es leider nur Pest oder Cholera als Ersatz. Facebook möchte ich nun nicht gerade in Form von WhatsApp beglücken, also hab ich mich neben SMS für Google-Hangouts entschieden. Ob bei Kurznachrichten jetzt Apple oder google mitliest ist da relativ. (Nur FB sollte es halt nicht sein). Das ganze Thema Messaging ist extremst unbefriedigend, sowohl unter ios als auch unter Android. Diesen ganzen Placeboteile wie Threema und wie sie nicht alle heissen kann man auch nicht trauen (ist halt kein opensource). Daher gibts hier halt einen Kompromiss.

Wenn jemand noch weitere Tips hat, immer gern her damit.

Gesucht wird bspw. noch:

  • PodFetcher
  • FeedReader (Gut, Feeds lese ich hauptsächlich auf dem iPad – aber wer weiss: Vielleicht kommt da ja auch irgendwann mal ein Droide hin)
  • …
Tagged with: • • • • • • •
Jan 25

GPG / PGP Key beglaubigen

Allgemein, Linux, Netz No Comments »

Gaaaanz kurze knackige Anleitung, wie man einen PGP/GPG Key beglaubigt  bzw. signiert (unvollständig, und OHNE Anleitung, wie man den Key auf korrektheit prüft – idealerweise signiert Ihr nur Keys, bei denen Ihr 100%ig sicher seid, dass diese auch vom passenden Keyowner kommen 🙂 )

Shell:

[gpg –list-keys] Pub-Key-ID des zu signierenden keys merken

[gpg –sign-key <pubkeyid>] Das eigentliche Signieren

[gpg –send-keys <pubkeyid>] Signieren dem Keyserver bekanntmachen

OSX / GPGTools:

  • GPG Schlüsselbund (GPG Keychain) starten.
  • Rechte Maustaste auf den zu signierenden Key
  • Beglaubigen anclicken, Details entsprechend wählen und OK drücken
  • Wieder rechte Maustaste, diesesmal “Öffentlichen Schlüssel an Schlüsselserver senden”

Der letzte Punkt – also das Veröffentlichen der Beglaubigung, wird gern vergessen. Ohne diesen Schritt ist das ganze jedoch recht witzlos.

[UPDATE]

Bei mehreren uids (Identitäten) pro Key:

  • Doppelclick auf den Key in der Keychain-GUI
  • Wechsel auf den “Benutzer-ID”-Tab
  • Zu bestätigende Identität OBEN auswählen
  • Unten auf das Plus clicken und beglaubigen
  • Anschliessend wieder raus, und “Öffentlichen Schlüssel an Schlüsselserver senden” (s.o.)
Tagged with: • • • • • • • • • • • • •
Jan 12

Tiny Tiny RSS updated nicht mehr

Linux, Netz No Comments »

TT-RSS an sich ist ja eine feine Sache. Das Ding hat allerdings ein/zwei Haken, wenn man es für mehrere Leute hosted. Ich nutze das hier mit dem Fever-Plugin, damit man die Feeds auch einigermassen elegant auf mobilen Endgeräten nutzen kann.

Meist ist es ja so, dass $user sich eine Feedliste zusammenstellt, und sich dann Wochenlang nicht mehr ins Frontend einloggt (Hab ich beim Google-Reader damals™ auch so gemacht). Das nimmt einem ttrss aber übel. Denn nach 30 Tagen (Einstellbar in der ./include/rssfuncs.php // Zeile 2) sagt sich ttrss: Nee, der User hat sich seit 30 Tagen nicht mehr eingeloggt, dann update ich halt nicht mehr. Pikanterweise zählt der Fever-Login nicht (Plugins verwalten Ihre Daten “irgendwie” anders – PHP-Magic halt).

Also merken: Wenn tt-rss nicht mehr updatet, entweder:

  • Zeile 2 der ./include/rssfuncs.php anpassen und hochdrehen (Halte ich für nicht so super)
  • Den/Die User/in anhalten, sich von Zeit zu Zeit mal ins Frontend einzuloggen
  • Oder (superschmutzig), per Hand das Feld last_login in der tabelle ttrss_users auf “NOW()” updaten.

 

Tagged with: • • • • • • • • •
Mai 19

RasberryPi mit XBMC via NFS mit 32MB SD-Card

Fun, Linux 2 Comments »

Eigentlich hab ich mich ja immer gewehrt den schönen “Experimentiercomputer” RaspberryPi zum “MediaCenter” zu degradieren. Andererseits hatte ich ein wenig Not hier. Bis vor 2 Jahren hatte ich ‘nen MacMini am TV-Gerät. Der ist dann irgendwann rausgeflogen und musste einem AppleTV (3) weichen.

Dummerweise kann das ATV3 sich nur bei Apple bedienen. Sprich alle fein säuberlich gekauften Filme und MP3s auf dem Fileserver konnten nur umständlich abgespielt werden, in dem immer irgendein olles iTunes auf dem Arbeitsplatzrechner lief. Zeit das zu ändern. Also Pi bestellt und RaspBMC draufgeknallt. Erster Begeisterung folgte direkt die Ernüchterung. Zu langsam, und zu buggy. Wenn bspw. der Pi hängt, hilft nur noch Strom raus und wieder rein, was die SD-Karte mit “Could not mount Root-FS” oder so quittiert. Blöd alles. Doch es gibt eine Lösung für alles.

Ziel sollte es sein im Raspberry nur noch den Bootloader auf der SD-Karte zu haben (den braucht der leider, da der Pi kein Bootp/PXE beherrscht), und diese am besten auch noch mit ‘nem Schreibschutz zu versehen. Gesagt getan. Was ist also notwendig?

  • 2GB SD-Karte fürs erste Setup
  • 32MB SD-Karte für den späteren Betrieb
  • Fileserver mit NFS-fähigkeit
  • Irgend ‘ne Linux-Büchse um die Karten entsprechend zu präparieren (Mit OSX oder Windows ist das echt Schmerz)

Vorgehensweise:

  1. RaspBMC ganz normal auf der 2GB Karte installieren (dd if=[imagefile] of=/dev/sdz bsize=16M) wobei sdz das SD-Kartendevice ist.
  2. Rasbperry ans Netz hängen und booten/Erstkonfig durchführen.
  3. Während der konfiguriert setzen wir den NFS-Server auf (gehe mal davon aus, dass die Grundlagen zu NFS dem Leser bekannt sind)
    1. Directory, in dem das Rasberry-Rootfs wohnen soll erstellen (mkdir /rasberryrootfs)
    2. Directory in die /etc/exports aufnehmen:/rasberryrootfs          IP.VOM.RASP.BERRY(rw,async,no_root_squash,no_subtree_check,anonuid=65534,anongid=65534,insecure)
    3. exportfs -rv aufrufen
  4. Wenn Raspberry fertig, dann:
    1. per ssh einloggen (pi/raspberry)
    2. xbmc stoppen: sudo sudo initctl xbmc stop
    3. NFS-Filesystem mounten: mount IP.VOM.FILE.SERVER:/raspberryrootfs /mnt
    4. Kram umkopieren (sudo cp -axv /. /mnt/.
      sudo cp -axv /dev/. /mnt/dev/.      )
    5. In der /mnt/etc/fstab folgende Zeile AUSkommentieren (also ein “#” davorschreiben):
      /dev/mmcblk0p2  /               ext4    defaults,noatime 0       0
    6. NFS-Filesystem umounten (sudo umount /mnt)
    7. Raspberry herunterfahren (sudo init 0)
    8. Karte entnehmen und in die o.g. Linuxbüchse stecken, sowie das vfat-Filesystem der Karte mounten.
    9. Kram aus dem vfat-Filesystem irgend wo auf die Platte kopieren.
    10. Karte umounten / Brauchen wir jetzt nicht mehr.
    11. Jetzt die 32MB Karte in die o.g. Linuxbüchse stecken und ein vfat-Dateisystem auf einer Primären Partition vom Typ “MSDOS/VFAT” erstellen.
    12. Den Krempel aus 9 auf die Karte kopieren.
    13. Jetzt noch die Datei cmdline.txt auf der 32MB Karte wie folgt anpassen:
      dwc_otg.lpm_enable=0 root=/dev/nfs rootfstype=nfs nfsroot=192.168.1.100:/raspberryrootfs,v3 ip=192.168.1.49:192.168.1.1:192.168.1.0:255.255.255.0:rpi:eth0:off smsc95xx.turbo_mode=N noatime rootwait loglevel=1 zram.num_devices=2
      Wobei folgendes gilt:

      1. Anstelle der 192.168.1.49 die IP des Raspberrys eintragen
      2. Anstelle der 192.168.1.100 die IP des NFS-Servers eintragen
      3. Anstelle der 192.168.1.1 die IP des Routers eintragen
      4. Anstelle der 192.168.1.0 die Netztadresse des Heimnetzes eintragen
    14. Karte umounten
    15. In den Pi stecken, und freuen 🙂

Wenn alles klappt, noch den nupsi für den Schreibschutz an der 32MB Karte aktivieren, und dann geht das Filesystem dort garantiert nicht mehr kaputt. Noch ein paar Tipps/Anmerkungen zur Performance von dem XBMC:

  • Alle überflüssigen Visualisierung sollten (so schick sie auch sein mögen) deaktiviert werden.
  • Krimskrams wie Samba-Server, Avahi, ftp auf dem Pi auch deaktivieren.

Viel Spass damit.

Tagged with: • • • • • • • • • •
Previous Entries
preload preload preload