Activer SSH au premier boot d’une carte Raspberry Pi

Depuis la dernière version de Raspbian Jessie (nov 2016) ssh est déactivé par défaut. Il faut donc se connecter via l’interface graphique et activer ssh dans la configuration de raspberry ( bouton framboise -> Préférences -> configuration du Raspberry Pi puis dans l’onglet “Interfaces” cocher SSH)
Si on possède une carte Raspberry qui n’est pas connectée à un ensemble clavier/souris/écran, il semble impossible de se connecter…
La solution consiste à ajouter un fichier (vide) nommé ssh dans la partition boot (c’est la partition visible lorsque la carte SD est introduite dans un PC Windows).
Au premier boot Raspberry détecte le fichier ssh, active le protocole ssh et efface le fichier ssh sur la partition boot.

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 avec Arduino

Pour arduino il existe une bibliothèque qui permet de créer un client permettant de publier et de souscrire à un topic.
Le code suivant permet de souscrire auprès d’un broker public gratuit : broker.hivemq.com

/*
  Basic MQTT example
  This sketch demonstrates the basic capabilities of the library.
  It connects to an MQTT server then:
  - publishes "Arduino Connected" to the topic "eiffel/texte"
  - subscribes to the topic "eiffel/texte", printing out any messages
  it receives. NB - it assumes the received payloads are strings not binary
  It will reconnect to the server if the connection is lost using a blocking
  reconnect function. See the 'mqtt_reconnect_nonblocking' example for how to
  achieve the same result without blocking the main loop. */
#include 
#include 
#include 
byte mac[] = { 0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED };
char server[] = "broker.hivemq.com";
void callback(char* topic, byte* payload, unsigned int length) {
	Serial.print("Message arrived [");
	Serial.print(topic);
	Serial.print("] ");
	for (int i = 0; i < length; i++) {
		Serial.print((char)payload[i]);
	}
	Serial.println();
}
EthernetClient ethClient;
PubSubClient client(ethClient);
void reconnect() {
	// Loop until we're reconnected
	while (!client.connected()) {
		Serial.print("Attempting MQTT connection...");
		// Attempt to connect
		// rename "arduinoClient" with an unique Id
		// like "arduinoClient1524ztSDeRT"
		if (client.connect("arduinoClient")) {
			Serial.println("connected");
			// Once connected, publish an announcement...
			client.publish("eiffel/texte", "Arduino connected");
			// ... and resubscribe
			client.subscribe("eiffel/texte");
		}
		else {
			Serial.print("failed, rc=");
			Serial.print(client.state());
			Serial.println(" try again in 5 seconds");
			// Wait 5 seconds before retrying
			delay(5000);
		}
	}
}
void setup()
{
	Serial.begin(115200);
	client.setServer(server, 1883);
	client.setCallback(callback);
	Ethernet.begin(mac); // get IP via DHCP
	// Allow the hardware to sort itself out
	delay(1500);
}
void loop()
{
	if (!client.connected()) {
		reconnect();
	}
	client.loop();
}

 

Pour tester le programme, il faut que la carte réseau de l’Arduino soit connectée à un réseau ayant accès à internet (adresse IP et passerelle renseignée) le programme utilise un paramétrage automatique DHCP.
Hivemq met à disposition une interface de test : http://www.hivemq.com/demos/websocket-client/
Le paramétrage est simple :
Cliquer sur le bouton Connect (laisser les paramètres par défaut)

Une fois connecté, déplier le bandeau Subscriptions et cliquer sur Add New Topic Subscription

Saisir alors le Topic du programme Arduino : eiffel/texte

Provoquer un reset de la carte Arduino, lancer le moniteur Série et observer la page hiveMQ, le message “Arduino connected” apparait, ce qui signifie que Arduino a publié ce message sur le topic eiffel/texte et que cela fonctionne !

Taper un message dans la fenêtre Publish du site HiveMQ et cliquer sur Publish, On voit normalement arriver le message dans la console du moniteur Arduino.

Si la carte Arduino tente de se reconnecter en permanence, c’est que l’Identifiant de connexion est déjà utilisé par un autre appareil. il faut modifier la ligne 37
[cpp ]
if (client.connect(“arduinoClient”)) {
[/cpp]
et remplacer “arduinoClient” par un identifiant unique
[cpp”]
if (client.connect(“mon_identifiant_perso_1872AZT123p”)) {
[/cpp]

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).

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

MQTT : Utiliser un service de messagerie dédié à l’internet des objets

MQTT ou MQ Telemetry Transport (MQ signifiant Message Queue) est un protocole de messagerie extrêmement simple et léger conçu pour les appareils à faible ressources (genre Arduino) et des réseaux à bande passante limitée. Ce protocole est idéal pour les applications M2M (Machine To Machine) et l’internet des objets ainsi que pour les applications mobiles où bande passante et économie d’énergie sont primordiales

MQTT permet à divers appareils de publier des informations (par exemple une sonde de température peut publier le résultat de ses mesures) vers un serveur nommé « BROKER » (courtier en français). Le broker pousse alors les données vers les clients qui sont abonnés au service. Pour différencier les différents services, les objets publient leurs résultats dans des « topics ». Le topics s’écrivent en utilisant un format permettant plusieurs niveaux, chaque niveau est séparé par un slash « / »
Par exemple :

smarthome/chambre/temperature
smarthome/chambre/light

http://www.frugalprototype.com/wp-content/uploads/2015/12/mqttschema.png

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

topologie node red

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":[]}]