Piduino par l’exemple

Comme piduino utilise la même API que Arduino, il vous suffit de vous rendre sur la référence Arduino, ou sur n’importe quel site expliquant les fonctions du langage Arduino pour en avoir une documentation.

Premier exemple, Blink !

Le dossier exemples contient des exemples du monde Arduino qui peuvent être utilisés directement avec piduino. La seule chose à ajouter par rapport à l’exemple correspondant Arduino est la ligne :

#include <Piduino.h>

Voici le code source de l’exemple Blink qui fait clignoter une led :

#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 ! Ce nombre dépend de votre modèle de carte Pi, pour le savoir rapidement, vous pouvez taper la commande pido readall 1, qui nous donne, par exemple, l’affichage suivant sur un Raspberry Pi B:

                                    P1 (#1)
+-----+-----+----------+------+---+----++----+---+------+----------+-----+-----+
| sOc | iNo |   Name   | Mode | V | Ph || Ph | V | Mode |   Name   | iNo | sOc |
+-----+-----+----------+------+---+----++----+---+------+----------+-----+-----+
|     |     |     3.3V |      |   |  1 || 2  |   |      | 5V       |     |     |
|   2 |   8 |    GPIO2 |   IN | 1 |  3 || 4  |   |      | 5V       |     |     |
|   3 |   9 |    GPIO3 |   IN | 1 |  5 || 6  |   |      | GND      |     |     |
|   4 |   7 |    GPIO4 |   IN | 1 |  7 || 8  | 1 | ALT0 | TXD0     | 15  | 14  |
|     |     |      GND |      |   |  9 || 10 | 1 | ALT0 | RXD0     | 16  | 15  |
|  17 |   0 |   GPIO17 |   IN | 0 | 11 || 12 | 0 | IN   | GPIO18   | 1   | 18  |
|  27 |   2 |   GPIO27 |   IN | 0 | 13 || 14 |   |      | GND      |     |     |
|  22 |   3 |   GPIO22 |   IN | 0 | 15 || 16 | 0 | IN   | GPIO23   | 4   | 23  |
|     |     |     3.3V |      |   | 17 || 18 | 0 | IN   | GPIO24   | 5   | 24  |
|  10 |  12 |   GPIO10 |   IN | 0 | 19 || 20 |   |      | GND      |     |     |
|   9 |  13 |    GPIO9 |   IN | 0 | 21 || 22 | 0 | IN   | GPIO25   | 6   | 25  |
|  11 |  14 |   GPIO11 |   IN | 0 | 23 || 24 | 1 | IN   | GPIO8    | 10  | 8   |
|     |     |      GND |      |   | 25 || 26 | 1 | IN   | GPIO7    | 11  | 7   |
+-----+-----+----------+------+---+----++----+---+------+----------+-----+-----+
| sOc | iNo |   Name   | Mode | V | Ph || Ph | V | Mode |   Name   | iNo | sOc |
+-----+-----+----------+------+---+----++----+---+------+----------+-----+-----+

La colonne iNo correspond au numéro ‘Arduino’, le numéro 0 pin correspond donc à la broche 11 du connecteur GPIO (GPIO17).

Pour compiler le programme blink sur la ligne de commande, vous devez taper le commander:

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

La dernière partie de la commande utilise pkg-config pour ajouter les options de construction à g ++ afin de compiler le programme correctement.

Vous pouvez ensuite exécuter le programme:

 $ sudo ./blink

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

$ sudo chmod u+s blink
$ ./blink

Pour disposer d’un environnement de développement plus convivial, il est conseillé d’utiliser Codelite, l’installation de piduino ajoute un modèle de programme pour piduino. Pour créer un nouveau programme piduino dans Codelite, il faut, une fois votre workspace créé, utiliser le menu Workspace/New Project et sélectionner le modèle Simple Executable (C++ piduino) :

Modèle de projet Codelite pour piduino

Dans Codelite, on peut non seulement compiler, mais aussi éditer et surtout déboguer le programme :

Débogage avec Codelite

Deuxième exemple

le deuxième exemple rtc_bq32k, utilise la bibliothèque Wire pour lire l’heure dans un circuit BQ32000 RTC.

Cela permet de découvrir 2 différences importantes entre une carte Arduino et une carte Pi :

  1. Tout d’abord, sur une carte Pi, l’interface homme-machine (écran et clavier) est fait sur la ligne de commande (la console !). Sur Arduino, le port série est utilisé.
  2. Sur une carte Pi, un programme peut se terminer pour donner la main à l’utilisateur. Sur Arduino, le programme ne s’arrête jamais (en fait, sur un système Linux, le programme du noyau ne s’arrête jamais non plus …)

Pour résoudre le premier problème, piduino définit un objet Console dont le l’utilisation est identique à l’objet Serial (c’est une classe dérivée de Stream).

Afin de permettre la compilation sur les deux plates-formes sans modifier le code source, nous pouvons ajouter au début du programme un bloc qui teste si la plate-forme cible est un système Unix/Linux (piduino), si c’est le cas, on inclut le fichier Piduino.h, sinon on définit un alias de Console qui correspond à Serial, c’est-à-dire que l’interface homme-machine est sur le port série.

#ifdef __unix__
#include <Piduino.h>  // All the magic is here ;-)
#else
// Defines the serial port as the console on the Arduino platform
#define Console Serial
#endif

#include <Wire.h>

void printBcdDigit (byte val, bool end = false) {
  val = (val / 16 * 10) + (val % 16); // BCD to DEC

  if (val < 10) {
    Console.write ('0'); // leading zero
  }
  if (end) {

    Console.println (val);
  }
  else {

    Console.print (val);
    Console.write (':');
  }
}

void setup() {

  Console.begin (115200);
  Wire.begin(); // Starting the i2c master
}

void loop() {

  Wire.beginTransmission (0x68); // start of the frame for the RTC at slave address 0x68
  Wire.write (0); // write the address of the register in the RTC, 0 first register
  Wire.endTransmission (false); // restart condition
  Wire.requestFrom (0x68, 3); // 3-byte read request

  if (Wire.available() == 3) { // if the 3 bytes have been read
    byte sec = Wire.read();
    byte min = Wire.read();
    byte hour = Wire.read() & 0x3F; // remove CENT_EN and CENT LSB bits

    // time display
    printBcdDigit (hour);
    printBcdDigit (min);
    printBcdDigit (sec, true);
  }
  exit (0); // exit the loop() function without ever coming back.
  // On Arduino, exit() performs an infinite loop as explained on
  // https://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html
  // on a Pi board, exit () stops the program by returning the supplied value.
}

Pour résoudre le second problème, il est possible d’utiliser sur les 2 les plates-formes, la fonction exit() (définie dans le bibliothèque standard). Cette fonction, compatible avec les deux plates-formes, permet d’arrêter l’exécution la fonction loop().

Sur un système Unix/Linux, cela arrête le programme et revient à la ligne de commande, sur Arduino, cela effectue une boucle infinie (après avoir appelé le destructeur d’objets C++).

Configuration de piduino

piduino détecte le modèle de carte sur lequel il s’exécute au moment du lancement du programme qui l’utilise, ainsi si vous installez le même paquet Armbian libpiduino, en architecture armhf par exemple, sur une carte Nano Pi Neo et sur Orange Pi Zero, piduino détectera automatiquement le bon modèle de carte !

Comment fait-il ?

Il utilise les fichiers présents sur la machine hôte pour le savoir. Il commence par scruter les fichiers /etc/friendlyelec-release puis /etc/armbian-release à la recherche d’un champ BOARD lui indiquant la signature de la carte (tag), si il ne trouve rien, il scrute le fichier /proc/cpuinfo à la recherche d’un numéro de révision correspondant à une carte Raspberry Pi de la base de données, si il ne le trouve pas, il ne peut le deviner ! vous aurez donc une erreur.

Il est possible de forcer le choix du modèle de carte Pi en utilisant le fichier de configuration /etc/piduino.conf.

Cela peut être nécessaire lorsque le programme ne peut pas détecter la configuration de la carte. Par exemple, dans le cas du NanoPi Neo Core/Core2, nous pouvons indiquer que la carte est sur son shield, dans ce cas, l’affichage du connecteur par la commande pido readall sera adaptée.

Comme expliqué précédemment, la détection de modèle de carte Pi utilise deux méthodes:
* La première méthode, qui s’applique aux cartes Raspberry Pi, lit le Fichier /proc/cpuinfo pour obtenir le modèle de microprocesseur dans le champ Hardware et la version du matériel dans le champ Revision. Ce numéro de révision est comparé avec le base de données pour en déduire le modèle RaspberryPi.
* La deuxième méthode, qui s’applique aux cartes utilisant ArmBian, vient de la lecture /etc/armbian-release ou /etc/friendlyelec-release pour obtenir le modèle de carte dans BOARD. piduino compare cette signature avec la base de données pour en déduire le modèle RaspberryPi.

Dans le fichier de configuration /etc/piduino.conf, nous trouverons ces deux possibilités, qu’il faut renseigner (l’une ou l’autre, mais jamais les deux !).

Par exemple, si nous voulons indiquer que notre NanoPi Neo Core2 est installé sur son shield, nous mettrons la valeur du champ tag à nanopineocore2shield:

# PiDuino configuration file
connection_info="sqlite3:db=/usr/local/share/piduino/piduino.db"

# Allows you to force the board tag (Armbian)
# !! Be careful, this is at your own risk !!
# !! Forcing an incorrect value may destroy GPIO pins !!
tag="nanopineocore2shield"

# Allows forcing the revision of the board (Raspbian)
# !! Be careful, this is at your own risk !!
# !! Forcing an incorrect value may destroy GPIO pins !!
#revision=0xa02082

On peut constater que le fichier de configuration contient également l’adresse de la base de données à utiliser. La base de données est par défaut un fichier SQLite3 local, mais cette base de données peut être installée sur un serveur MySQL par exemple (pour le format de la ligne connection_info Voir la documentation de CPPDB).

piduino

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 !