Im Rahmen vom Free 4 Review konnte ich das WRTNode testen In den folgenden Kapitel findet Ihr Informationen zum Board wie auch persönliche Erfahrungen beim realisieren der folgenden Projekte:

• Netzwerkintegration
• Ansteuern von Ausgängen (blink)
• Eingänge auslesen
• Webserver steuert Ausgänge und liest Sensoren
• DNLA Musik Abspieler per Smartphone

Leider gibt es noch nicht sehr viele Informationen über den WRTNode, die offiziellen Wiki Seiten sind sehr bescheiden und auch im offiziellen Forum ist nicht viel los. Auch gibt es fast keine konkreten Projekt Beschreibungen. Somit war der Anfang recht schwierig und aus einem Test ist eher eine Forschungsarbeit geworden. Viel Spass beim durchlesen.

Der WRTNode ist ein OpenWrt Board. OpenWrt ist eine GNU/Linux distribution welche für embedded Geräte erstellt wurde und als alternative Firmware für Router zur Anwendung kommt. OpenWrt ist somit sehr stark im Netzwerkbereich. Der WRTNode hat neben seinen Netzwerkfähigkeiten viele I/O Schnittstellen. Hier die Übersicht über die Pin's:

Der WRTNode wird in einer kleinen stabilen Box geliefert.

Im innern der Box befindet sich der WRTNode selber mit einem speziellen USB Kabel, und ein paar Aufkleber.

Wenn der WRTNode eingesteckt wird ist er automatisch als “WLan Access Point” verfügbar.

Somit muss der Computer mit dem eine Verbindung aufgebaut werden soll über Wlan verfügen. Der Wlan AP ist unter dem Namen “WRTnodeXXXX” verfügbar wobei XXXX eine Zahl ist. Das Standard Passwort für die Verbindung ist: 12345678

Sobald der Computer mit dem WRTNode AP verbunden ist kann der WRTNode unter dem Namen i.wrtno.de erreicht werden.

$ping i.wrtno.de

Jetzt kann über den Browser auf die Administrator Oberfläche zugegriffen werden:

http://i.wrtno.de

Oder über SSH / Putty in der Kommando Zeile gearbeitet werden,

Benutzer: root

pw: 12345678

Der WRTNode ist ein richtiger Netzwerk Profi er ist ein “Wireless Access Point” welcher aber auch mit Ethernet/RJ45 umgehen kann. Er enthält eine Firewall welche viele Konfigurations Möglichkeiten bietet.

Zusätzlich kann er sich selber auch in einem anderen WLan anmelden und so den Zugang zum Internet herstellen. In diesem Fall ist es auch möglich den WRTNode vom lokalen Netz über diese “Client” Verbindung anzusprechen ohne direkt selber im WRTNode WLan angemeldet zu sein.

Um den WrtNode an ein anderes Wlan einzubinden kann mit dem Befehl aps mögliche Access Points gefunden werden.

Danach müssen diese Daten in die Datei /etc/config/wireless eingetragen werden.

Mit dem Befehl ia kann dann auch noch überprüft werden ob der Zugang funktioniert hat, oder einfach ein ifconfig aufrufen.

Damit der WRTNode mit Ethernet umgehen kann muss ein spezielles Kabel hergestellt werden:

http://wiki.wrtnode.com/index.php?title=Starting#WRTnode_special_network_cable

Alternativ kann man auch RJ45 Buchsen anschliessen und ist so sehr flexibel.

Hier meine Verkabelung:

WRT Node                Ethernet Port
TX+ (PIN 1,16,18,20)	TX + (1)
TX– (PIN 14,3,5,7)      TX – (2)
RX+ (PIN 15,17,19,21)   RX + (3)
RX – (PIN 2,4,6,8) 	RX – (6)

Hier eine gute Anleitung bezüglich den Ethernet Anschlüssen:

http://www.peatonet.com/en/hazte-tu-propio-router-con-wrtnode-anadiendo-cuatro-puertos-lan-y-un-puerto-wan/

Sobald das Netzerkkabel am Computer angeschlossen ist wird per DHCP eine IP Adresse vergeben:

Und schon kann via SSH auf den WRTNode zugegriffen werden:

Auf dem WRTNode ist ebenfalls ein Ethernet WAN Port verfügbar:

WRT Node 	 Ethernet WAN Port
TX+ (PIN 22)     TX+ (1)
TX– (PIN 9)      TX– (2)
RX+ (PIN 23)     RX+ (3)
RX– (PIN 10) 	 RX– (6)

Da die Anschlüsse mit dem Lan Port 1 übereinstimmen kann der gleiche Adapter auch für den WAN Port verwendet werden:

In der Datei: /etc/config/network finden sich normalerweise zwei VLAN's. Das VLAN 2 werden wir als WAN konfigurieren.

Entweder direkt hier in der Datei unter 'wan'

oder im Web Interface:

Nach dem Editieren der Datei kann über den Befehl /etc/init.d/network restart die neue Einstellung aktiviert werden.

Wenn der Computer am WRTnode als Wifi Access Point verbunden ist dann ist die IP Adresse im Standard folgende: 192.168.8.1

Wenn der WRTnode sich selber mit einem Wifi Access Point verbunden hat dann ist er im lokalen Netz grundsätzlich erreichbar. Jedoch blockiert die Firewall die Verbindung in der Standard Einstellung.

Um das zu umgehen kann in der Firwall eine Port Weiterleitung eingerichtet werden, dazu in der shell die Firewall Konfigurations Datei öffnen:

$vi /etc/config/firewall

Hier jetzt am besten pro Verbindungsytyp/Port einen Eintrag machen, hier als Beispiel die http Verbindung mit Port 80.

Analog kann so eine Portweiterleitung auf für die anderen nötigen Verbindungen angelegt werden, einfach den Parameter src_dport anpassen. Hier die Ports:

• http ⇒ 80
• ssh ⇒ 22
• sshfs ⇒ 222
• dlna ⇒ 6600

Danach muss man noch rausfinden welche IP Adresse der WRTNode vom Wireless Access Point erhalten hat, dazu $ifconfig apcli0 ausführen:

Jetzt einfach die gewünschte Verbindung mit dieser IP Adresse öffnen.

Um die Firewall neu zu starten, folgenden Befehl eingeben:

/etc/init.d/firewall restart

Von einem Linux Computer kann über den folgenden Befehl eine Verbindung zum WRTNode aufgebaut werden:

$ssh root@192.168.8.1

Von einem Windows Computer kann mit Putty eine Verbindung zum WRTNode aufgebaut werden:

Von einem Linux Computer kann das Dateisystem vom WRTNode in das Lokale als Mount eingebunden werden. Danach kann wie auf ein lokales Dateisystem zugegriffen werden. Doch zuvor muss noch das Packet “openssh-sftp-server” installiert werden:

Im lokalen Dateisystem einfach einen Order anlegen der dann als Einstieg für den WRTNode dient, hier /home/user/mnts/dat_wrtnode

Danach kann mit dem Befehl der Mount ausgeführt werden:

$sshfs root@192.168.8.9:/ /home/user/mnts/dat_wrtnode

Falls es mal nicht funktionieren will zuerst nur ssh versuchen. Es kann nämlich sein, dass diese IP bereits in der Datei known_hosts von einem anderen System eingetragen ist, dann funktioniert es nicht mehr weil der “RSA hostkey” nicht übereinstimmt. Der ssh gibt dazu eine Warnung aus, sshfs jedoch nur “read: Connection reset by peer”

Dabei wird auch erklährt wie der falsche key entfernt wird. Danach einfach nochmals mit ssh die Verbindung aufbauen und die Abfrage um den neuen Key aufzunehmen bestätigen.

Jetzt wird auch sshfs funktionieren.

Über jeden Browser ist ein Zugriff auf das LuCI möglich.

Standard Benutzer ist: root und das Passwort ist: 12345678

Einmal angemeldet hat man Zugriff auf viele Informationen und Einstellungen:

Hier die Verbindungseinstellungen im Filezilla:

Damit kann vom Windows auf das gesamte WRTNode System zugreifen.

Der Wrtnode verfügt über einige Skripte zur Konfiguration:

• nr (Network Reset) Neustarten vom der Netzwerk Komponenten
• vw (vi Wireless) Wlan Konfiguration Editieren
• aps (Access Point search) Suche nach Wlan Zugangspunkten
• ia (Ifconfig Access Point) Gibt die Netzwerkinformationen über den Wlan Zugangspunkt aus

Alle diese Kurzbefehle können direkt in der Shell eingegeben werden.

Wichtige Zusatz Software Pakete welche ich genutzt habe:

• php5, php5-cgi > siehe PHP Kapitel Webserver php
• mdp > ein DLNA fähiger Musik Player

Das ist eigentlich was mich am meisten interessiert hat wie kann ich eigene Anwendungen auf dem WRTNode entwickeln und speziell natürlich wie ich mit der Aussenwelt über die Pins arbeiten kann. Dazu muss man sagen dass die GPIO Pins in das Betriebsystem als “Devices” eingebunden sind und man dadurch sehr einfach im Dateisystem darauf zugreifen kann.

Hier meine Erfahrungen, aufgeteilt auf die verschiedenen Technologien.

Der uHTTPd Webserver unterstützt in der Auslieferungskonfiguration kein PHP. Um PHP zu aktiveren, in der Luci Oberfläche unter Software die Packete php5 und php5-cgi installieren.

Dann in der uHTTPd Config die Zeile bei main einfügen:

list interpreter ".php=/usr/bin/php-cgi"

Config Datei mit vi editieren:

$vi /etc/config/uhttpd

Danach den Webserver neu starten:

$/etc/init.d/uhttpd restart

Um PHP zu testen im /www Ordner die Datei phpinfo.php anlegen:

<?php

// Zeigt alle Informationen (Standardwert ist INFO_ALL)
phpinfo();

// Zeigt nur die Module-Informationen.
// phpinfo(8) führt zum gleichen Ergebnis.
phpinfo(INFO_MODULES);

?>

Und im Browser öffnen, und schon läuft PHP auf dem Webserver:

Jetzt wollen wir natürlich mit vom Browser über den Webserver mit der realen Welt in Verbindung treten. Wir möchten mit dem Browser eine LED per GPIO Pin steuern.

dazu legen wir folgende Datei an: /www/gpio.php, damit erhalten wir eine einfache Website mit 2 Links welche Shell Befehle ausführt je nachdem ob welcher Link gedrückt wurde.

<?php
if(isset($_GET['Zustand'])) {
// LED Einschalten
if($_GET['Zustand'] === '1') {
$val = trim(@shell_exec("/root/test/./gpio.sh 0 1")); //GPIO 0 auf 1 stellen
}
// LED Ausschalten
elseif($_GET['Zustand'] === '0') {
$val = trim(@shell_exec("/root/test/./gpio.sh 0 0")); //GPIO 0 auf 0 stellen
}}
?>
<BR>
<center>
<a href="<?php print($_SERVER['PHP_SELF']); ?>?Zustand=1">Led 1 ein</a>
<BR>
<BR>
<a href="<?php print($_SERVER['PHP_SELF']); ?>?Zustand=0">Led 1 aus</a>
</center>

das Shell Script legen wir in folgender Datei an /root/test/gpio.sh

# Blink Example
echo parameter $0 $1 $2
echo $2 > /sys/class/gpio/export
echo out > /sys/class/gpio/gpio$1/direction
echo $2 > /sys/class/gpio/gpio$1/value

Jetzt die gpio.php Datei im Browser öffnen und die Led damit steuern.

Da gleiche Prinzip funktioniert auch für Eingänge, in folgendem Beispiel wird noch ein Digitaler Eingang abgefragt und dann der Zustand per PHP im Browser angezeigt.

gpio.php

<?php 

// LED Status
echo "<center>Status";
$val = trim(@shell_exec("/root/test/./gpioin.sh 2"));
echo "<pre>$val</pre>";

if($val === '1') {
$image = "led_ein.png"; }
if($val === '0') {
$image = "led_aus.png"; }
Echo "<img src=".$image." Style=width:83px;height:80px;></center>";

if(isset($_GET['Zustand'])) {
// LED Einschalten
if($_GET['Zustand'] === '1') {
$val = trim(@shell_exec("/root/test/./gpio.sh 0 1")); //GPIO 0 auf 1 stellen
echo "<pre>$val</pre>";
}
// LED Ausschalten
elseif($_GET['Zustand'] === '0') {
$val = trim(@shell_exec("/root/test/./gpio.sh 0 0")); //GPIO 0 auf 0 stellen
echo "<pre>$val</pre>";
}}
?>
<BR>
<center>
<a href="<?php print($_SERVER['PHP_SELF']); ?>?Zustand=1">Led 1 ein</a>
<BR>
<BR>
<a href="<?php print($_SERVER['PHP_SELF']); ?>?Zustand=0">Led 1 aus</a>
</center>

gpioin.sh

# Input GPIO Example
echo $1 > /sys/class/gpio/export
echo in > /sys/class/gpio/gpio$1/direction
cat /sys/class/gpio/gpio$1/value

Der schnellste und einfachste Weg Funktionen zu realisieren welche mit der Aussenwelt kommunizieren ist über ein Shell Script. Hier ein blink.sh Script. Dazu muss einfach an GPIO 0 eine Led angeschlossen werden.

# Blink Example
echo 0 > /sys/class/gpio/export
echo out > /sys/class/gpio/gpio0/direction
count=0
while [ $count -le 5 ] 
do
echo GPIO 0 ON
echo 1 > /sys/class/gpio/gpio0/value
sleep 1
echo GPIO 0 OFF
echo 0 > /sys/class/gpio/gpio0/value
sleep 1
count=$(( $count + 1 ))
done
echo 0 > /sys/class/gpio/unexport

Um mit Python sieht das ganze so aus, wichtig hier ist damit der Zugriff aufs Dateisystem auch wirklich ausgeführt wird ein fh.flush() aufzurufen. Ansonsten wird das erst nach dem Ende vom Script gemacht.

Den Code mit dem vi Editor in der Datei blink.py anlegen und dann die Berechtigung geben und ausführen:

$vi blink.py

$chmod +x blink.py

$python blink.py

#!/usr/bin/python
import time
try:
   print "Blink Prepare GPIO"
   fh = open('/sys/class/gpio/export', 'w')
   fh.write('0')
   fh.flush()
   fh.close()
except: 
   print "Error: Export GPIO"

try:
   fh = open('/sys/class/gpio/gpio0/direction', 'w')
   fh.write('out')
   fh.flush()   
   fh.close()
except:
   print "Error: DIRECTION GPIO"

try:
   fh = open('/sys/class/gpio/gpio0/value', 'w')
except:
   print "Error: Value GPIO"

count = 0
print "Blink Example"
while (count < 5):
   count = count + 1
   fh.write('1')
   fh.flush()
   print "Write 1"
   time.sleep (1)
   fh.write('0')
   fh.flush()   
   print "Write 0"
   time.sleep (1)
print "End"
 fh.close()

Hier noch ein weiteres Script wobei es eine Schreibroutine und eine Routine zum Öffnen vom GPIO Pin gibt.

#!/usr/bin/python
import time
 
GPI = '0'
 
def write_gpio(gpinr, data):
    try:
        tmp = "/sys/class/gpio/gpio" + gpinr + "/value"
        fh = open(tmp, 'w')
    except:
        print "not open => open GPIO"
        open_gpio(gpinr,'out')
        tmp = "/sys/class/gpio/gpio" + gpinr + "/value"
        fh = open(tmp, 'w')
    fh.write(data)
    fh.flush()
 
def open_gpio(gpinr, gpidir):
    print "Open GPIO"
    fh = open('/sys/class/gpio/export', 'w')
    fh.write(gpinr)
    fh.flush()
    fh.close()
    tmp = "/sys/class/gpio/gpio" + gpinr + "/direction"
    fh = open(tmp, 'w')
    fh.write(gpidir)
    fh.flush()
    fh.close()
 
count = 0
print "Blink Example"
while (count < 20):
   count = count + 1
   write_gpio(GPI,'0')
   time.sleep (0.03)
   write_gpio(GPI,'1')
   time.sleep (0.03)
print "......done"

Das dritte Script hat zusätzlich noch eine Routine um einen GPIO Pin als digitalen Input zu verwenden. Die Routine wird dazu verwendet um auf einen Button zu reagieren. Der Button wird zwischen VC und dem GPIO Pin 1 angeschlossen. Zusätzlich wird noch ein einem Pull Down Widerstand angeschlossen.

#!/usr/bin/python
import time

GPI = '1'

def write_gpio(gpinr, data):
    try:
        tmp = "/sys/class/gpio/gpio" + gpinr + "/value"
        fh = open(tmp, 'w')
    except:
        print "not open => open GPIO"
        open_gpio(gpinr,'out')
        tmp = "/sys/class/gpio/gpio" + gpinr + "/value"
        fh = open(tmp, 'w')
    fh.write(data)
    fh.flush()

def read_gpio(gpinr):
    data = 0
    try:
        tmp = "/sys/class/gpio/gpio" + gpinr + "/value"
        fh = open(tmp, 'r')
    except:
        print "not open => open GPIO"
        open_gpio(gpinr,'in')
    data = fh.read(1)
    fh.flush()
    return data
    
def open_gpio(gpinr, gpidir):
    print "Open GPIO"
    fh = open('/sys/class/gpio/export', 'w')
    fh.write(gpinr)
    fh.flush()
    fh.close()
    tmp = "/sys/class/gpio/gpio" + gpinr + "/direction"
    fh = open(tmp, 'w')
    fh.write(gpidir)
    fh.flush()
    fh.close()

count = 0
value = 0
print "read GPIO1 until value 1/Button pressed"
while (count < 200):
    value = read_gpio(GPI)
    time.sleep (0.1)
    if ('1' in value):
       count = 201
       print "Button pressed"
    count = count + 1
print "Script ended."
    

Wie Ihr wisst verfügt der WRTNode nur über Digitale Ein/Ausgänge um aber trotzdem mit sehr einfachen Mitteln einen Lichtsensor oder Temperatur Sensor anzuschliessen gibt es folgende Möglichkeit. Man baut sich ein RC-Glied auf: http://de.wikipedia.org/wiki/RC-Glied

In unserem Fall sieht die Schaltung so aus:

Damit nie zu viel Strom fliesst wird noch ein 2.2 KOhm Widerstand eingesetzt. Diese Schaltung ist nicht sehr genau und auch von der Umgebungstemperatur abhängig aber um zu erkennen ob das Licht vergessen wurde auszuschalten genügt es längst. Damit

Wir haben 3.3 Volt in der Schaltung, der Digitale Eingang schaltet bei ca. 2 Volt auf HIGH. Das sind ungefähr 60% der Spannung. Das entspricht fast genau dem Wert in der RC Schaltung bei welchem die Formel gilt: t = T.

Damit der Kondensator bei jeder Messung wieder entladen ist wird der GPIO Pin jeweils zuerst auf GND gesetzt und erst danach auf Digital IN um zu erkennen wie lange es geht bis 60% der Spannung erreicht ist.

Um also an den Widerstand zu kommen, ersetzten wir T = R x C.

Das gibt dann eine Formel: t = R x C. Wir wollen R wissen was R = t/C gibt.

Hier vorab schon die Resultate meiner kleinen Messreihe, es ist also mit 10% Ungenauigkeit zu rechnen. Wenn das in der Anwendung keine Rolle spielt ist dieser Ansatz gut zu gebrauchen. Bei dem Test mit dem kleinsten Widerstand stört sicher der 2.2 KOhm Widerstand dieser ist nämlich in der Formel nicht berücksichtigt. Sicher lässt sich die Genauigkeit auch mit Testreihen erhöhen, aber es bleibt eine etwas “ungenaue” Lösung.

Hier noch das Python Script zur Messung:

#!/usr/bin/python
import time
import datetime
 
GPI = '1'
 
def write_gpio(gpinr, data):
    try:
        tmp = "/sys/class/gpio/gpio" + gpinr + "/value"
        fh = open(tmp, 'w')
    except:
        print "not open => open GPIO"
        open_gpio(gpinr,'out')
        tmp = "/sys/class/gpio/gpio" + gpinr + "/value"
        fh = open(tmp, 'w')
    fh.write(data)
    fh.flush()

def read_gpio(gpinr):
    data = 0
    try:
        tmp = "/sys/class/gpio/gpio" + gpinr + "/value"
        fh = open(tmp, 'r')
    except:
        print "not open => open GPIO"
        open_gpio(gpinr,'in')
    data = fh.read(1)
    fh.flush()
    return data
 
def open_gpio(gpinr, gpidir):
    print "Open GPIO"
    fh = open('/sys/class/gpio/export', 'w')
    fh.write(gpinr)
    fh.flush()
    fh.close()
    tmp = "/sys/class/gpio/gpio" + gpinr + "/direction"
    fh = open(tmp, 'w')
    fh.write(gpidir)
    fh.flush()
    fh.close()

def dir_gpio(gpinr, gpidir):
    try:
        tmp = "/sys/class/gpio/gpio" + gpinr + "/value"
        fh = open(tmp, 'r')
    except:
        print "not open => open GPIO"
        open_gpio(gpinr,gpidir)
        tmp = "/sys/class/gpio/gpio" + gpinr + "/value"
        fh = open(tmp, 'r')
    tmp = "/sys/class/gpio/gpio" + gpinr + "/direction"
    fh = open(tmp, 'w')
    fh.write(gpidir)
    fh.flush()
    fh.close()

# Function to measure charge time
def Chtime (gpipin):
  value = 0
  # Discharge capacitor
  dir_gpio(GPI,'out')    
  write_gpio(GPI,'0')    
  time.sleep(0.1)
  dir_gpio(GPI,'in')
  # Count loops until voltage across
  # capacitor reads high on GPIO
  time1 = datetime.datetime.utcnow()
  while ('0' in read_gpio(GPI)):
    value += 1
  
  time2 = datetime.datetime.utcnow() - time1
#  print time2
#  return value
  return time2

print "3x charge times(s):"
print Chtime(GPI)
time.sleep (1)
print Chtime(GPI)
time.sleep (1)
print Chtime(GPI)

Hier das Script in Aktion. Es gibt die gemessenen Zeiten aus. Die Berechnung vom Widerstand ist dann in der Tabellenkalkulation gemacht, könnte jedoch problemlos im Script erfolgen.

In der Werbung wird oft von einer “easy and completed IDE” bzw. “Einfache und komplette IDE” gesprochen, dafür kann ich leider wenig Punkte vergeben. In meiner Definition gibt es eine nur auf Linux lauffähige SDK aber nichts mehr. Nachfolgende die Schritte um ein “blink” Programm zu schreiben, zu kompilieren, zu installieren und zu starten.

Das SDK kann hier herunter geladen werden: http://d.wrtnode.com/3.14.18/

Danach in ein lokales Verzeichnis entpacken und den folgendem Befehl starten:

$make menuconfig

Hier <Build the OpenWRT SDK auswählen> und auf <save> und dann <exit> drücken.

Jetzt das ganze kompilieren mit:

$make V=s

Am Schluss hat man ein SDK mit welchem ein eigenes Programm in einem IPK Paket erstellt werden kann, welches dann auf dem WRTNode mit opkg installiert werden kann.

Unter /bin/ramips/ ist jetzt die Datei OpenWrt-SDK-ramips-for-linux-i686-gcc-4.8-linaro_uClibc-0.9.33.2.tar.bz2 zu finden. Diese entpacken wir am besten in dem Order:

Danach entstandenen Ordner OpenWrt-SDK-ramips-for-linux-i686-gcc-4.8-linaro_uClibc-0.9.33.2 /package

einen Ordner blink für das Packet erstellen. Am Schluss brauchen wir hier folgende Dateien:

/blink/src/blink.c /blink/src/Makefile /blink/Makefile

Hier die Inhalte

/blink/src/blink.c blink.zip

/blink/src/Makefile

# build a Makefile for blink.c
blink: blink.o   
	$(CC) $(LDFLAGS) blink.o -o blink
blink.o: blink.c        
	$(CC) $(CFLAGS) -c blink.c
clean: 
	rm *.o blink

/blink/Makefile makefile.zip

Dann auf der Stufe vom Ordner OpenWrt-SDK-ramips-for-linux-i686-gcc-4.8-linaro_uClibc-0.9.33.2 den Befehl $make V=s ausführen.

Im Protokoll ist dann ersichtlich, dass das Packet “blink” erstellt wurden.

Unter ../bin/ramips/packages/base/ ist das kompilierte Packet erstellt worden.

Dies nun auf den WRTNode übertragen und installieren, die Meldungen können ignoriert werden.

$opkg install blink_1_ramips_24kec.ipk

danach blink ausführen, $blink, und schon blink es.

Jetzt haben wir die SDK Umgebung lauffähig und es kann hier weiter programmiert werden

Im Falle eines Syntaxfehlers ist das beim kompilieren mit $make V=s im protokoll ersichtlich, hier habe ich ein “gugus” eingegeben welcher C nicht versteht. Wenigstens steht die Zeile, hier 163 damit ich den Fehler beheben kann.

Als Projekt habe ich mir vorgenommen mit dem WRTNode ein DNLA Musik Spieler zu bauen, welcher über eine Smartphone App steuerbar ist. Dazu benötigt man noch einen USB Audio Stick um eine Stereo Anlage anzuschliessen. In meinem Fall habe ich mich für den “CM108 Audio Controller” entschieden.

Wichtig hier ist, der Audio Adapter muss über einen USB Hub angeschlossen werden damit er funktioniert.

Die Treiber wurden automatisch geladen. Das kann mit:

$cat /proc/asound/cards

geprüft werden.

Um die Audio Ausgabe zu prüfen kann mit aplay eine WAV Datei abgespielt werden.

$aplay /root/ring.wav

Funktioniert das Abspielen können wir uns um den DNLA Server kümmern. Er ist nötig um die Befehle von der App entgegenzunehmen und die Musikstücke abzuspielen.

Auf Linux gibt es das MDP Projekt, dieses werden wir jetzt mittels .ipk Packete von http://d.wrtnode.com/packages/ installieren. Ich habe mich für die folgenden Packete entschieden:

• glib2_2.41.1-1_ramips_24kec.ipk
• libflac_1.2.1-1_ramips_24kec.ipk
• libmad_0.15.1b-3_ramips_24kec.ipk
• libogg_1.3.1-1_ramips_24kec.ipk
• libvorbisidec_1.0.2+svn18153-1_ramips_24kec.ipk
• mpd-mini_0.16.8-2_ramips_24kec.ipk

alle diese mit opkg install <packet> installieren.

Jetzt müssen wir MPD noch konfigurieren, dazu die mpd.conf aufrufen und die Pfade anpassen. Als Ausgabe musste ich nichts definieren, dann wird die Default Ausgabe genutzt.

$vi /etc/mpd.conf

Dann versuchen wir MDP zu starten am besten zuerst mit diesen Optionen:

$mpd –verbose –stdout –no-daemon

falls dann alles ok ist damit kann mit mdp gestartet werden.,

$mdp

es erscheint eine Fehlermeldung:

Failed to bind to '[::]:6600': Success

aber das bedeutet nicht dass auf den anderen Netzwerk Adressen mdp nicht antwort geben wird.

Mit $ps kann geprüft werden ob der mpd Prozess auch läuft.

Damit mpd auch nach einem Neustart läuft muss noch gepüft werden ob im Startscript alles ok ist:

$vi /etc/init.d/mpd

Dann noch prüfen ob es einen Link im Verzeichnis /etc/rc.d gibt für mpd.

Falls nicht, kann es nachgeholt werden: $/ect/init.d/mpd enable

Hier sieht man dass der Link vorhanden ist und somit mpd auch nach einem Neustart gestartet wird.

Hier die Verkabelung, der WRTNode ist mit einem Strom Adaper angeschlossen und am USB Hub wo ein USB Stick mit der Musik und der USB Audio Adapter hängen.

Auf einem Smartphone kann man jetzt mit der App Mpdroid das abspielen der Musik schön steuern. Dazu muss nur die IP Adress vom WRTNode angegeben werden.

• uname -a (Zeigt die Linux/Firmware Version an)
• reboot (Startet den WRT Node neu)
• firstboot&&reboot (Löscht alle Einstellungen und Daten und setzt alles zurück)

Der WRTNode hat ja nur einen Flash Speicher und Memory eingebaut. Dennoch läuft ein Linux auf dem System und man hat das Gefühl ganz normale (kleine) Festplatten im Zugriff zu haben.

Hier ein gute Beschreibung zum Einstieg:

http://wiki.openwrt.org/doc/techref/flash.layout

Um einen Überblick über den Aufbau der Speicherverteilung auf dem eigenen Gerät zu erhalten empfehlen sich folgende Befehle:

• df -h (Zeigt die Speicherverteilung vom Flash Speicher)
• free -m (Zeigt den verfügbaren Speicher)

Beim Flash Speicher ist nicht mehr viel Platz frei, hier müssen wir etwas unternehmen um weitere zusätzliche Software installieren zu können. Beim RAM Speicher ist nicht mit einem Engpass zu rechnen.

Weitere Details über die Aufteilung kann mit dem Befehl: cat /proc/mtd oder am Anfang der Ausgabe der dmesg gefunden werden:

Wenn viel zusätzliche Software installiert wird kommt der verfügbare Speicher vom WRTnode schnell an ein Limit. Da bietet sich ein USB Stick an. Zwar ist der Zugriff auf USB nicht so schnell wie auf den internen Speicher.

Der USB Stick wird zuerst am besten mit einem ext4 Dateisystem formatiert. Danach kann er wie hier beschrieben mit “extroot” in das Root Laufwerk eingegliedert werden. Dadurch kann wie gewohnt Software installiert werden, Sie landet einfach auf dem USB Stick ist jedoch trotzdem direkt erreichbar. Da extroot bereits am Werk mit dem /Overlay Verzeichnis aktiviert ist muss zuerst der bestehende Inhalt in das USB Laufwerk kopiert werden.

http://wiki.openwrt.org/doc/howto/extroot#openwrt_barrier_breaker_trunk

Nachdem das Laufwerk unter /mnt/sda1 verfübar ist kann mit dem folgenden Befehl das heutige “Overlay” in das neue Laufwerk kopiert werden.

$tar -C /overlay -cvf - . | tar -C /mnt/sda1 -xf -

Jetzt muss nur noch die Configuration vom Overlay definiert werden und zwar zentral in: /etc/config/fstab

Um an die UUID zu kommen den Befehl $block info oder $blkid verwenden.

Nach einem Neustart ist mit dem Befehl df ersichtlich dass das ganze bestens funktioniert hat, und jetzt der Overlay von /dev/sda1 schön eingebunden ist.

Das beste kommt aber jetzt mit dem Befehl df -h schauen wir wieder wie viel Platz uns zur Verfügung steht, und siehe da es sind 10 GB.

Und auch im Luci Web Interface ist klar dass noch viel Platz für weitere Software zur Verfügung steht.

Um eine andere Firmware auszuprobieren muss nicht unbedingt die neue Firmware auf den Flash Speicher geladen werden. Es gibt die Möglichkeit zuerst die Firmware auf einem USB Stick zu speichern und damit zu booten.

Das ganze ist hier beschrieben, es muss lediglich das Image als “uimage” Datei auf dem USB Stick vorhanden sein.

http://wiki.wrtnode.com/index.php?title=WRTnode_U-Boot_instructions

Es empfiehlt sich den WRT Node mit einem Seriellen Kabel zu Verbindung. Falls die Netzwerk Konfiguration mit der neuen Firmware nicht funktioniert kann wenigstens über die Serielle Verbindung auf den WRTNode noch zugegriffen werden.

Dazu braucht es lediglich einen Serial zu USB Konverter.

Hier die Pins:

WRT Node ⇔ Serial to USB

GPIO 75 (TXD2) ⇔ TX

GPIO 62 (RXD2) ⇔ RX

GPIO 64 (GND) ⇔ GND

Am besten verbindet man sich am PC dann per Putty mit dem USB Serial Konverter.

In Putty muss einfach der Port angegeben werden:

Am Anfang vom Startvorgang kann die Startoption ausgewählt werden. Wir wählen die Option 3 oder warten bis die Option 3 als Standard gewählt wird:

Dann startet er das Image vom USB Stick, hier ersichtlich. Es wird der Image Name ausgegeben und man sieht die Version.

Wenn der WRTNode dann fertig gestartet ist kann über Putty ein normaler Shell Zugriff gemacht werden. Einfach Enter drücken und schon hat mann einen root Shell Zugang.

Wie bereits erwähnt ist der Wrtnode nicht ideal um mit anderen elektronischen Komponenten zu kommunizieren. Er hat kein Analoger Eingang und es gibt zudem auch keine Libaries wie bei einem Arduino von Standard Komponenten. Somit liegt es nahe den Wrtnode mit einem anderen Mikrocontroller zu ergänzen. Das gleiche Konzept nutzt ja auch ein Yun oder das Yun Shield. Ich habe mich für den HelvePic32, einem Pic32 Chip, entschieden. Vorteile gegenüber anderen Mikrocontrollern:

• Betriebsspannung von 3.3 Volt wie ein PIC32
• 3 UART/Serielle Schnittstellen

Wie auch bei einem Yun ist bei uns der Linux Teil nur ein Dienstleister. Das Programm mit der Logik läuft im Mikrocontroller. Bei uns muss also der HelvePic32 auf die Konsole oder Programme vom Linux zugreifen können und er muss Resultate auswerten können. Analog der Yun Bridge.

Wir verbinden folgende Leitungen

Den Wrtnode und den HelvePic32 schliessen wir per USB an.

Jetzt müssen wir noch die Baud Rate kontrollieren, beide Systeme müssen für die UART Schnittstelle die gleiche Baud Rate verwenden. Auf dem OpenWrt ist der UART von Pin 7 und 8 unter /dev/ttyS0 erreichbar. Um die Baud Rate zu kontrollieren auf dem WrtNode einfach folgenden Befehl eingeben:

stty -F /dev/ttyS0

Hier oben ist ersichtlich dass wir mit 115200 Baud arbeiten.

Diese Baud Rate verwenden wir weiter unten im HelvePic32 Programm. Falls es zu unsicheren Verbindungen oder unerklährlichen Fehler in der Verbindung kommt kann mit dem folgenden Befehl die Baudrate reduziert werden. Hier auf 9600 Baud.

stty -F /dev/ttyS0 9600

Damit die Serial Verbindung auch nach einem Neustart noch mit der Baud Rate von 115200 arbeitet, einfach in der Datei: /etc/rc.local den Befehl eintragen. Dadurch wird nach einem Neustart automatisch die gewünschte Baudrate gesetzt.

Inhalt Datei /etc/rc.local

Aber Achtung im Boot Vorgang arbeitet das System weiterhin mit 115200 Baud's erst wenn das System gestartet ist wird rc.local ausgeführt und somit die Baud Rate umgestellt.

Hier setzt der HelvePic32 ein “ls -l” auf dem Linux ab. Wir nutzen dabei alle 3 UART's.

Serial übermittelt das Testprotokoll an den Computer (via USB) Serial0 führt das Kommando auf dem Linux aus Serial1 wertet da Resultat vom Linux aus

Hier das HelvePic32 Programm:

int mil;
char inChar = 0;

void setup() {
	Serial.begin(115200);
	Serial0.begin(115200);
	Serial1.begin(115200);
}

void loop() {
  mil = millis() / 200;
  Serial.print("Request at: ");
  Serial.println(mil);

  Serial0.println("ls -l");
  
  Serial.println("Response: ");
  while (Serial1.available() > 0) {
    // get incoming byte:
    inChar = Serial1.read();
    Serial.print(inChar);
  }
  Serial.println();
  delay(1000);
}

Nach dem Übertragen vom Programm auf den HelvePic32 sollte im “Serial Terminal” das Resultat vom Befehl “ls -l” ersichtlich sein. Somit ist die Verbindung vom HelvePic32 zum WrtNode aufgebaut.

Weitere Projekt Ideen welche mir noch so spontan in den Sinn gekommen sind:

• Aufzeichnen von Daten aus Sensoren und anzeigen im Browser
• WebCam mit Temperatur/Luftfeuchte Anzeige im Browser
• Zur Steuerung von Fluggeräten mit eingebauter Kamera

Links mit Informationen über den WRTNode bzw. OpenWRT

WRTNode:

http://www.wrtnode.com/

http://wiki.wrtnode.com/

https://twitter.com/wrtnode

http://wrtnode.com/w/?forum=forum-2

http://d.wrtnode.com/packages/ Wrtnode IPK Packete

OpenWRT:

https://forum.openwrt.org/index.php

http://wiki.openwrt.org/

http://www.openwrt.org/

Der WRTNode bzw. die zur Verfügung stehende Software und Dokumentationen machen es dem “Maker” nicht leicht. Es ist schon fast eine Voraussetzung dass man Linux gut kennt, oder sicher bereit ist sich je nach Projekt in Linux einarbeiten will.

Das Netzwerk Gebiet ist das einzige Gebiet wo man merkt dass der WRTNode sehr stark ist und da ist auch genügend Dokumentation vorhanden, sodass man problemlos zur Lösung kommt. Auch beim Ansteuern von USB Hardware sind dank der Linux Unterstützung und der offenen Architektur wenig Probleme vorhanden.

Wenn es jedoch darum geht mit der realen Welt mittels Schnittstellen in Kontakt zu treten ist es schon etwas schwieriger. Die einfache Ansteuerung von den GPIO Pins funktioniert dann nach einiger Zeit schon. Nur wenn es darum geht weitere Hardware anzuschliessen ist praktisch gar nichts vorhanden worauf man aufbauen könnte. Wenn man aus der Arduino Welt kommt hat man sich an die Libraries sehr gewöhnt mit welchen man viele Hardware mit wenig Aufwand zum laufen bekommt. Dies sieht hier komplett anders aus es ist meistens noch gar nichts vorhanden.

Von der Hardware, Netzwerkfähigkeiten, Betriebsystem und auch vom Webserver hat mich der WRTNode vollständig überzeugt. Auch lassen sich sehr einfach standard USB (Multimedia) Komponenten einbinden. Auf so einem kleinen Board mit so wenig Stromverbauch das alles am laufen zu haben ist toll.

Negativ ist die kleine Community, mangelnde Dokumentation und aufwendige Implementierung von Lösungen mit Schnittstellen zur Aussenwelt.

Aus meiner Sicht hat der WRTNode ein sehr grosses Potenzial es braucht einfach noch etwas mehr Leute die Lösungen und Dokumentationen erstellen. Ich hoffe ich habe mit dem Review einen ganz kleinen Teil dazu beigetragen.