Homepage Wiki Forum Buy

NetIO

Aus GNUBLIN

Schwierigkeitsgrad Voraussetzung Gnublin Familie
Gnublin logo easy.png Grundkenntnisse Konsole Alle

Inhaltsverzeichnis


NetIO with Gnublin

Screenshot netio.png

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: "NetIO with Gnublin" 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
  • "NetIO with Gnublin" 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

Appflow1.jpg

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.py –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. #!/usr/bin/python
  2.  
  3. import asyncore
  4. import socket
  5. import select
  6. import subprocess
  7. import gnublin
  8. import os
  9.  
  10. gpio = gnublin.gnublin_gpio()
  11. gpio.pinMode(3, 'out')
  12. gpio.pinMode(18, 'out')
  13.  
  14. class Client(asyncore.dispatcher_with_send):
  15.     def __init__(self, socket=None, pollster=None):
  16.         asyncore.dispatcher_with_send.__init__(self, socket)
  17.         self.data = ''
  18.         if pollster:
  19.             self.pollster = pollster
  20.             pollster.register(self, select.EPOLLIN)
  21.     def handle_close(self):
  22.         if self.pollster:
  23.             self.pollster.unregister(self)
  24.     def handle_read(self):
  25.         receivedData = self.recv(8192)
  26.         if not receivedData:
  27.             self.close()
  28.             return
  29.         receivedData = self.data + receivedData
  30.         while '\n' in receivedData:
  31.             line, receivedData = receivedData.split('\n',1)
  32.             self.handle_command(line)
  33.         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.

In anderen Sprachen