Transformez les appareils série en appareils connectés à l’IdO

mathias

Nous avons tous entendu parler de la façon dont l’Internet des objets va révolutionner nos vies et nos entreprises en connectant chaque actif au cloud et en rendant les données instantanément disponibles pour analyse et affichage. La première étape consiste à connecter ces appareils pour qu’ils puissent envoyer des données. La deuxième étape consiste à faire en sorte que le dispositif sache quand il doit envoyer ces données. Cela signifie que la connectivité et l’intelligence doivent être ajoutées à chaque appareil.

Compte tenu du grand nombre d’appareils dotés d’une connexion série, il existe une solution qui permet de configurer et d’activer facilement la transmission des données des appareils finaux à Google Analytics, 2lemetry ou tout autre fournisseur de services en nuage disposant d’une API ouverte telle que HTTP ou MQTT.

La solution utilise la famille de dispositifs PremierWave de Lantronix pour connecter un dispositif final via un port série comme RS-232/485 ou Ethernet, extraire intelligemment les données utiles et les envoyer à Google Analytics et 2lemetry. Les outils disponibles avec Google Analytics permettent de créer facilement des tableaux de bord personnalisés afin de présenter les données dans un format qui aide à piloter les processus commerciaux et à fournir aux utilisateurs finaux des informations significatives.

Google Analytics permet de combiner ces données avec des données provenant d’autres processus commerciaux. Avec 2lemetry, vous disposez d’un processus de publication/abonnement facile pour la communication de machine à machine. Cela permet aux données de circuler facilement d’un appareil à l’autre et d’être affichées aux utilisateurs finaux via des outils Web standard.

La famille comprend un dispositif pour la connectivité Ethernet ou série vers cellulaire, un autre qui fournit une connectivité Ethernet ou série vers WiFi, et un troisième, un système sur module qui peut être intégré dans un dispositif personnalisé.

Les composants peuvent exécuter nativement du code Python et prennent en charge la bibliothèque standard Python. Cela facilite la gestion de l’intelligence au niveau de l’appareil périphérique, ainsi que l’utilisation de paquets Python pour se connecter aux services de cloud computing qui ont des protocoles ouverts.

Lors d’une démonstration du système au récent salon Embedded World 2014, nous avons envoyé des données en direct depuis le sol. Avec un appareil activé, l’utilisateur pouvait rapidement poster des données vers le service Cloud de son choix, en utilisant des normes ouvertes et un langage de programmation facile à développer comme Python.

La démonstration consistait en une balance avec une sortie RS-232 connectée à une pièce PremierWave. Le script Python exécuté sur la pièce PremierWave analysait les données de la balance et envoyait le poids reçu aux deux services Google Analytics et 2lemetry en parallèle.

Le programme Python utilise le module Pyserial pour analyser ces données. Le port série de port série est facilement initialisé avec Pyserial :

class ser349klx :
# configurer le port série. Passez le périphérique comme ‘/dev/ttyS1’ ou
# ‘/dev/ttyS2’ pour
# le port série 1 et 2 (respectivement) dans PremierWave EN ou XC HSPA+.
def init(self, device, weight, c2l, ga) :
while True :
essayer :
serstat = True
ser = serial.Serial(device,2400,
interCharTimeout=0.2, timeout=1)
sauf exception :
serstat = False
if serstat :
break

    self.ser = ser
    self.weight = weight
    self.c2l = c2l
    self.ga = ga

La balance utilisée envoie en permanence le poids actuel via le port RS-232, chaque valeur étant séparée par un retour chariot.
chaque valeur séparée par un retour chariot :

def receive_line(self) :
    buffer = ''

    while True :
        buffer = buffer + self.ser.read(self.ser.inWaiting())

        if '\r' in buffer :
            lines = buffer.split('\r')
            return lines[-2]

Le code qui trouve un nouveau poids est appelé depuis une boucle, qui attend ensuite que
dix valeurs non nulles égales pour attendre que le poids se stabilise avant de l’envoyer à
Google Analytics et 2lemetry, comme indiqué ci-dessous :

# Ceci exécute une boucle continue écoutant les lignes provenant du
# port série et les traite.
def getData(self) :
    count = 0
    prev = 0.0
    while True :
        time.sleep(0.1)
        essayer :
            val = self.receive_line()
            weight.value=float(val[-5:])*0.166
            si (prev == poids.valeur) :
                count += 1
                si (count == 10) et (str(prev) != '0.0') :
                    self.ga.send("{ :.2f}".format(prev))
                    si supportMqtt :
                      self.c2l.send("{ :.2f}".format(prev))
            autre :
                count = 0
                prev = poids.valeur
        sauf exception :
            passer

Étant donné que le protocole de mesure de Google Analytics utilise des requêtes
standard pour envoyer des données à partir d’appareils autres que des navigateurs Web, la méthode ga.send est
facilement mise en œuvre à l’aide des modules Python urllib et urllib2, comme indiqué ci-dessous :

classe gaConnect :
def init(self, tracking, mac) :
self.tracking = tracking
self.mac = mac

            def send(self, data) :
                            values = { 'v' : '1',
                                        'tid' : self.tracking,
                                        'cid' : self.mac,
                                        't' : 'event',
                                        'ec' : 'balance',
                                        'ea' : 'weight',
                                        'el' : données }

            res = urllib2.urlopen(urllib2.Request
             ("http://www.google-analytics.com/collect",urllib.urlencode(values))))

La dernière étape consiste à initialiser un objet Google Analytics connect pour se connecter au compte Analytics de l’utilisateur :

ga = gaConnect(« UA-XXXX-Y », dev.mac)

L’adresse MAC de l’appareil envoie des informations uniques à chaque appareil.

Le système 2lemetry utilise le protocole MQTT. Cela peut être facilement mis en œuvre en utilisant le paquet Mosquitto :

classe connexion2lemetry :
def init(self, dev) :
self.client = mosquitto.Mosquitto(‘things/’+dev.mac)
self.client.username_pw_set(« username », password= »password »)
self.id = dev.mac

def send(self, value) :
    self.client.connect("q.m2m.io")
    self.client.loop()
self.client.publish('domain/things/'+self.id, '{
                           "report":{"test":{"weight":"'+value+'"}}}',1)
    self.client.loop()
    self.client.disconnect()

def disconnect(self) :
    self.client.disconnect()

Voilà, vous pouvez voir qu’en utilisant Python, vous pouvez facilement transformer des appareils série en appareils connectés à l’IoT.