Raspberry pi – Page 2

connexion wifi d’une carte Raspberry Pi 3

La Carte Raspberry 3 possède nativement d’une interface réseau sans fils (WIFI) . Nous allons voir diverses méthodes pour se connecter au wifi

Utilisation de l’interface graphique :

C’est certainement la méthode la plus simple : connecter la carte raspberry à un clavier, une souris et un écran (via la prise HDMI) . Dans la barre supérieur on voit l’icône réseau , il suffit alors de sélectionner le réseau wifi, de saisir le mot de passe… et voilà.

Pour les raspberry sans interface graphique.

Une autre méthode consiste à écrire un petit fichier de configuration qui est pris en compte au boot de la carte.
Il faut connaitre le nom du point d’accès et le mot de passe. Pour l’exemple imaginons que le point d’accès se nomme mammouth et que le mot de passe soit motDePasse
Sur un PC, il faut créer un fichier texte nommé wpa_supplicant.conf
Puis le compléter de la manière suivante :

country=FR
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
network={
                ssid="nomDuPointDacces"
                psk="motDePasse"
               }

Une fois ce fichier créé, il faut le sauvegarder sur la carte SD du raspberry :

Couper l’alimentation du raspberry
Extraire la carte SD
A l’aide d’un adaptateur SD/ USB, introduire la carte SD dans le PC
Sauvegarder le fichier wpa_supplicant.conf précédemment créé sur la carte SD
Réintroduire la carte SD dans le raspberry pi et le redémarrer.

Le fichier wpa_supplicant.conf est automatiquement placé au bon endroit dans l’arborescence et la connexion wifi se fait.

Retrouver l’adresse IP d’une carte Raspberry.

Une fois connecté au wifi, pour pouvoir se connecter à la carte raspberry, il faut connaitre son adresse IP. Nous allons utiliser un logiciel qui scanne le réseau afin de retrouver son adresse IP : Advanced port Scanner (http://www.advanced-port-scanner.com/fr/ ).
Ce Logiciel « ping » les diverses adresses IP du réseau et indique les informations qu’il trouve lorsqu’il rencontre une machine.
Il faut juste connaitre la plage réseau qu’on veut balayer :
Exemple : Réseau Classe C 192.168.5 les adresses possibles vont de 1 à 254. Ce qui veut dire que nous allons balayer de 192.168.5.1 à 192.168.5.254

Une fois le scan effectué on repère la (les) carte(s) Raspberry par leur adresse MAC qui commence toujours par B8:27:EB . On peut alors connaitre l’adresse IP de la carte et s’y connecter via WinSCP et PuTTY.

MQTT – utilisation de node-red

Pour le test nous allons utiliser une version de node-red en ligne : https://fred.sensetecnic.com/

Si ce n’est déjà fait, il faut créer un compte (gratuit) afin d’arriver sur l’interface de node-red en ligne.

Une fois le compte créé et validé (vérification par émail), on peut accéder à l’interface de création de flux node-red.

A gauche (repère 1) on trouve le tableau de bord de notre instance FRED, on peut redémarrer l’instance, rajouter des nœuds…

Le repère 2 montre la liste des nœuds disponibles dans notre instance, il y a des nœuds d’entrée (input), de sortie (output), des nœuds de fonction (function)…

Le repère 3 est l’espace de composition des flux (flow dans le jargon node-red) , on y fait glisser des nœuds, que l’on paramètre en double-cliquant dessus. On relie des nœuds entre-eux à l’aide de connexions.

Le repère 4 possède 2 onglets : info et debug. Info donne les informations d’un nœud quand on le sélectionne, c’est une aide en ligne très pratique. L’onglet debug permet d’afficher les information de débogage du flux en utilisant le nœud debug

flux MQTT très simple:

Faire glisser un nœud inject (dans input) et un nœud mqtt (dans output), relier les deux nœuds.

Paramétrer le nœud mqtt : double cliquer dessus. Cliquer alors sur le stylo à droite de la liste déroulante « Add new mqtt broker… »

Saisir alors broker.hivemq.com dans la boite de texte , puis cliquer sur Add

De retour à la configuration de la connexion MQTT compléter le topic avec eiffel/texte

laisser la liste déroulante QoS sur 2, puis cliquer sur Done

Publier le flux en cliquant sur

Dans une autre fenêtre de navigateur, ouvrir une page sur http://www.hivemq.com/demos/websocket-client/ et se connecter. Comme précédemment, créer une souscription à eiffel/texte.
dans la fenètre node-red, cliquer sur le bouton du nœud timestamp : une valeur numérique apparait dans la fenêtre Messages du site HiveMQ.

Node-red envoie correctement une donnée au Broker HiveMQ.

Dans le sens inverse il est aussi possible d’utiliser un flux en tant que souscripteur et d’afficher les messages reçus.

Flux plus complexe

Ce flux est composé à l’aide de :

Inject (input)
Text input (ui)
Button (ui)
Function (function)
Mqtt (input)
Mqtt (output)
Text (ui)

le code du flux complet est le suivant :

[ { "id": "953bb49c.e4ad38", "type": "legacy_ui_text_input", "z": "5230c72.fadcf38", "tab": "84499b6b.8ac208", "mode": "text", "delay": 300, "name": "saisie", "topic": "texte", "group": "Publication", "order": 1, "x": 389, "y": 168, "wires": [ [ "ced9018e.3a8a78" ] ] }, { "id": "9fd6a3b6.540028", "type": "mqtt out", "z": "5230c72.fadcf38", "name": "", "topic": "eiffel/texte", "qos": "", "retain": "", "broker": "ac60999.b095968", "x": 792, "y": 193, "wires": [] }, { "id": "ced9018e.3a8a78", "type": "function", "z": "5230c72.fadcf38", "name": "", "func": "switch (msg.topic)\n{\n case \"texte\" :\n global.set(\"texte\",msg.payload);\n break;\n case \"btn01\" :\n msg.payload=global.get(\"texte\");\n return msg;\n}\n", "outputs": 1, "noerr": 0, "x": 592, "y": 190, "wires": [ [ "9fd6a3b6.540028" ] ] }, { "id": "7204c371.c12724", "type": "legacy_ui_button", "z": "5230c72.fadcf38", "tab": "84499b6b.8ac208", "name": "Envoi", "payload": "btn01", "topic": "btn01", "group": "Publication", "order": 1, "x": 389, "y": 224, "wires": [ [ "ced9018e.3a8a78" ] ] }, { "id": "da2dd664.a80928", "type": "mqtt in", "z": "5230c72.fadcf38", "name": "", "topic": "eiffel/texte", "qos": "2", "broker": "ac60999.b095968", "x": 385, "y": 297, "wires": [ [ "5f6550ac.8a541" ] ] }, { "id": "5f6550ac.8a541", "type": "legacy_ui_text", "z": "5230c72.fadcf38", "tab": "84499b6b.8ac208", "name": "reçu :", "group": "Souscription", "order": 1, "format": "{{msg.payload}}", "x": 786, "y": 302, "wires": [] }, { "id": "84499b6b.8ac208", "type": "legacy_ui_tab", "z": "5230c72.fadcf38", "name": "Home", "icon": "dashboard", "order": "1" }, { "id": "ac60999.b095968", "type": "mqtt-broker", "z": "5230c72.fadcf38", "broker": "broker.hivemq.com", "port": "1883", "clientid": "", "usetls": false, "compatmode": true, "keepalive": "60", "cleansession": true, "willTopic": "", "willQos": "0", "willPayload": "", "birthTopic": "", "birthQos": "0", "birthPayload": "" } ]

Copier/ coller ce texte dans la fenêtre popup qui s’ouvre si on suit Menu import ClipBoard

Le flux complet apparait à l’écran et peut être placé où l’on veut.

La fonction (nœud function) possède le code suivant :

switch (msg.topic)
    {
      case "texte":
          global.set("texte", msg.payload);
          break;
      case "btn01":
          msg.payload = global.get("texte");
          return msg;
     }

Msg.topic permet d’identifier le nœud qui a provoqué l’appel de la fonction, si c’est la boite de texte, on mémorise le texte dans une variable du contexte global. Si l’appel a été provoqué par le clic sur le bouton, on récupère la variable texte du contexte global et on l’affecte à msg.payload, et on retourne msg, de ce fait le texte ressort de la fonction.

Qualité de service QoS ^[1]:

Le niveau de qualité de service le plus simple est le service non confirmé (Unacknowledged Service). Ce niveau utilise une séquence de paquets PUBLISH : l’éditeur envoie un message une seule fois au broker et ce dernier transmet ce message une seule fois aux abonnés. Aucun mécanisme ne garantit la réception du message et le broker ne l’enregistre pas non plus. Ce niveau de qualité de service est également appelé « QoS niveau 0 » ou QoS0, ou encore « At most once » (au plus une fois).

Le deuxième niveau de service est le service confirmé (Acknowledged Service). Ce niveau utilise une séquence de paquets PUBLISH/PUBACK (Publish Acknowledge) entre l’éditeur et son broker, ainsi qu’entre le broker et les abonnés.

Un paquet de confirmation vérifie que le contenu a été reçu et un mécanisme de renvoi du contenu d’origine est déclenché si l’accusé de réception n’est pas reçu en temps voulu. Cela signifie que l’abonné peut recevoir plusieurs copies du même message. Ce niveau de qualité de service est également appelé « QoS niveau 1 » ou QoS1, ou encore « At least once » (au moins une fois).

Le troisième niveau de QoS est le service garanti (Assured Service). Ce niveau délivre le message avec deux paires de paquets. La première est appelée PUBLISH/PUBREC et la seconde, PUBREL/PUBCOMP. Les deux paires s’assurent que quel que soit le nombre de tentatives, le message ne sera délivré qu’une seule fois. Ce niveau de qualité de service est également appelé « QoS niveau 2 » ou QoS2, ou encore « Exactly once » (exactement une fois).

http://www.lemagit.fr/conseil/Internet-des-Objets-bien-comprendre-MQTT ↑

Paramétrage de base d’une carte Raspberry PI

Cet Article explore le menu de configuration de la carte Raspberry Pi afin de paramétrer le système en français et d’exploiter au mieux les ressources du nano-ordinateur.

A partir d’une image de raspbian de base, il faut configurer le raspberry . Pour ce faire, dans l’interface graphique, selectionner Menu-> Préférences -> Raspberry Pi Config. Puis pour chaque onglet effectuer les tâches suivantes :

Dans Timezone choisir Europe puis Paris,

Dans Set Keyboard choisir France et French

Dans Set Wifi Country Choisir France…

Il faut ensuite redémarrer la machine.

Node-Red sur Raspberry pi

topologie de l’installation

La carte raspberry pi est le serveur node-red, elle est reliée à un réseau lui permettant d’accéder à internet. Dans ce réseau des clients peuvent se connecter à la carte raspberry pi. Au travers d’un navigateur web, le client va avoir accès à l’interface de développement, mais aussi à des interfaces homme machine (IHM) développées avec node-red.

Une cible matérielle constituée de capteurs et/ou d’actionneurs interconnectés au bornier de la carte Raspberry Pi. Node-red peut accéder aux composants matériels de la carte Raspberry, ainsi on pourra utiliser les broches GPIO (General Purpose Input/Output), la liaison série, SPI ou I2C…

Node-red est multiplateforme : dans le cas d’un PC ou d’un Mac l’accès aux GPIO est impossible. On peut alors utiliser une carte Arduino comme carte d’interface avec le monde extérieur. Pour ce faire il faut programmer la carte Arduino avec le programme Firmata. Firmata est un protocole permettant de piloter des Entrées/sortie de la carte Arduino par l’interface USB.

lancer node-red

Node Red est livré de manière native avec Raspbian Jessie. depuis l’interface graphique : Menu -> Programmation->Node-RED

Depuis une console :

[shell]pi@rpi01:~ $ node-red-start
[/shell]

Pour stopper node-red

[shell]pi@rpi01:~ $ node-red-stop[/shell]

Une fois lancé node-red démarre un serveur web qui fournit un espace de développement pour un client web.
On peut alors lancer un navigateur qui pointe vers l’adresse du Raspberry sur le port 1880 http://<Adresse IP du Raspberry>:1880

La programmation à proprement parlé consiste à dessiner un diagramme appelé flux ou “flow”. Ce flux est constitué de nœuds ou “node” puisés dans la palette de nœuds à gauche. Les nœuds sont connectés entres-eux par les liaisons. Les nœuds peuvent être paramétrés en double-cliquant dessus.

Exemple

Dans l’interface faire glisser un nœud « inject » et un nœud « debug » puis les relier ensemble.

Double cliquer sur le nœud correspondant à « inject » et vérifier que le champ « Payload » sélectionne bien l’option « timestamp »

Normalement un point bleu est accroché à chaque nœud. Cela signifie que ce flux n’a pas été publié. Il faut donc cliquer sur « Deploy » qui doit être en rouge (en haut à droite de l’interface).

Une fois publié un message « Success » s’inscrit dans la fenêtre, les points bleus disparaissent et « Deploy » devient gris : le flux est prêt à l’usage !

Cliquer sur l’onglet « debug » dans la colonne droite afin de rendre le débogage actif. Cliquer sur le bouton de « TimeStamp » (l’espèce d’oreille à gauche de timestamp »). Dans la fenêtre de debug on voit alors apparaitre un nombre (1465633234061 dans notre exemple)

Explications.

L’espace de travail permet de créer un/des flux (flow en anglais). Ce flux est composé de nœuds reliés les uns aux autres et qui échangent des informations (d’où la notion de flux). Les nœuds peuvent être des entrées, des sorties ou un mixe des deux. La sortie de chaque nœud fournit un message (msg). Au sens informatique du terme, msg est un objet qui peut contenir plusieurs propriétés. Le message de la plupart des nœuds possède la propriété « payload » (charge utile en français). Ceci explique les paramètres du nœud debug :

En sortie on verra une propriété du message : msg.payload

Le nombre observé correspond donc à la charge utile envoyée par le nœud « timestamp » c’est à dire la date et l’heure courante exprimée au format unix : Il s’agit du nombre de secondes écoulées depuis le 01/01/1970 00 :00.

On peut intégrer un nœud de type fonction pour décoder ce temps unix.

intégration d’une fonction

Faire glisser une fonction sur l’espace de travail. L’insérer entre timestamp et le nœud de debogage (msg.payload)

Puis compléter le nœud fonction avec le code suivant :

[javascript]// Création d’un objet date à partir de payload
var dateActuelle = new Date(msg.payload);
// ajoute une proriété date à msg qui contient la date au format
// chaine de caractères
msg.date = dateActuelle.toString();
//Retourne le message de sorte qu’il puisse être envoyé
return msg;[/javascript]

Le champ « name » correspond à l’étiquette donnée au nœud. Ce nom peut être quelconque, car il n’a aucune liaison avec le code qu’il exécute. Cependant il est plus commode, car plus lisible de lui affecter un nom qui corresponde au job effectué par le nœud.

Ce code va créer un objet date à partir du temps unix fourni par le msg.payload. Ensuite, on convertit cet objet “dateActuelle” en une chaine de caractères (date.toString();) le résultat est alors placé dans une propriété de msg nommée date (msg.date) . Enfin la fonction retourne l’objet msg vers la sortie de la fonction. L’objet msg issu de la fonction contiendra alors 2 propriétés : msg.payload et msg.date qu’on peut exploiter.
Pour ce faire ajouter un autre nœud debug sur l’espace de travail.
Le relier à la sortie de la fonction et modifier ses propriétés de la manière suivante :

Quand on clique sur timestamp, on obtient alors 2 messages dans la fenêtre debug :

l’un représentant msg.payload et l’autre msg.date qui est la version décodée de la date unix.

On peut activer ou désactiver les nœuds debug en cliquant sur leur bouton (l’oreille à droite) qui se replie alors partiellement :

import/export des flux

Cette option permet de sauvegarder les flux. Il existe deux manières d’importer/exporter : par une bibliothèque (Library) stockée sur le raspberry ou par un système de copier/coller. La bibliothèque intégrée au raspberry pi est très simple à utiliser mais présente l’inconvénient que les flux sauvegardés restent dans le nano-ordinateur, ce qui n’est pas très commode pour l’échange, surtout si on accède au raspberry pi via une console ssh. La méthode par le presse-papier est un peu plus indirecte mais permet de récupérer un flux directement sur le client connecté au serveur node-red.

On peut sauvegarder un ou plusieurs nœuds ou un flux entier. La démarche est très simple :

Export

à l’aide de la souris encadrer le/les nœuds à sauvegarder

Ils apparaissent en surbrillance orange.

Sélectionner Menu->Export -> Clipboard

Une fenêtre modale s’ouvre alors avec une boite de texte contenant le code du flux

Il suffit alors de copier ce texte et de le coller dans un fichier (tout éditeur de texte convient).
Par exemple le code de ce tuto est le suivant :

[{"id":"9fb5ed7f.b97cd","type":"inject","z":"41e4001c.26d2e","name":"","topic":"","payload":"","payloadType":"date","repeat":"","crontab":"","once":false,"x":207,"y":119,"wires":[["57f7ca3.a0dc834"]]},{"id":"630b1b83.2a893c","type":"debug","z":"41e4001c.26d2e","name":"","active":true,"console":"false","complete":"payload","x":636,"y":146.5,"wires":[]},{"id":"57f7ca3.a0dc834","type":"function","z":"41e4001c.26d2e","name":"unix conversion","func":"// Création d'un objet date à partir de payload\nvar dateActuelle = new Date(msg.payload);\n// ajoute une proriété date à msg qui contient la date au format \n// chaine de caractères\nmsg.date = dateActuelle.toString();\n//Retourne le message de sorte qu'il puisse être envoyé\nreturn msg;","outputs":1,"noerr":0,"x":430,"y":123,"wires":[["630b1b83.2a893c","66333555.6bc38c"]]},{"id":"66333555.6bc38c","type":"debug","z":"41e4001c.26d2e","name":"","active":true,"console":"false","complete":"date","x":628,"y":96.5,"wires":[]}]

Il s’agit de texte au format json.

Import

La démarche est quasi identique : Menu->Import->Clipboard

Puis coller dans la boite de texte le code qui aura été préalablement copié depuis un fichier texte

Une fois la boite modale fermée, le dessin du flux apparait accroché à la souris, il ne reste plus qu’à le placer dans l’espace de travail.

ce qu’il faut retenir

Node-red permet de programmer des flux d’informations

Les informations se propagent de nœud en nœud à l’aide d’un objet message (msg).

L’objet msg contient une propriété payload (charge utile) qui permet d’exploiter de manière efficace ce qui sort d’un nœud.

Des fonctions écrites en js (javascript) peuvent s’insérer entre deux nœuds. Ces fonctions peuvent créer de nouvelles propriétés à l’objet msg.

Il est possible d’importer/exporter des nœuds ou des flux.

Code source à importer par le presse papier.

[{"id":"9fb5ed7f.b97cd","type":"inject","z":"41e4001c.26d2e","name":"","topic":"","payload":"","payloadType":"date","repeat":"","crontab":"","once":false,"x":207,"y":119,"wires":[["57f7ca3.a0dc834"]]},{"id":"630b1b83.2a893c","type":"debug","z":"41e4001c.26d2e","name":"","active":true,"console":"false","complete":"payload","x":636,"y":146.5,"wires":[]},{"id":"57f7ca3.a0dc834","type":"function","z":"41e4001c.26d2e","name":"unix conversion","func":"// Création d'un objet date à partir de payload\nvar dateActuelle = new Date(msg.payload);\n// ajoute une proriété date à msg qui contient la date au format \n// chaine de caractères\nmsg.date = dateActuelle.toString();\n//Retourne le message de sorte qu'il puisse être envoyé\nreturn msg;","outputs":1,"noerr":0,"x":430,"y":123,"wires":[["630b1b83.2a893c","66333555.6bc38c"]]},{"id":"66333555.6bc38c","type":"debug","z":"41e4001c.26d2e","name":"","active":true,"console":"false","complete":"date","x":628,"y":96.5,"wires":[]}]