NetIO with Gnublin

Inhaltsverzeichnis
• 1 NetIO with Gnublin
- 1.1 Funktionsweise
NetIO with Gnublin
Mit NetIO erstellt man sehr schnell und einfach Oberflächen für Fernbedienungen. Man kann
einfach diese Oberfläche auf ein Smartphone oder Tablet laden.
Als Gegenstück kann man sehr leicht auf dem GNUBLIN die Kommandos mit Python der
Fernbedienung entgegennehmen und auswerten bzw. einfache Aktionen direkt starten.
Wie geht das alles?
●
●
●
●
●
●
●
●
●
●
Account auf NetIO anlegen http://netio.davideickhoff.de/editor
App auf Smartphone installieren
UI-Designer per Browser starten und Config öffnen: "http://wiki.gnublin.orgNetIO with
Gnublin"http://wiki.gnublin.org http://netio.davideickhoff.de/editor2?config=6932
Aktuelle IP Adresse von GNUBLIN in Connection-Settings eingeben
Save Online klicken
App im Smartphone starten (im Iphone Telefon schütteln)
Zugangsdaten eingeben und auf Sync clicken
"http://wiki.gnublin.orgNetIO with Gnublin"http://wiki.gnublin.org auswählen
Auf GNUBLIN gehen, Python API + Server kopieren und starten
Relay + GPIO steuern
Wir steuern als Demo die rote LED (an GPIO 3) auf dem GNUBLIN Board das im gleichen Netzwerk
wie unser Telefon hängt.
Im wesentlichen denkt man sich einfache Kommandos aus, die man in der Oberfläche für jeden
Button & Co. definiert. Diese Kommandos werden dann an den kleinen Server im GNUBLIN 1:1
gesendet. Dort kann man diese einfach auswerten.
Funktionsweise
Hier eine kleine Anleitung, wie du NetIO auch auf dem Gnublin zum Laufen bekommst:
Lade die UI-Designer config von unserer Projektseite herunter: [1]
Trage bei Connection die aktuelle IP des Gnublin ein. Die IP des Gnublin findest du mit folgendem
Befehl heraus:
root@gnublin:~$ ifconfig
NetIO App aus dem Apple App Store (Google Play Store) installieren. Die App baut einen TCP Socket
auf um dort dann selbst definierte Strings zu versenden. Um diese mit dem Online Account zu
synchronisieren muss man bei einem Android Smartphone mit zwei Fingern über den Bildschirm
streichen, das iPhone muss man schütteln.
Gnublin Seite (Python):
Nun benötigt man noch einen TCP Socket Server der die Verbindung annimmt und entsprechend
reagiert. Dieser wird im Beispiel unten in Python implementiert.
Gnublin mit Netzwerk verbinden. [2]
Bevor man die API in Python nutzen kann laden wir uns die folgenden beiden Dateien herunter:
root@gnublin:~$ wget
https://raw.github.com/embeddedprojects/gnublin-api/master/python-module/gnublin/gnublin.p
y –no-check-certificate
root@gnublin:~$ wget
https://github.com/embeddedprojects/gnublin-api/raw/master/python-module/gnublin/_gnublin.
so –no-check-certificate
Die beiden Dateien holen wir dann direkt auf unser Gnublin.
Erstelle eine Datei server_netio.py und kopiere Folgendes hinein und schiebe siehe via scp auf dein
Gnublin: [3]
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
#!/usr/bin/python
import
import
import
import
import
import
asyncore
socket
select
subprocess
gnublin
os
gpio = gnublin.gnublin_gpio()
gpio.pinMode(3, 'out')
gpio.pinMode(18, 'out')
class Client(asyncore.dispatcher_with_send):
def __init__(self, socket=None, pollster=None):
asyncore.dispatcher_with_send.__init__(self, socket)
self.data = ''
if pollster:
self.pollster = pollster
pollster.register(self, select.EPOLLIN)
def handle_close(self):
if self.pollster:
self.pollster.unregister(self)
def handle_read(self):
receivedData = self.recv(8192)
if not receivedData:
self.close()
return
receivedData = self.data + receivedData
while '\n' in receivedData:
line, receivedData = receivedData.split('\n',1)
self.handle_command(line)
self.data = receivedData
34.
def handle_command(self, line):
35.
if line == 'LED1 on':
36.
self.send('on')
37.
gpio.digitalWrite(3,1)
38.
elif line == 'LED1 off':
39.
self.send('off')
40.
gpio.digitalWrite(3,0)
41.
elif line == 'RELAY open':
42.
self.send('off')
43.
gpio.digitalWrite(18,0)
44.
elif line == 'RELAY close':
45.
self.send('off')
46.
gpio.digitalWrite(18,1)
47.
else:
48.
self.send('unknown command')
49. class Server(asyncore.dispatcher):
50.
def __init__(self, listen_to, pollster):
51.
asyncore.dispatcher.__init__(self)
52.
self.pollster = pollster
53.
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
54.
self.bind(listen_to)
55.
self.listen(5)
56.
def handle_accept(self):
57.
newSocket, address = self.accept()
58.
print "Connected from", address
59.
Client(newSocket,self.pollster)
60. def readwrite(obj, flags):
61.
try:
62.
if flags & select.EPOLLIN:
63.
obj.handle_read_event()
64.
if flags & select.EPOLLOUT:
65.
obj.handle_write_event()
66.
if flags & select.EPOLLPRI:
67.
obj.handle_expt_event()
68.
if flags & (select.EPOLLHUP | select.EPOLLERR | select.POLLNVAL):
69.
obj.handle_close()
70.
except socket.error, e:
71.
if e.args[0] not in asyncore._DISCONNECTED:
72.
obj.handle_error()
73.
else:
74.
obj.handle_close()
75.
except asyncore._reraised_exceptions:
76.
raise
77.
except:
78.
obj.handle_error()
79. class EPoll(object):
80.
def __init__(self):
81.
self.epoll = select.epoll()
82.
self.fdmap = {}
83.
def register(self, obj, flags):
84.
fd = obj.fileno()
85.
self.epoll.register(fd, flags)
86.
self.fdmap[fd] = obj
87.
def unregister(self, obj):
88.
fd = obj.fileno()
89.
del self.fdmap[fd]
90.
self.epoll.unregister(fd)
91.
def poll(self):
92.
evt = self.epoll.poll()
93.
for fd, flags in evt:
94.
yield self.fdmap[fd], flags
95. if __name__ == "__main__":
96.
pollster = EPoll()
97.
pollster.register(Server(("",54321),pollster), select.EPOLLIN)
98.
while True:
99.
evt = pollster.poll()
100.
for obj, flags in evt:
101.
readwrite(obj, flags)
Danach einfach:
python server_netio.py
Starte die NetIO App und bediene den Schalter. Die onboard LED wird ein- und ausgeschaltet.
Viel Spaß beim Weiterbasteln.