piduino

Publié le par

Arduino sur cartes Pi, le meilleur des deux mondes !

piduino est une bibliothèque C++ pour cartes Pi qui permet d’utiliser les entrées-sorties comme GPIO, I2C, SPI, UART… avec une API aussi proche que possible du langage Arduino.
La description des cartes Pi utilise un modèle « Objet » stocké dans une base de données qui permet d’ajouter facilement de nouveaux modèles de cartes.

Actuellement, les modèles SoC pris en charge sont AllWinner H-Series et Broadcom BCM2708 à 2710 qui lui permet d’être utilisé sur Raspberry Pi et la plupart des Nano Pi, Orange Pi et Banana Pi.

Pour en savoir plus sur piduino, vous pouvez suivre la Wiki, mais si vous êtes pressé, passons à la version de démarrage rapide …

Guide de démarrage rapide

Le moyen le plus rapide et le plus sûr d’installer piduino sur Armbian est d’utiliser le dépôt APT de piduino.org, vous devriez donc procéder comme suit:

wget -O- http://www.piduino.org/piduino-key.asc | sudo apt-key add -
sudo add-apt-repository 'deb http://apt.piduino.org stretch piduino'
sudo apt update
sudo apt install libpiduino-dev piduino-utils

Ce dépôt fournit les packages piduino pour les architectures armhf etarm64 (et la plupart des librairies et programmes disponibles sur le github de epsilonrt).
Dans les commandes ci-dessus, le dépôt est une distribution Debian Stretch, mais vous pouvez également choisir Ubuntu Xenial ou Bionic en remplaçant stretch par xenial ou bionic. Il peut être nécessaire d’installer le logiciel software-properties-common paquet pour add-apt-repository.

Pour Raspbian, vous devez faire un peu différent:

wget -O- http://www.piduino.org/piduino-key.asc | sudo apt-key add -
echo 'deb http://raspbian.piduino.org stretch piduino' | sudo tee /etc/apt/sources.list.d/piduino.list
sudo apt update
sudo apt installer libpiduino-dev piduino-utils

Le dépôt Raspbian fournit des packages piduino Stretch pour l’architecture armhf uniquement .

Si vous voulez construire piduino à partir de sources, vous pouvez suivre la Wiki.

Utilitaires

Une fois installé, vous devez exécuter ce qui suit sur la ligne de commande:

$ pinfo
Nom: NanoPi Core2 Mini Shield
Famille: NanoPi
ID de base de données: 40
Fabricant: Friendly ARM
Tag Conseil: nanopineocore2shield
SoC: H5 (Allwinner)
Mémoire: 1024 Mo
Identifiant GPIO: 9
Bus I2C: / dev / i2c-0
Bus SPI: /dev/spidev1.0
Ports série: / dev / ttyS1

Comme nous pouvons l’imaginer, dans l’exemple ci-dessus, nous sommes sur une NanoPi Neo Core2 connecté à un Mini Shield.

Pour lire l’état des broches du connecteur 1, exécutez la commande suivante sur la ligne de commande:

$ pido readall 1
                                          CON1 (#1)
+-----+-----+----------+------+------+---+----++----+---+------+------+----------+-----+-----+
| sOc | iNo |   Name   | Mode | Pull | V | Ph || Ph | V | Pull | Mode |   Name   | iNo | sOc |
+-----+-----+----------+------+------+---+----++----+---+------+------+----------+-----+-----+
|     |     |     3.3V |      |      |   |  1 || 2  |   |      |      | 5V       |     |     |
|  12 |   8 |  I2C0SDA | ALT2 |  OFF |   |  3 || 4  |   |      |      | 5V       |     |     |
|  11 |   9 |  I2C0SCK | ALT2 |  OFF |   |  5 || 6  |   |      |      | GND      |     |     |
|  91 |   7 |  GPIOG11 |  OFF |  OFF |   |  7 || 8  |   | OFF  | ALT2 | UART1TX  | 15  | 86  |
|     |     |      GND |      |      |   |  9 || 10 |   | OFF  | ALT2 | UART1RX  | 16  | 87  |
|   0 |   0 |   GPIOA0 |  OFF |  OFF |   | 11 || 12 |   | OFF  | OFF  | GPIOA6   | 1   | 6   |
|   2 |   2 |   GPIOA2 |  OFF |  OFF |   | 13 || 14 |   |      |      | GND      |     |     |
|   3 |   3 |   GPIOA3 |  OFF |  OFF |   | 15 || 16 |   | OFF  | ALT2 | UART1RTS | 4   | 88  |
|     |     |     3.3V |      |      |   | 17 || 18 |   | OFF  | ALT2 | UART1CTS | 5   | 89  |
|  15 |  28 | SPI1MOSI | ALT2 |  OFF |   | 19 || 20 |   |      |      | GND      |     |     |
|  16 |  24 | SPI1MISO | ALT2 |  OFF |   | 21 || 22 |   | OFF  | OFF  | GPIOA1   | 6   | 1   |
|  14 |  29 |  SPI1CLK | ALT2 |  OFF |   | 23 || 24 |   | OFF  | ALT2 | SPI1CS   | 27  | 13  |
|     |     |      GND |      |      |   | 25 || 26 |   | OFF  | OFF  | GPIOA17  | 11  | 17  |
+-----+-----+----------+------+------+---+----++----+---+------+------+----------+-----+-----+
| sOc | iNo |   Name   | Mode | Pull | V | Ph || Ph | V | Pull | Mode |   Name   | iNo | sOc |
+-----+-----+----------+------+------+---+----++----+---+------+------+----------+-----+-----+

pido etpinfo disposent de pages de man…, donc vous pouvez en savoir plus sur ces commandes grâce à :

$ man pido

Exemple Blink

Vous êtes prêt à faire de l’Arduino sur carte Pi ? Ok, allons-y !

Nous allons faire clignoter une led connectée avec une résistance à une broche GPIO. Voilà le code source de l’exemple, qui, à l’exception de la première ligne est identique à celui du tutoriel Arduino :

#include <Piduino.h> // all the magic is here ;-)

const int ledPin = 0; // Header Pin 11: GPIO17 for RPi, GPIOA0 for NanoPi

void setup() {
  // initialize digital pin ledPin as an output.
  pinMode (ledPin, OUTPUT);
}

void loop () {
  // Press Ctrl+C to abort ...
  digitalWrite (ledPin, HIGH);  // turn the LED on (HIGH is the voltage level)
  delay (1000);                 // wait for a second
  digitalWrite (ledPin, LOW);   // turn the LED off by making the voltage LOW
  delay (1000);                 // wait for a second
}

Évidement, vous devez connaître le numéro de broche où vous avez connecté à la led ! Pour ce faire :

$ pido readall 1
                                          CON1 (#1)
+-----+-----+----------+------+------+---+----++----+---+------+------+----------+-----+-----+
| sOc | iNo |   Name   | Mode | Pull | V | Ph || Ph | V | Pull | Mode |   Name   | iNo | sOc |
+-----+-----+----------+------+------+---+----++----+---+------+------+----------+-----+-----+
|     |     |     3.3V |      |      |   |  1 || 2  |   |      |      | 5V       |     |     |
|  12 |   8 |  I2C0SDA | ALT2 |  OFF |   |  3 || 4  |   |      |      | 5V       |     |     |
|  11 |   9 |  I2C0SCK | ALT2 |  OFF |   |  5 || 6  |   |      |      | GND      |     |     |
|  91 |   7 |  GPIOG11 |  OFF |  OFF |   |  7 || 8  |   | OFF  | ALT2 | UART1TX  | 15  | 86  |
|     |     |      GND |      |      |   |  9 || 10 |   | OFF  | ALT2 | UART1RX  | 16  | 87  |
|   0 |   0 |   GPIOA0 |  OFF |  OFF |   | 11 || 12 |   | OFF  | OFF  | GPIOA6   | 1   | 6   |
|   2 |   2 |   GPIOA2 |  OFF |  OFF |   | 13 || 14 |   |      |      | GND      |     |     |
|   3 |   3 |   GPIOA3 |  OFF |  OFF |   | 15 || 16 |   | OFF  | OFF  | GPIOG8   | 4   | 88  |
|     |     |     3.3V |      |      |   | 17 || 18 |   | OFF  | OFF  | GPIOG9   | 5   | 89  |
|  22 |  12 |   GPIOC0 |  OFF |  OFF |   | 19 || 20 |   |      |      | GND      |     |     |
|  23 |  13 |   GPIOC1 |  OFF |  OFF |   | 21 || 22 |   | OFF  | OFF  | GPIOA1   | 6   | 1   |
|  24 |  14 |   GPIOC2 |  OFF |  OFF |   | 23 || 24 |   | UP   | OFF  | GPIOC3   | 10  | 25  |
+-----+-----+----------+------+------+---+----++----+---+------+------+----------+-----+-----+
| sOc | iNo |   Name   | Mode | Pull | V | Ph || Ph | V | Pull | Mode |   Name   | iNo | sOc |
+-----+-----+----------+------+------+---+----++----+---+------+------+----------+-----+-----+

La colonne iNo de ce tableau correspond au numéro ‘Arduino’, le numéro 0 pin correspond donc à la broche 11 du connecteur GPIO (GPIOA0 pour un Nano Pi).

Une fois le code source du programme, enregistré dans le fichier blink.cpp (pas d’extension .ino sous Pi !), vous pouvez construire, vous devez taper la commande:

$ g++ -o blink blink.cpp $(pkg-config --cflags --libs piduino)

Vous pouvez ensuite exécuter le programme:

$ sudo ./blink

sudo est nécessaire pour accéder à la zone mémoire du GPIO. Vous pouvez activer le bit setuid pour éviter sudo à l’avenir:

$ sudo chmod u+s blink
$ ./blink

Avec Codelite c’est plus facile et amusant, non ?

Débogage avec Codelite

Vous devriez lire le wiki sur les exemples pour en savoir plus …

Genèse du projet

piduino est né d’une question d’un de mes étudiants qui m’a demandé pourquoi la programmation des entrées-sorties sur NanoPi n’était pas aussi simple que sur Arduino.

piduino vise donc à répondre à ce besoin:

Une interface de programmation d’application (API) sur les cartes Pi aussi proche que possible de celle d’Arduino.

Cette API doit permettre l’utilisation de GPIO, port série, bus I2C et SPI… sur Raspberry Pi, Nano Pi, Orange Pi, Banana Pi, Beagle Board… comme sur une carte Arduino.

Que propose piduino ?

  • Une interface de programmation API identique à Arduino, à l’exeception du #include <Piduino.h> est ajouté au début du programme. Cela n’interdit pas d’offrir des extensions de l’API mais à condition de rester indépendant de la plate-forme et de ne pas rendre le code incompatible avec Arduino. Il est logique de penser que les utilisateurs qui souhaitent rester dans le monde Arduino utilisent le C++, piduino est destiné à ce cas d’utilisation. Néanmoins, certaines fonctions peuvent être utilisées en langage C (pinMode(), digitalWrite(), …).
  • La description des cartes Pi basée sur un modèle « Objet » stocké dans une base de données (SQLite par défaut), permettant à un utilisateur qui n’est pas forcément un hacker d’ajouter une nouvelle variante de carte Pi SANS programmation. Une variante désigne une carte équipée du même modèle de SoC avec une partie matérielle différente (connecteurs…).
  • Une conception objet en C++ avec une séparation claire de la partie spécifique à la plate-forme. La prise en charge de nouveaux SoC se résume à ajouter une partie « HAL » dans le répertoire src/arch. Les HAL actuellement disponibles sont les Soc AllWinner de la série H (cartes Nano Pi, Banana Pi, Orange Pi …) et les Broadcom de la famille BCM2835 à 37 (cartes Raspberry Pi).
  • Un utilitaire en ligne de commande de manipulation des signaux GPIO : pido
  • Un utilitaire en ligne de commande qui récupère les informations de la carte et le la base de données : pinfo
  • Un programme de gestion de la base de données de cartes Pi: pidbm (en développement…).

Remarque

Il existe déjà quelques projets qui permettent la programmation des entrées-sorties sur cartes embarquées, mais pour un seul modèle de carte Pi.

Le plus connu est probablement wiringPi. wiringPi est une solution prévue pour Raspberry Pi et même s’il y a versions dérivées pour d’autres cartes Pi, ces versions sont des fork « boiteux » de la version originale, d’un point de vue du génie logiciel.

Les raisons qui m’ont amené à ne pas choisir wiringPi sont les suivantes :

  • Même s’il y a une similitude avec la programmation Arduino, il y a des différences qui augmentent avec le temps (et qui perturbe les débutants).
  • wiringPi a été conçu en C pur, ce qui freine l’évolutivité et n’est pas très compatible avec Arduino (le langage Arduino est du C++ !). Il est impossible par exemple de compiler un programme Arduino faisant appel à la liaison série (HardwareSerial) ou aux bus I2c (Wire) et SPI…
  • wiringPi a été conçu pour le Raspberry Pi et son adaptation à d’autres cartes Pi est de plus en plus ingérable, au fur et à mesure de l’arrivée de nouveaux modèles de cartes Pi. Il suffit d’aller sur le site de ArmBian pour voir la multitude de modèles Pi !