Orange Pi (Armbian), remplacer le GPIO par un Arduino/Firmata, Node-RED et Johnny-Five • Domotique et objets connectés à faire soi-même

1Vus

Le GPIO de l’Orange Pi est annoncé comme compatible avec celui du Raspberry Pi. C’est parfaitement exact, mais son utilisation est très compliquée, surtout lorsqu’on débute. Il faut à chaque fois trouver la librairie qui a été adaptée à son langage (Python, Node-RED, C++, NodeJS…). Au mieux, on trouve une version en cours de développement, au pire rien n’existe encore. Il est très facile de remplacer le GPIO de l’Orange Pi par un Arduino fonctionnant avec le firmware Firmata. Pour le piloter, nous utiliserons Node-RED avec le package contrib-gpio et johnny5. Pour ce tutoriel, nous utiliserons un Orange Pi Lite (version WiFi, 512 Mo de Ram) fonctionnant sous Armbian (5.26)

Il y a plusieurs arguments de poids qui penchent en la faveur de l’Orange Pi. Une gamme complète de puissance (présentée ici) est disponible à un prix très raisonnables. Pour de petits projets (IoT, robotique…), l’Orange Pi Zero ou l’Orange Pi Lite pourront se substituer au Raspberry Pi Zero W pour un prix équivalent (11€). On commence à trouver le Raspberry Pi Zero W mais c’est encore difficile de le trouver en dehors d’un kit. On est encore loin des 10€ annoncés.

Quel Arduino choisir ? comparaison des E/S de l’Arduino

En fonction du nombre de connecteurs nécessaire pour votre projet, vous pourrez très facilement opter pour le modèle qui convient. Voici un petit tableau récapitulatif des principales cartes Arduino. Pour ce tutoriel, j’ai opté pour un Arduino Pro Micro 5V/16MHz. Si vous rencontrés des problèmes avec vos clones Arduino, vous trouverez peut être une solution en lisant cet article.

  • Photos indicatives. Les caractéristiques techniques des cartes peuvent être très différentes d’un fabricant à l’autre.

** En fonction du fabricant, notamment sur les clones asiatiques, l’interface de programmation est en USB. Plus simple à utiliser, vous ferrez également l’économie d’un câble FTDI (USB vers port série).

(***) Utilisez ce tableau pour déterminer les spécifications techniques d’un MCU SAMD21 à partir de sa désignation

Image extraite de la documentation technique disponible ici.

Comment installer le firmware Firmata depuis l’IDE Arduino ?

Le firmware Firmata permet d’accéder à toutes les fonctionnalités de l’Arduino via le port série (à l’aide d’un câble USB). Connectez la carte à l’ordinateur et ouvrez l’IDE Arduino. Dans le menu des examples, vous trouverez un sous-menu nommé Firmata. Sélectionnez le firmware qui correspond à votre besoin. Le plus courant est d’utiliser le firmware Standard. Il existe également une version Plus qui permet de communiquer avec des périphériques par liaison série UART, USART ou SoftwareSerial.

Téléversez simplement le firmware sur la carte. C’est prêt !

whb1lgm1vrkngxqgl92r-9705746

Si vous avez des besoins spécifiques, vous pouvez passe par le site Firmata Builder (page de configuration, projet GitHub) qui permet de choisir les fonctionnalités et la vitesse du port série :

  • DigitalInputFirmata : lecture sur les entrées digitales
  • DigitalOutputFirmata : écriture sur les sorties digitales
  • AnalogInputFirmata : lecture sur les entrées analogiques
  • AnalogOutputFirmata : écriture sur les sorties analogiques
  • ServoFirmata  : piloter des servomoteurs
  • I2CFirmata : communiquer avec des appareils sur le bus I2C
  • OneWireFirmata : communiquer avec des appareils sur le bus OneWire
  • StepperFirmata  : contrôler des moteurs à 2 ou 4 fils, pont en H
  • SerialFirmata : communiquer avec des périphériques série en utilisant l’UART (configuration matérielle) ou SoftwareSerial (logiciel)
  • FirmataScheduler : un programmateur de tâche

Téléchargez et décompressez le fichier ino généré par le builder avant de le téléverser comme n’importe quel autre programme depuis l’IDE Arduino.

vq49qtoijpfzoqoshdtl-1191003

Installer Node-RED sur l’Orange Pi (Armbian)

Je vous conseille d’utiliser la distribution Armbian pour Orange Pi. Elle est légère et très régulièrement mise à jour. Vous pouvez opter pour la version server (sans bureau graphique) ou Desktop (ce sera XFCE4). L’Orange Pi Lite (version 512Mo est capable de faire fonctionner le bureau XFCE4) mais si vous n’avez pas besoin d’interface, le mieux est d’opter pour la version serveur afin de garder la puissance de SoC AllWinner pour votre projet. Voici une série d’articles à suivre avant de continuer ce tutoriel :

Installer le module Serialport

Le premier module à installer est Serialport (dépôt GitHub). J’ai essayé d’installer les modules node-red-contrib-arduino et node-red-contrib-gpio sans succès depuis le gestionnaire de palette. Arrêtez Node-RED et placez vous dans le répertoire

cd ~/.node-red/

Puis installez le module serialport avec la commande

sudo npm install serialport --unsafe-perm --build-from-source

Il y aura certainement des messages d’erreur, mais ça fonctionne (il y a toujours des messages d’erreur ou d’alerte avec Nodejs !).

Pourquoi ne pas utiliser le module Arduino pour Node-RED ?

Il existe un module qui permet de communiquer avec le firmware Firmata de l’Arduino. C’est le module node-red-contrib-arduino (page npm du module). Il fonctionne très bien sur Raspberry Pi mais j’ai rencontré des difficultés pour me connecter à Firmata. D’autre part, il est un peu moins complet que Johnny-Five :

  • Digital – accepte 0, 1, true, false, on, off
  • Analogue (PWM) – accepte un entier de 0 à 255
  • Servo – accepte un entier de 0 à 180
  • String – pour envoyer une chaine (String) à l’Arduino

Je vous propose donc d’installer Johnny-Five.

Installer le module Johnny-Five (Johnny 5)

11qilhpk1rihg6wgitrb-4192232

Johnny-Five est un projet Open Source très populaire destiné à la programmation d’objets connectés ou robotique en Javascript (page officielle). Le nom a été inspiré du personnage du film Short Circuit dont voici un petit extrait pour le plaisir de re-découvrir

Il est disponible sous la forme d’un plugin Node-RED. De très nombreuses cartes sont supportées :

  • Arduino Uno
  • SparkFun RedBoard
  • Arduino Leonardo
  • Arduino Mega
  • Arduino Fio
  • Arduino Micro
  • Arduino Mini
  • Arduino Nano
  • Arduino Pro Mini
  • BotBoarduino
  • chipKit Uno32
  • Spider Robot Controller
  • DFRobot Romeo
  • Teensy 3
  • BeagleBone Black
  • CHIP
  • Blend Micro v1.0
  • Electric Imp April
  • Intel Galileo Gen 1
  • Intel Galileo Gen 2
  • Intel Edison Arduino
  • Intel Edison Mini
  • SparkFun Edison GPIO Block
  • SparkFun Arduino Block
  • Intel Joule 570x
  • LightBlue Bean
  • Linino One
  • pcDuino3 Dev Board
  • Pinoccio Scout
  • Raspberry Pi 3 Model B
  • Raspberry Pi 2 Model B
  • Raspberry Pi Zero
  • Raspberry Pi Model A Plus
  • Raspberry Pi Model B Plus
  • Raspberry Pi Model B Rev 1
  • Raspberry Pi Model B Rev 2
  • Particle Core (Spark Core)
  • Particle Photon
  • Sparkfun Photon RedBoard
  • Tessel 2

La liste complète se trouve ici ainsi que les caractéristiques prises en charge. Johnny-Five communique avec le firmware Firmata de l’Arduino sur le port série. Tout fonctionne très bien avec les clones asiatiques.

L’installation de Johnny-Five pose problème depuis le gestionnaire de palette. Depuis le Terminal, placez vous dans le répertoire de Node-RED

cd ~/.node-red

Puis installer les module johnny-five et node-red-contrib-gpio. Si vous suivez ce tutoriel pour Raspberry PI, installez également raspi-io (inutile pour l’Orange Pi, la librairie n’est pas compatible).

sudo npm install -g johnny-five --unsafe-perm --force
sudo npm install -g node-red-contrib-gpio --unsafe-perm --force

Pour tout savoir par les possibilités offertes par Johnny 5, rendez vous sur le WiKi disponible en plusieurs langues : anglais, espagnol, hollandais, portugais et français.

Une fois l’installation terminée, vous avez 3 nouveaux outils (de couleur jaune) dans la palette. Tout d’abord, on trouve deux flows dans Input/Output permettant de piloter directement les entrées en les sorties. Ils ont été installé par le package node-red-contrib-gpio.

owzdcspex1qf8eonz7l5-6466557

Ensuite, on trouve le flow johnny5 dans la palette function

Piloter le GPIO de l’Arduino à l’aide du node GPIO Out

On peut piloter le GPIO de l’Arduino de deux façons. La première est d’utiliser les flows GPIO. Ici, par exemple on va faire clignoter une Led branchée sur la broche 13 de l’Arduino Pro Micro. Commencez par placer un node inject. Définissez un intervalle d’une seconde (every 1 second).

ocfjpo1u08wvzcxlcxqh-4144749

Ensuite ajoutez un node Trigger qui va envoyer un signal On durant 250ms puis Off (vous pouvez modifier la durée)

8vi7xwt5pp4v0kdf4zeg-9277749

Ajouter un node GPIO Out et cliquez sur le crayon à droite du champ de sélection Board. Dans la fenêtre de configuration qui s’ouvre, choisissez Arduino/Firmata dans la liste Nodebot.

cdqwrgofbouyyqtiz3pd-7362764

L’Arduino étant connecté en USB à l’Orange Pi Lite, sélectionnez Local Serial Port dans la liste Connection.

rkhj7hqvsbgcthf7miia-3827786

Pour trouver le port, cliquez sur la loupe. Après quelques secondes, le port sur lequel est branché l’Arduino/Firmata sera présent dans la liste. Donnez un nom à cette carte et terminez en cliquant sur Add.

lyr5qmrmgfqvxbxdx0ns-7370847

Dans la liste Board, choisissez la carte que vous venez de créer.

w71eezw7ytdllxuutsdr-5430361

Dans la liste Type, choisissez Digital (0/1). D’autres types sont disponibles :

  • Analogue (0-255)
  • Servo (0-180)
  • I2C : les propriétés read, write, delay sont disponibles. Nous allons voir dans le paragraphe suivant qu’il est plus facile de passer par le node johnny5 pour récupérer des mesures d’un capteur I2C.

zcru0vjmutwqg29ggs1o-1654306Vous obtenez le flow suivant. Déployez le. Si tout est correct, la led reliée à la broche 12 va se mettre à clignoter.

ltr2hngbfiq1966e1zr2-9987571

Code du flow

[{"id":"86de909b.53432","type":"trigger","z":"802c6c20.fd84e","op1":"true","op2":"false","op1type":"bool","op2type":"bool","duration":"250","extend":false,"units":"ms","reset":"","name":"","x":560.5,"y":263,"wires":[["f9bf5a32.8b8af8"]]},{"id":"a8dc2e92.6857d","type":"inject","z":"802c6c20.fd84e","name":"","topic":"","payload":"","payloadType":"date","repeat":"1","crontab":"","once":false,"x":360.5,"y":263,"wires":[["86de909b.53432"]]},{"id":"f9bf5a32.8b8af8","type":"gpio out","z":"802c6c20.fd84e","name":"","state":"OUTPUT","pin":"12","i2cDelay":"0","i2cAddress":"","i2cRegister":"","outputs":0,"board":"d32705d1.7dc448","x":731.5,"y":263,"wires":[]},{"id":"d32705d1.7dc448","type":"nodebot","z":"","name":"Arduino Pro Micro","username":"","password":"","boardType":"firmata","serialportName":"/dev/ttyUSB0","connectionType":"local","mqttServer":"","socketServer":"","pubTopic":"","subTopic":"","tcpHost":"","tcpPort":"","sparkId":"","sparkToken":"","beanId":"","impId":"","meshbluServer":"https://meshblu.octoblu.com","uuid":"","token":"","sendUuid":""}]

Piloter le GPIO de l’Arduino à l’aide du node Johnny 5

Pour des opérations simples, les nodes GPIO (in/out) peuvent suffire. Pour les autres cas, vous pouvez saisir du code javascript directement dans le node johnny5. Nous verrons plus en détail prochainement comment utiliser la librairie Johnny-Five en Javascript. Ce qu’il faut savoir ici, c’est qu’il n’est pas nécessaire d’appeler la librairie J5 ni d’initialiser la carte (board). Ces opérations sont réalisées par la node. Le code saisi dans le node sera exécuté lorsque la carte est prête (ready).

Nous allons faire clignoter une Led reliée à la broche 13 et récupérer la température et la pression atmosphérique d’un BMP180. La broche SDA du bus I2C se trouve sur la broche A4 de l’Arduino. La broche SCL sur l’A5.

vthgi8ywzt7v6byxlmf1-2359261

Source : Johnny-Five http://johnny-five.io/api/multi/

On créé un objet Led attaché à la broche 12

var led = new five.Led(12);

On créé ensuite un objet Multi qui est spécialisé dans la lecture de mesures multiples (documentation complète). On va définir une fréquence de lecture de 5 secondes (5000 ms).

var multi = new five.Multi({
  controller: "BMP180",
  freq: 5000
});

Pour faire clignoter la Led, on utilise la fonction strobe(durée en ms)

led.strobe(500);

On va ensuite récupérer les mesures du BMP180 à chaque changement et les faire “sortir” du node à l’aide de la commande Node-RED node.send (détail ici).

multi.on("change", function() {
  node.send({payload: {
      temp:  this.thermometer.celsius,
      pa :  this.barometer.pressure
    }
  });
});

On sortira les données sous la forme d’un objet JSON

{
  temp: valueTemp,
  pa : valuePA
}

Voici le code complet qu’il vous suffit de coller dans le node johnny5

var led = new five.Led(12);
var multi = new five.Multi({
  controller: "BMP180",
  freq: 5000
});

// Fait clignoter la Led - Strobe the pin on/off
led.strobe(500);

// Lit la température et la pression atmosphérique sur le BMP180 connecté sur le bus I2C
// Read temp and atm. pressur on BMP180 sensor connected on I2C bus
multi.on("change", function() {
  node.send({payload: {
      temp:  this.thermometer.celsius,
      pa :  this.barometer.pressure
    }
  });
});

Ce qui donne

qnmsslyrixs9gf2ea9bd-5930636

Branchez un Debug en sortie

vlrwrmdsa3qq8mojalgi-8961331

Déployez le flow. Dans l’onglet debug, vous pouvez voir les mesures récupérées sur le BMP180 en I2C !

mzkfcuzbyarru1vnj9ey-7639246

Code du flow

[{"id":"c38fde5c.2f0d5","type":"johnny5","z":"802c6c20.fd84e","name":"Strobe Led(13) + Get BMP180 values","func":"var led = new five.Led(13);\nvar multi = new five.Multi({\n  controller: \"BMP180\",\n  freq: 5000\n});\n\n// Strobe the pin on/off, defaults to 100ms phases\nled.strobe(500);\n\n// Lit la température et la pression atmosphérique sur le BMP180 connecté sur le bus I2C\n// Read temp and atm. pressur on BMP180 sensor connected on I2C bus\nmulti.on(\"change\", function() {\n  node.send({payload: {\n      temp:  this.thermometer.celsius,\n      pa :  this.barometer.pressure\n    }\n  });\n});\n  \n\n\n\n\n","board":"d32705d1.7dc448","noerr":0,"x":435.5,"y":376,"wires":[["b539bf0.738f14"]]},{"id":"b539bf0.738f14","type":"debug","z":"802c6c20.fd84e","name":"","active":true,"console":"false","complete":"false","x":699.5,"y":377,"wires":[]},{"id":"d32705d1.7dc448","type":"nodebot","z":"","name":"Arduino Pro Micro","username":"","password":"","boardType":"firmata","serialportName":"/dev/ttyUSB0","connectionType":"local","mqttServer":"","socketServer":"","pubTopic":"","subTopic":"","tcpHost":"","tcpPort":"","sparkId":"","sparkToken":"","beanId":"","impId":"","meshbluServer":"https://meshblu.octoblu.com","uuid":"","token":"","sendUuid":""}]

Voilà, vous pouvez maintenant utiliser un clone d’Arduino Nano à moins de 2€ pour remplacer le GPIO de l’Orange Pi et vous affranchir des difficultés pour trouver les librairies. Node-RED est un excellent outil de prototypage mais vous allez rapidement trouver que développer dans une petite fenêtre peut s’avérer compliquer pour mettre à point et maintenir vos programmes. Dans le prochain tutoriel, nous verrons comment coder en Javascript et utiliser la librairie Johnny-Five

Avez-vous aimé cet article ?