Yun Shield von Dragino

Hier ein kurzer Erfahrungsbericht vom Yun Shield von Dragino. Mit dem WRTNode habe ich die enormen Möglichkeiten eines OpenWrt Systems erkannt. Trotz seiner kleinen Grösse und dem geringen Stromverbrauch können viele Dinge damit angestellt werden.

Die Interaktion mit anderen Elementen ist bei einem Yun Shield in Kombination mit einem normalen Arduino sehr viel einfacher. Ebenfalls wollte ich mal die Möglichkeiten der Yun Bridge ausprobieren.

Als sehr guter Einstieg möchte ich hier noch die offizielle Wiki Seite erwähnen: http://wiki.dragino.com/index.php?title=Yun_Shield.

In diesem Artikel wird das Yun Shield V1.1 benutzt. Mittlerweile gibt es noch die Version 2.3 und 2.4. Hier sieht man schön die Unterschiede der Versionen: http://wiki.dragino.com/index.php?title=Yun_Shield#Difference_between_v1.x_and_v2.x

Am Ende dieses Test's findet Ihr auch noch zusätzliche Infos zu der Version 2.3.

Das Shield kommt sehr solide verpackt mit einer Wlan Antenne angeliefert. Die Antenne kann gut am Shield angebracht werden.

Das Yun Shield braucht ein Arduino als Unterbau. Es bieten sich viele Arduino Boards oder Clones an. Dabei gilt jedoch je weniger desto besser. Weil das Shield sich per SPI und UART(Rx/Tx) mit dem Arduino verbindet ist ein Arduino Board welches an diesen Schnittstellen nicht schon zu viel Hardware angeschlossen hat am besten. Deshalb war meine Wahl natürlich ein Helvetino. Falls die Verbindung zwischen Arduino und Yun Shield nicht funktioniert empfiehlt es sich auch die LED an Pin 13 zu unterbrechen. Bei mir hat das gestört.

Beim Helvetino v1.01 ist leider der ICSP Stecker noch nicht angeschlossen. Das muss also noch nachgeholt werden:

 MISO(12) 1--2 VCC
  SCK(13) 3--4 MOSI(11)
    RESET 5--6 GND

Auf dem Shield muss jetzt über einen Jumper noch die Arduino Spannung eingestellt werden.

Die Stromversorgung erfolgt dann am besten über den Arduino Stecker Anschluss. Nur über den Arduino FTDI/USB Anschluss ist nicht zu empfehlen.

Das Yun Shield ist wie andere OpenWrt System nach dem einschalten als Wireless Router zugänglich. Damit kann man sich ohne Verschlüsselung/Zugangscode verbinden. Im Webbrowser lässt sich dann mit dem Passwort “dragino” das Administrations Inteface öffnen.

Unter <System> lässt sich hier sehr einfach das Shield mit einem bestehenden Wireless Netzwerk verbinden, dann ist der Zugriff vom Shield auf das Internet oder auch umgekehrt möglich.

Ebenfalls kann über SSH mit der Shell auf das Shield zugegriffen werden:

Unter Sensors muss jetzt noch der Arduino Typ eingestellt werden. Standardmässig ist “UPLOAD BOOTLOADER” nicht aktiviert, dass heisst das YunShield überträgt nur den Sketch und löscht den Arduino Bootloader. Dann ist der Arduino nicht mehr über ein FTDI Adaper zu programmieren. Um das zu verhindern einfach “UPLOAD BOOTLOADER” auswählen. Oder nach dem Gebrauch mit dem Yun Shield einfach selber nochmals den Bootloader übertragen.

Im Gegensatz zum WRTNode wo die Firewall standardmässig vieles blockiert, ist beim Yun Shield die Firewall im Auslieferungszustand komplett offen. Das bietet natürlich den Vorteil dass ich nicht viel Konfigurieren muss damit ein Zugriff funktioniert. Aber es ist sicher keine Gute Idee ein Yun Shield direkt ohne Firewall ins Internet zu setzen.

Entweder kann über diesen Befehl die Firewall Einstellung angeschaut werden,

$vi /etc/config/firewall

oder über das Luci Browser Interface:

Das Yun Shield stellt auch eine Wireless Access Point zur Verfügung. Entweder meldet sich der Computer an dem AP an oder aber das Yun Shield meldet sich an einem anderen Wlan Access Point an. Das ist sehr einfach über das Luci Interface über das Menu “Network” “Wifi” mit dem Button “Scan” eingerichtet werden.

Um das Wlan über die shell ein oder auszuschalten folgende Befehler verwenden:

$wifi up
$wifi down

Hier ein Arduino Sketch um das Wlan ein oder auszuschalten:

/*
       Wifi up and down
 */

#include <Process.h>
const int ledPin = 7;
void setup() {
  digitalWrite(ledPin, HIGH);    
  delay(10000);
  digitalWrite(ledPin, LOW);
  Bridge.begin(115200);	// Initialize the Bridge
  pinMode(ledPin, OUTPUT); 
  Console.begin();	// Initialize the Serial
  Console.println("Wifi on/off Script");  
  digitalWrite(ledPin, HIGH);  
  delay(500);
  digitalWrite(ledPin, LOW);
}

void loop() {
  Process wifiCheck;  // initialize a new process

  Console.println("Wifi off");  

  digitalWrite(ledPin, LOW);

  wifiCheck.runShellCommand("wifi down");

  // while there's any characters coming back from the
  // process, print them to the serial monitor:
  while (wifiCheck.available() > 0) {
    char c = wifiCheck.read();
    Console.print(c);
  }
  delay(5000);

  
  Console.println("Wifi on");  
  
  wifiCheck.runShellCommand("wifi up");

  digitalWrite(ledPin, HIGH);  

  // while there's any characters coming back from the
  // process, print them to the serial monitor:
  while (wifiCheck.available() > 0) {
    char c = wifiCheck.read();
    Console.print(c);
  }
  delay(5000);
  
}

Hier als als Test der Vergleich der Yun Konsole mit dem Ping für den Verbindungstest.

Falls einmal Aufgrund eines Fehlers kein Zugriff mehr über Wlan auf das Yun Shield möglich ist, gibt folgende Möglichkeit:

Die Reset Taste 5 Sekunden drücken, dadurch werden alle Wlan Einstellungen gelöscht und auf den Standard zurückgesetzt.

Es gibt zwei Möglichkeiten um mehr Platz auf dem Yun Shield zu bekommen. In beiden Fällen braucht es ein USB Datenträger aber die Methode zum einbinden ist verschieden. Jede Methode hat Vorteile und Nachteile.

Analog zum WRTNode kann auch hier sehr einfach das interne Filesystem mit einem USB Stick erweitert bzw. überlagert werden:

WRTNode ein mini OpenWRT Board

Um an die UUID zu kommen wir im Yun Shield am besten der Befehlt $blkid verwendet.

Mit $df und $mount kann der Erfolg geprüft werden.

Vorteil: Das ganze System hat viel mehr Platz zur Verfügung

Nachteil: Es werden mehr Schreibzyklen auf den Datenträger durchgeführt was bei Flash Speichern zu Problemen führen kann.

Die zweite Methode ist ein normaler Mount und die Verwendung eines symbolischen Links (Symlink).

In meinem Fall wollte ich im Verzeichnis vom Webserver: /www/ weitere Dateien ablegen. Aber aus Platzgründen wollt ich sie auf dem USB Speicher ablegen. Dazu den USB Stick einstecken und prüfen ob er automatisch ein Mount Punkt erstellt hat.

$mount
/dev/sda1 on /mnt/sda1 type ext2 (rw,relatime,errors=continue)

Wir sehen oberhalb, dass unser USB Stick unter /mnt/sda1 erreichbar ist.

Um jetzt das Verzeichnis “sensor” auf dem USB Stick unter /www zur Verfügung zu stellen müssen wir ein Symlink erstellen:

$ln -s /mnt/sda1/sensor /www/sensor

Mit $ln -l kann das geprüft werden:

Um den Symlink wieder zu löschen, folgenden Befehl verwenden:

$rm -Rf /www/sensor

Vorteil: Es werden weniger Schreibzyklen durchgeführt als beim Overlay.

Nachteil: Einzelne Bereiche können dadurch manuell ausgelagert werden. Aber die Methode bringt nicht automatisch mehr Platz im ganzen System.

Optional: Um noch etwas weniger Schreibzyklen zu haben, kann in der Datei: /etc/config/fstab folgenden Optionen gesetzt werden: noatime,nodiratime

config 'mount'
        option 'device'         '/dev/sda1'
        option 'target'         '/mnt/sda1'
        option 'fstype'         'auto'
        option 'option'         'noatime,nodiratime'

Die Programmierung vom Arduino kann über das Yun Shield umgeleitet werden. Die Arduino IDE bietet dazu automatisch einen Yun Port an. Die Arduino IDE muss jedoch vor dem starten vom Yun gestartet sein. Der Yun macht bei seinem Start einen UDP Broadcast 5353. Wenn das Yun Shield jedoch im Dauerbetrieb ist und man nur eine kleine Änderung am Aduino Coding hat ist das blöd den Yun dafür auszuschalten. Abhilfe gibt es mit indem man den Broadcast manuell auslöst bzw den AVAHI Daemon neu startet damit dieser den Broadcast auslöst.

$/etc/init.d/avahi-daemon restart

Danach ist das Yun Shield in der IDE sichtbar.

Jetzt muss noch die IDE über die Datei Arduino\hardware\arduino\avr\board.txt erweitert werden. Dazu einfach diese Zeilen von dieser Vorlage hinzufügen:

https://github.com/dragino/modules/tree/master/hardware/YunShield/sketchbook/hardware/YunShield

Bei mir habe ich die folgenden 4 Dragino Yun Shield Kombinationen eingetragen:

boards_yun_shield.txt.zip

Danach steht das Board “Arduino Uno - Dragino Yun” nach einem Neustart zur Verfügung.

Nach dem erfolgreichen Upload ist folgende Meldung ersichtlich:

In der Arduino IDE sind unter “Examples” viele Beispiele der Yun Bridge vorhanden:

Gegenüber den Beispielen wo über “Serial.” Informationen ausgegeben werden müssen über Wlan alle “Serial.” Befehle mit dem Befehl “Console.” ausgetauscht werden und den Start Befehl: “Serial.begin(9600);” wird mit “Console.begin();” ersetzt.

In der Praxis hat sich leider gezeigt, dass die YUN Bridge nicht sehr stabil ist. Ich habe vieles ausprobiert bin dann aber zum Schluss gekommen das die Senkung der Übertragungsgeschwindigkeit der Seriellen Schnittstelle die beste Verbesserung bringt.

Standardmässig wird mit 250k Baud gearbeitet. Um das zu ändern muss in der der Konsole folgender Befehl eingegeben werden:

stty -F /dev/ttyATH0 115200

Damit wird auf 115200 Bauds umgestellt. Im Arduino Sketch muss bei folgendem Befehl auch die gleiche Baud Rate mitgegeben werden.

  Bridge.begin(115200);	// Initialize the Bridge

Bei mir hat diese Anpassung eine wesentliche Verbesserung der Stabilität gebracht. Vorher hat das YunShield immer wieder Aufgaben an die Shell verschluckt.

Hier ein kleines Testprogramm um die Bridge zu testen. Das Programm schreibt jede Sekunde ein Zeitstempel in die Datei /root/d.log

#include <Bridge.h>

const int ledPin = 8;
void setup() {
  pinMode(ledPin, OUTPUT);  
  digitalWrite(ledPin, HIGH);
  delay(10000);         // wait some seconds until linux is ready
  Bridge.begin(115200);	// Initialize the Bridge
  digitalWrite(ledPin, LOW);
}

void loop() {
  String runcmd = "date >> /root/d.log"; 
  Console.println(runcmd);
  Process p2;
  p2.runShellCommand(runcmd);
  while (p2.running());  
  delay(1000);
}

Auf der Linux Konsole kann dann in der Datei geprüft werden ob es keine Lücken gibt.

$cat d.log
Mon Jun 15 23:49:27 CEST 2015
Mon Jun 15 23:49:28 CEST 2015
Mon Jun 15 23:49:28 CEST 2015
Mon Jun 15 23:49:29 CEST 2015
Mon Jun 15 23:49:30 CEST 2015
Mon Jun 15 23:49:31 CEST 2015

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.

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.

Inhalt Datei /etc/rc.local

# Put your custom commands here that should be executed once
# the system init finished. By default this file does nothing.
/bin/stty -F /dev/ttyATH0 115200
exit 0

Um das dann zu prüfen den Befehlt stty -F /dev/ttyATH0 eingeben, unter speed wird die Baud Rate angezeigt.

Um vom Linux aus den Arduino Processor neu zu starten steht der Befehl: reset-mcu zur Verfügung.

Um das Linux System neu zu starten einfach: reboot eingeben.

Um beide Systeme gleichzeitig neu zu starten folgende Datei: /bin/reboot mit folgendem Inhalt anlegen.

reset-mcu
/sbin/reboot

Um das Script ausführbar zu machen noch folgendes eingeben: chmod +x /bin/reboot

Dann wird mit dem reboot das Arduino und das Linux system gleichzeitig neu gestartet. Weil das Linux System länger braucht für einen Neustart empfiehlt es sich im Arduino Sketch ein Delay(10000); einzubauen dann wartet es 10 Sekunden lang. Das ist wichtig, damit nicht in den Boot Vorgang vom Linux System eingegriffen wird.

Wir wollen das Yun Shield und den Helvetino als Pflanzenwächter einsetzen. Er soll die Bodentemperatur messen und bei bedarf der Pflanze Wasser geben.

Die ganzen Messdaten sollen natürlich über ein Web Zugang ersichtlich sein.

Als erstes Installieren wir folgende Pakete:

php5 php5-cgi php5-mod-sqlite3_5.4.5-3_ar71xx.ipk

Falls nicht in der Liste vorhanden von hier: http://www.dragino.com/downloads/index.php?dir=motherboards/ms14/Firmware/Yun/Packages--v2.x/

Und dann mit diesem Aufruf installieren:

opkg install <packet>

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

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

Config Datei mit vi editieren, der Eintrag ist schon vorbereitet, er muss nur noch akiviert werden.

$vi /etc/config/uhttpd

        # List of extension->interpreter mappings.
        # Files with an associated interpreter can
        # be called outside of the CGI prefix and do
        # not need to be executable.
        list interpreter        ".php=/usr/bin/php-cgi"

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:

Damit wir die Daten von den Sensoren speichern können brauchen wir eine kleine Datenbank. SQlite eignet sich dazu gut. Wir installieren das Packet: sqlite3-cli

Jetzt können wir auf der Kommandozeile eine Datenbank anlegen und eine Tabelle dazu:

$sqlite3 log_pl.db sqlite>CREATE TABLE sensor (time INT, value INT, value2 INT, value3 INT, value4 INT, value5 INT);

Wir befüllen die Tabelle mit einem Datensatz und prüfen den Eintrag:

sqlite>INSERT INTO sensor ( time, value, value2) VALUES ( 1, 2, 3);

sqlite> select * from sensor; 1|2|3|||

Um die SQLite Konsole wieder zu verlassen einfach .exit eingeben

Um die Daten in die Datenbank zu speichern gehen wir den Weg über ein Python Script, welches wir dann vom Arduino mit Hilfe der Bridge aufrufen. Über die Parameter übergeben wir die Daten an das Script. Hier der insert_pl.py Script.

#!/usr/bin/python
# This coding is called from Arduino via Yun Bridge

import sqlite3 as lite
import sys

f = open('/arduino/insert_log_pl','a')
f.write('insert:' + sys.argv[1] + sys.argv[2] + '\n' )

con = None

try:
  con = lite.connect('/arduino/log_pl.db')
  cur = con.cursor()    

# insert one entry
  record = ( sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4], sys.argv[5], sys.argv[6] )
  cur.execute("INSERT INTO sensor VALUES(?, ?, ?, ?, ?, ?)", record)
  con.commit()
         
except lite.Error, e:
                                        
  print "Error %s:" % e.args[0]
  f.write('Error')
  sys.exit(1)
                                                    
finally:
  if con:
    con.close()
                                                                    

Um die Daten zu prüfen brauchen wir auch noch einen Python Lese Script: sa_pl.py

#!/usr/bin/python
# -*- coding: utf-8 -*-

import sqlite3 as lite
import sys
import datetime

con = None

try:
  con = lite.connect('/arduino/log_pl.db')
  cur = con.cursor()    

 
# select and print all entries 
  cur.execute('SELECT * FROM sensor')
  rows = cur.fetchall()
  for row in rows:
#    print row
    print (
    datetime.datetime.fromtimestamp(
            int(row[0])
                ).strftime('%Y-%m-%d %H:%M:%S')
                ), "1:", row[1],"2:", row[2],"3:", row[3],"4:", row[4],"5:", row[5]

# insert one entry
#  cur.execute("INSERT INTO sensor VALUES ('234234','32')")
#  con.commit()

# just get nbr of entries
  cur.execute('SELECT Count() FROM sensor')
  nbr=cur.fetchone()
  print('Number of rows %s'%nbr)
          
except lite.Error, e:
                                        
  print "Error %s:" % e.args[0]
  sys.exit(1)
                                                    
finally:
                                                        
  if con:
    con.close()
                                                                    

So jetzt schreiben wir einen Eintrag.

$python insert_pl.py 22 33 44 55 66 77

und prüfen ob er angekommen ist.

$python sa_pl.py

folgt noch.

Jetzt haben wir die Daten in der Datenbank, wollen Sie aber noch auslesen können. Dazu verwenden wir ein PHP Script welches ein JSON Format ausgibt.

Hier der Anfang einer Ausgabe, wir haben immer Unix Timestamp und dann den jeweiligen Wert.

{"stats":[{"label": "Soil humidity","data":[[1435818941000,169],[1435819662000,169],[1435822161000,509],
[1435822882000,506],[1435823602000,504],[1435824323000,502],[1435825044000,500],[1435825764000,498],
[1435826485000,504],[1435827205000,504],[1435827926000,504],[1435828647000,503],[1435829368000,503],
[1435830089000,503],[1435830810000,503],[1435831531000,503],[1435832251000,502],[1435832972000,501],
[1435833693000,501],[1435834414000,500],[1435835134000,499],[1435835855000,498],[1435836576000,497],
[1435837297000,496],[1435838017000,494],[1435838738000,493],[1435839459000,492],[1435840180000,490],
[1435840901000,489],[1435841622000,487],[1435842342000,485],[1435843063000,483],[1435843784000,482],
[1435844505000,479]]},{"label": "Luminosity","data":[[1435818941000,89],[1435819662000,111],[1435822161000,333],
[1435822882000,333],[1435823602000,334],[1435824323000,334],[1435825044000,334],[1435825764000,334],
[1435826485000,334],[1435827205000,334],[1435827926000,334],[1435828647000,334],[1435829368000,334],
[1435830089000,334],[1435830810000,334],[1435831531000,334],[1435832251000,334],[1435832972000,334],
[1435833693000,334],[1435834414000,335],[1435835134000,335],[1435835855000,335],[1435836576000,335],

Die Webseite bassiert auf JQuery und Flot. Wobei analog dem Beispiel hier: http://www.flotcharts.org/flot/examples/zooming/index.html die Möglichkeit besteht in einem Overview Bild einen Bereich für die Detailanalyse auszuwählen.

Das ganze sieht dann so aus:

Um ein Script im Linux regelmässig laufen zu lassen kann es als Cronjob eingeplant werden. Dazu crontab -e eingeben und den Job definieren.

Hier ein Beispiel, immer 20 nach der vollen Stunde läuft der nt.sh Script.

20 * * * * /bin/sh /root/nt.sh

Um zu sehen ob es funktioniert das Log auslesen mit: logread | grep cron

Zum prüfen ob der zuständige Prozess läuft folgendes eingeben: ps | grep syslogd

Fall der Prozess nicht läuft, kann er gestartet und aktiviert werden:

/etc/init.d/cron start /etc/init.d/cron enable

Offizielle gute Wiki Seite

Helvetino Referenz auf der Wiki Seite

Dragino IPK Packages

Yun Shield Produkt Seite im Boxtec Shop

Yun Bridge Library Referenz

Projekt: Pflanzen Wächter mit dem Yun Shield

Das Dragino Yun Shield bietet ein gutes Preis/Leistungs Verhältnis. Es ist sehr gut für alle IoT Projekte. Das Linux System ist sehr einfach nutzbar und auch erweiterbar. Dank der Anbindung an einen Arduino können alle Sensoren sehr einfach angesteuert werden. Das Yun Shield ist eine sehr gute Alternative zum Arduino Yun.

Hier noch zusätzliche Informationen zu der Version 2.3 vom Yun Shield. https://shop.boxtec.ch/shield-v23-p-42540.html. Die Version 2.3 bietet zusätzlich einen 2. USB Port und ein Mikro SD Karten Steckplatz.

Auch bei der Firmware hat sich einiges geändert. Dragino hatte eine Zeit lange 2 unterschiedliche Firmwares unterstützt. Ab jetzt wird aber nur noch die IoT Firmware weiterentwickelt. Daher macht es sinn auf diese Firmware zu wechseln. Hier die Infos dazu: http://wiki.dragino.com/index.php?title=Upgrade_Firmware_ms14#Upgrade_firmware_from_Yun_firmware_to_IoT_Mesh_firmware_via_WiFi

Als wichtigste Änderung ist die Baud Rate bei der neuen IoT Firmware. Die beträgt nur noch 115200. Kontrolliert Eure bestehenden Codings, die Baud Rate muss immer so definiert werden: Bridge.begin(115200);

Hier die Web Oberfläche mit der IoT Firmware 4.3.0.

Die Anbindung hat sich bei der Version 2.3 nicht geändert. Weiterhin wird der Arduino über die ICSP Schnitstelle programmiert und über die UART Schnittstelle kommunizieren die beiden Systeme miteinander. Wie hier ersichtlich kann über die Web Oberfläche die Kommunikation kontrolliert werden. Falls hier der richtige Arduino nicht angezeigt werden muss die Kommunikation kontrolliert werden.