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 !

Installer Armbian dans la mémoire eMMC d’une carte Nano Pi

Certaines cartes Nano Pi disposent de mémoire eMMC. C’est le cas des Nano Pi Neo Core et Neo Core2, mais aussi de la Neo Plus2.
Cette mémoire change radicalement l’utilisation possible de ces cartes Nano Pi, en autorisant leur utilisation dans un contexte industriel. En effet, la mémoire MMC (cartes SD ou microSD) dont sont équipées la plupart des cartes concurrentes, comme les cartes Raspberry Pi, a la fâcheuse tendance à rendre l’âme sans prévenir au bout de quelques mois d’utilisation. Il suffit de lancer une recherche sur un moteur de recherche avec les mots clés { sd card corrupted raspberry pi } pour comprendre le problème.

Les cartes Nano Pi équipées de mémoire de mémoire eMMC sont livrées avec le système d’exploitation “maison” qui est une version modifiée de ArmBian basé sur Ubuntu Xenial. Bien que ce choix soit celui de la simplicité, il amène à se pencher, dans un contexte industriel, sur la pérennité, l’évolutivité et la sécurité de cette solution.

La distribution ArmBian prenant en charge les cartes Nano Pi, il apparaît bien plus intéressant de se tourner vers cette solution. Cette solution permettra, par exemple, de recompiler “rapidement” les paquets du noyau (BSP) afin d’y intégrer des drivers absents de l’image par défaut (IIO par exemple). ArmBian fournit le script compile.sh qui permet de faire cela très simplement.

Dans cet article, nous allons voir comment installer ArmBian dans la mémoire eMMC d’une carte Nano Pi Core LTS. Cette carte sera implantée dans son mini-shield afin de pouvoir effectuer le prototypage.

Nous utiliserons comme environnement de travail un PC sous GNU Linux, car c’est beaucoup plus simple de travailler sur une carte Nano Pi à partir d’un PC sous GNU Linux. Pour ceux qui en doute, il suffit de se reporter à mon article sur Codelite.

Téléchargement de l’image ArmBian

L’image que nous avons choisi est la version Stretch basée sur Debian. Elle peut être téléchargée sur la page de téléchargement de ArmBian consacrée à la carte NanoPi Neo (et Core).

Une fois le fichier archive 7z téléchargé, puis décompressé on oubliera pas de vérifier la signature SHA256 du fichier afin de vérifier son intégrité…

$ 7za e Armbian_5.69_Nanopineo_Debian_stretch_next_4.19.13.7z 

7-Zip (A) [64] 9.20  Copyright (c) 1999-2010 Igor Pavlov  2010-11-18
p7zip Version 9.20 (locale=fr_FR.UTF-8,Utf16=on,HugeFiles=on,8 CPUs)

Processing archive: Armbian_5.69_Nanopineo_Debian_stretch_next_4.19.13.7z

Extracting  Armbian_5.69_Nanopineo_Debian_stretch_next_4.19.13.img
Extracting  Armbian_5.69_Nanopineo_Debian_stretch_next_4.19.13.img.asc
Extracting  armbian.txt
Extracting  sha256sum.sha

Everything is Ok

Files: 4
Size:       1103121482
Compressed: 266049577
$ sha256sum -c sha256sum.sha 
Armbian_5.69_Nanopineo_Debian_stretch_next_4.19.13.img: Réussi

Écriture de l’image sur carte microSD

Pour écrire l’image dans la mémoire eMMC, il faudra passer par une carte microSD. Une fois le système transféré en eMMC, cette carte SD pourra être retirée. La solution la plus simpliste pour écrire une image sur une carte SD est dd, mais il existe une solution beaucoup plus confortable et “sécurisée”, elle s’appelle Etcher.

Balena Etcher en action

Je vous conseille donc d’utiliser Etcher pour écrire votre image sur la carte microSD. Pour l’installer proprement, il est préférable d’ajouter le dépôt de paquets :

echo "deb http://deb.etcher.io stable etcher" | sudo tee /etc/apt/sources.list.d/balena-etcher.list
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 379CE192D401AB61
sudo apt-get update
sudo apt-get install balena-etcher-electron

Démarrage de la carte Nano Pi sur la carte microSD

Une fois l’image écrite sur la carte microSD, il suffit de l’insérer dans la carte Nano Pi et de l’alimenter.

La première connexion se fera sur la liaison série de débogage (UART0). On utilisera pour ce faire, un adaptateur série-USB connecté au connecteur DBG_UART du mini-shield et un logiciel d’émulation de terminal comme gtkTerm ou minicom.

Lors de la première connexion, le mot de passe root est ‘1234’. Il devra être modifié pour un plus sûr ;-| et vous aurez la possibilité de créer un utilisateur. Je vous conseille de créer un utilisateur pi dans un premier temps.

Transfert du système en mémoire eMMC

Pour transférer le système de la microSD vers la mémoire eMMC, il suffit d’utiliser la commande :

sudo nand-sata-install 

On choisira ensuite le menu system on eMMc puis le type ext4.

Après quelques minutes de patience… On arrêtera proprement le système. Après coupure de l’alimentation, on retirera la carte microSD avant de redémarrer sur la mémoire eMMC… 🙂

Utilisation de MODBUS sur NanoPi

MODBUS est un protocole de communication non-propriétaire, créé en 1979 par Modicon, utilisé pour des réseaux d’automates programmables, relevant du niveau applicatif, c’est-à-dire du niveau 7 du Modèle OSI. Ce protocole basé sur une structure hiérarchisée entre un client unique et plusieurs serveurs est dans le domaine public et sa spécification est publique.

Ce protocole a rencontré beaucoup de succès depuis sa création du fait de sa simplicité et de sa bonne fiabilité. Il repose sur un protocole maître-esclave.

Le protocole MODBUS peut être implémenté :

  • sur une liaison série asynchrone de type RS-232, RS-422 ou RS-485 ou TTY (boucle de courant), avec des débits et sur des distances variables ; on parle alors de MODBUS over Serial Line;
  • via TCP/IP sur Ethernet ; on parle alors de MODBUS over TCP/IP ; le port logiciel 502 est dédié à ce protocole
  • via ModBus Plus. ModBus Plus est un réseau à passage de jetons à 1 Mb/s, pouvant transporter les trames Modbus et d’autres services propre à ce réseau.

Une liaison multipoints de type RS-485 relie client et serveurs via une paire différentielle qui permet un débit élevé (jusqu’à 10 méga-bits par seconde) sur une distance importante (jusqu’à 1 200 m). Elle ne dispose que de 2 bornes qui alternativement passent les données dans un sens puis dans l’autre.

Sur une liaison série asynchrone, le codage des caractères peut être en binaire (RTU) ou en ASCII (plus lent !).

Le NanoPi est probablement le plus récent des concurrents du Raspberry Pi. FriendlyARM mise sur les prix et la compacité.

Dans cet article nous allons apprendre à contrôler des esclaves MODBUS à partir d’un NanoPi Neo utilisant une liaison RS485 (en RTU).

Le NanoPi utilise un système Armbian en version 5.41 (kernel 4.14.18), c’est important de la savoir car la configuration des liaisons série (UART) sur les noyaux à partir de la version 4 est totalement différente des précédents noyaux en version 3.4.

Le matériel

Nous avons donc besoin d’un module supplémentaire afin d’adapter les signaux de l’UART du NanoPi au RS485. Il faut qu’il soit alimenté en 3.3V, tension utilisée par tous les signaux du GPIO.

Nous pouvons choisir celui de Sparkfun qui utilise un circuit SP3485. On trouve des clones de ce module sur le site AliExpress pour quelques centimes d’euros.

Nous choisissons d’utiliser l’UART1 du NanoPi. Nous utiliserons donc les signaux:

  • UART1_TX (PG6, broche 8 du GPIO) qui sera relié au signal DI (Driver Input) du SP3485 (RX-I sur le module Sparkfun)
  • UART1_RX (PG7, broche 10 du GPIO) qui sera relié au signal RO (Receiver Output) du SP3485 (TX-O sur le module Sparkfun)
  • UART1_RTS (PG8, broche 16 du GPIO) qui sera relié aux signaux DE (Driver Enable) et /RE (Receiver Enable) du SP3485 (rélié ensemble à RTS sur le module Sparkfun). Ce signal est très important car il assure le multiplexage half-duplex sur la paire différentielle.
  • GND (broche 6 du GPIO) et 3.3V (broche 1 du GPIO) qui seront reliés respectivement aux broches GND et 3-5V sur le module Sparkfun.

La connexion du ou des esclaves MODBUS se fera conformément au standard RS485. Il convient de bien repéré la polarité de la paire différentielle (brancher à l’envers: ça ne marche pas ! hein Mickaël). Comme le décrit cet article, ce problème est loin d’être simple. En effet, certains fabricant repère leurs broches par A et B, mais ne respectent par la standard RS485.

C’est la raison pour laquelle, il est préférable de raisonner en borne + et borne -. Sur la ligne, toutes les bornes + de la paire différentielles seront reliées ensemble (idem pour le -). L’inversion de polarité est la cause de “panne” la plus courante sur un bus RS485, on vérifiera donc systématiquement ce point (en vérifiant le schéma interne de l’esclave si nécessaire) en cas de dysfonctionnement.

Une autre cause de dysfonctionnement sur RS485 est l’absence de résistances de terminaison et/ou de polarisation. Pour que la laison fonctionne dans de bonnes conditions, il faut que la paire différentielle:

  • soit terminée à chaque extrémité par une résistance de terminaison de 120 ohms (dépend de l’impédance caracttistique du câble)
  • soit polarisée en l’absence de signal par une résistante reliant le VCC à la borne + et une résistance reliant le GND à la borne – (voir cet article )

Cablage RS485

Configuration du NanoPi

Il est nécessaire de valider l’UART1 et d’activer le signal RTS sur la NanoPi.

Pour valider l’UART1, il suffit de lancer Armbian-config:

$ sudo armbian-config

Il faut ensuite chosir le menu System puis Hardware et valider uart1. Il faudra accepter le redémarrage proposé…

Armbian-config

Pour activer le signal RTS, il faut modifier le fichier /boot/armbianEnv.txt :

$ sudo nano /boot/armbianEnv.txt

On y ajoutera la ligne :

param_uart1_rtscts=1

Puis il faut redémarrer le NanoPi.

La liaison série de l’UART1 est accessible par le fichier /dev/ttyS1

Le logiciel

Nous utiliserons le logiciel mbpoll en version 1.4.

mbpoll est un utilitaire en ligne de commande permettant de dialoguer avec des esclaves ModBus RTU ou TCP.
Il utilise libmodbus.

mbpoll permet de:

  • lire des entrées discrètes
  • lire et écrire des sorties binaires (coil)
  • lire des registres d’entrée (input register)
  • lire et écrire des registres de sortie (holding register)

La lecture et l’écriture de registres peut se faire au format décimal, hexadécimal ou flottant simple précision.

Installation de mbpoll

Le moyen le plus rapide et le plus sûr d’installer mbpoll consiste à utiliser le référentiel APT de piduino.org. Vous devez 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 mbpoll

Ce référentiel fournit les packages mbpoll et libmodbus (version 3.1.4) pour les architectures i386, amd64, armhf et arm64. Dans les commandes ci-dessus, le référentiel est une distribution Debian Stretch, mais vous pouvez également choisir Ubuntu Xenial en remplaçant stretch par xenial.

Des explications plus complètes sur l’installation et la compilation sont disponibles sur le site de mbpoll.

Utilisation de mbpoll

mbpoll dispose d’une aide en ligne avec l’option -h :

$ mbpoll -h
usage : mbpoll [ options ] device|host [ writevalues... ] [ options ]

ModBus Master Simulator. It allows to read and write in ModBus slave registers
                         connected by serial (RTU only) or TCP.

Arguments :
  device        Serial port when using ModBus RTU protocol
                  COM1, COM2 ...              on Windows
                  /dev/ttyS0, /dev/ttyS1 ...  on Linux
                  /dev/ser1, /dev/ser2 ...    on QNX
  host          Host name or dotted IP address when using ModBus/TCP protocol
  writevalues   List of values to be written.
                If none specified (default) mbpoll reads data.
                If negative numbers are provided, it will precede the list of
                data to be written by two dashes ('--'). for example :
                mbpoll -t4:int /dev/ttyUSB0 -- 123 -1568 8974 -12
General options : 
  -m #          mode (rtu or tcp, TCP is default)
  -a #          Slave address (1-255 for rtu, 0-255 for tcp, 1 is default)
                for reading, it is possible to give an address list
                separated by commas or colons, for example :
                -a 32,33,34,36:40 read [32,33,34,36,37,38,39,40]
  -r #          Start reference (1 is default)
  -c #          Number of values to read (1-125, 1 is default)
  -u            Read the description of the type, the current status, and other
                information specific to a remote device (RTU only)
  -t 0          Discrete output (coil) data type (binary 0 or 1)
  -t 1          Discrete input data type (binary 0 or 1)
  -t 3          16-bit input register data type
  -t 3:hex      16-bit input register data type with hex display
  -t 3:int      32-bit integer data type in input register table
  -t 3:float    32-bit float data type in input register table
  -t 4          16-bit output (holding) register data type (default)
  -t 4:hex      16-bit output (holding) register data type with hex display
  -t 4:int      32-bit integer data type in output (holding) register table
  -t 4:float    32-bit float data type in output (holding) register table
  -0            First reference is 0 (PDU addressing) instead 1
  -B            Big endian word order for 32-bit integer and float
  -1            Poll only once only, otherwise every poll rate interval
  -l #          Poll rate in ms, ( > 100, 1000 is default)
  -o #          Time-out in seconds (0.01 - 10.00, 1.00 s is default)
Options for ModBus / TCP : 
  -p #          TCP port number (502 is default)
Options for ModBus RTU : 
  -b #          Baudrate (1200-921600, 19200 is default)
  -d #          Databits (7 or 8, 8 for RTU)
  -s #          Stopbits (1 or 2, 1 is default)
  -P #          Parity (none, even, odd, even is default)
  -R [#]        RS-485 mode (/RTS on (0) after sending)
                 Optional parameter for the GPIO RTS pin number
  -F [#]        RS-485 mode (/RTS on (0) when sending)
                 Optional parameter for the GPIO RTS pin number

  -h            Print this help summary page
  -V            Print version and exit
  -v            Verbose mode.  Causes mbpoll to print debugging messages about
                its progress.  This is helpful in debugging connection...

Par exemple si l’on souhaite lire les 2 premiers regsitres d’entrée (1 et 2 donc) d’un esclave à l’adresse décimale 33 connecté en RS485 avec un baudrate de 38400 et une période d’interrogation de 500 millisecondes :

$ mbpoll -a33 -b38400 -t3 -c2 -R  /dev/ttyS1 -l 500
mbpoll 1.4 - FieldTalk(tm) Modbus(R) Master Simulator
Copyright © 2015-2018 Pascal JEAN, https://github.com/epsilonrt/mbpoll
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under certain conditions; type 'mbpoll -w' for details.

Protocol configuration: Modbus RTU
Slave configuration...: address = [33]
                        start reference = 1, count = 2
Communication.........: /dev/ttyS1,      38400-8E1 
                        t/o 1.00 s, poll rate 500 ms
Data type.............: 16-bit register, input register table

-- Polling slave 33... Ctrl-C to stop)
[1]:  9975
[2]:  10021
-- Polling slave 33... Ctrl-C to stop)
[1]:  9997
[2]:  10021
^C--- /dev/ttyS1 poll statistics ---
2 frames transmitted, 2 received, 0 errors, 0.0% frame loss

everything was closed.
Have a nice day !

On peut voir à l’oscilloscope que la transmission s’effectue correctement :

Signaux RS485

En voie 1 on a le signal RTS (DE/RE) et en voie 2 le signal TX (DI).

Si on souhaite lire l’identifiant de l’esclave (Code fonction 17: Report Slave ID) :

$ mbpoll -a33 -b38400 -u -R  /dev/ttyS1 
mbpoll 1.4 - FieldTalk(tm) Modbus(R) Master Simulator
Copyright © 2015-2018 Pascal JEAN, https://github.com/epsilonrt/mbpoll
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under certain conditions; type 'mbpoll -w' for details.

Protocol configuration: Modbus RTU
Slave configuration...: address = 33, report slave id
Communication.........: /dev/ttyS1,      38400-8E1 
                        t/o 1.00 s, poll rate 1000 ms
Length: 14
Id    : 0x02
Status: On
Data  : press-1.1.58

mbpoll dispose d’un mode “mise au point” grâce à l’option -v, très pratique pour le dépannage :

$ mbpoll -a33 -b38400 -u -R  /dev/ttyS1 -v
debug enabled
Set mode to RTU for serial port
Set device=/dev/ttyS1
mbpoll 1.4 - FieldTalk(tm) Modbus(R) Master Simulator
Copyright © 2015-2018 Pascal JEAN, https://github.com/epsilonrt/mbpoll
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under certain conditions; type 'mbpoll -w' for details.

Opening /dev/ttyS1 at 38400 bauds (E, 8, 1)
Set response timeout to 1 sec, 0 us
Protocol configuration: Modbus RTU
Slave configuration...: address = 33, report slave id
Communication.........: /dev/ttyS1,      38400-8E1 
                        t/o 1.00 s, poll rate 1000 ms
[21][11][D9][EC]
Sending request using RTS signal
Waiting for a confirmation...
<21><11><0E><02><FF><70><72><65><73><73><2D><31><2E><31><2E><35><38><81><B7>
Length: 14
Id    : 0x02
Status: On
Data  : press-1.1.58

Dans la commande ci-dessus, on peut voir que le NanoPi a envoyer la trame [21][11][D9][EC] et que l’esclave MODBUS lui a répondu <21><11><0E><02><FF><70><72><65><73><73><2D><31><2E><31><2E><35><38><81><B7>.

Utilisation de CodeLite

CodeLite est environnement de développement très léger qui peut facilement être utilisé sur NanoPi (ou toute autre carte Pi).

Dans ce tutoriel, nous allons utiliser Codelite pour créer un programme en langage C simple sur un NanoPi Neo sous ArmBian 5.41 (basé sur une Debian Stretch). Notre programme contiendra un simple printf, pour l’instant, mais 3 autres articles utiliserons ce premier tutoriel comme base afin d’effectuer des opérations sur MODBUS…

Dans un premier temps nous allons nous connecter au NanoPi par SSH à partir d’un système Linux (pour faire simple). Il faut savoir qu’il est possible d’effectuer les mêmes opérations sous MS Windows à condition d’installer un client SSH comme PuTTY, de le configurer pour utiliser le X11 Forwarding et d’installer un serveur X-Window comme Xming. Comme nous voulons faire simple, nous allons nous connecter à partir de Linux 😉

Connexion au NanoPi

Pour se connecter au NanoPi à l’adresse 192.168.122.70 avec mon identifiant (pascal), je tape :

    $ ssh pascal@192.168.122.70

Avant de lancer CodeLite, il faut l’installer ainsi que quelques paquets nécessaires (mais non installés automatiquement) :

    $ sudo apt upate
    $ sudo apt install codelite codelite-plugins hicolor-icon-theme gtk2-engines-pixbuf lxterminal libatk-adaptor libgail-common libcanberra-gtk-module xauth

Une fois les installations effectuées, on se déconnecte, puis on se reconnecte en ajoutant l’option -X et on peut alors lancer CodeLite :

    $ exit
    $ ssh pascal@192.168.122.70 -X
    $ codelite &

La fenêtre ci-dessous s’ouvre.

Création de l’espace de travail

CodeLite utilise des espaces de travail qui permettent de regrouper un ensemble de projets. Pour un espace de travail, on utilise le menu File, puis New, puis Workspace. La fenêtre ci-dessous s’ouvre.

On remplit le nom de notre nouveau workspace (libmodbus-tutorial), on choisit le dossier en cochant la case demandant de créer un nouveau répertoire.

Après avoir cliqué sur Ok, on se retrouve avec le nouvel espace de travail présent dans le bandeau latéral à gauche de la fenêtre de CodeLite:

Création du projet

Dans CodeLite, un programme correspond à un projet. Il existe un grand nombre de modèles présent, mais dans notre cas, nous allons créer un simple programme C en ligne de commande.

Pour créer un nouveau projet, on utilise le menu File, puis New, puis Project (on peut aussi faire un clic-droit sur l’espace de travail dans le bandeau de gauche).

La fenêtre suivante nous permet de choisir le modèle de projet (Simple executable (gcc)):

Il faut alors choisir un nom pour notre projet (hello-world ici) et cocher la case demandant de créer un nouveau répertoire dans celui de l’espace de travail:

Le choix de la chaîne de compilation doit laisser par défaut, il suffit donc de cliquer sur Finish dans la fenêtre suivante:

On voit alors dans le bandeau de gauche notre nouveau projet, en cliquant sur le petit triangle à gauche du dossier bleu hello-world, on peut voir qu’il contient un dossier “virtuel” nommé src que l’on peut lui même dérouler. On voit que le projet contient un seul fichier main.c Un double clic que le fichier main.c permet de l’ouvrir:

Compilation du projet

Pour compiler le programme il faut utiliser le menu Build, puis Build Project. On peut aussi utiliser la touche F7 ou l’icône .

Un rapport en bas de la fenêtre indique que la compilation s’est effectuée avec succès.

Exécution du programme

Pour exécuter le programme on utilise le menu Build, puis Run. On peut aussi utiliser la touche Ctrl+F5 ou l’icône .

Le programme se lance, une fenêtre de terminal s’ouvre et nous affiche le message correspondant à notre prinf:

Un appui sur la touche Entrée met fin au programme.

Exécution en mode pas à pas

Il est possible d’exécuter le programme en mode pas à pas.

Pour lancer l’exécution en mode pas à pas, on utilise le menu Debugger puis Start/Continue Debugger. On peut aussi utiliser la touche F5 ou l’icône

Le mode permet :

  • d’exécuter instruction par instruction (touche F10)
  • d’exécuter instruction par instruction en rentrant dans les fonctions (touche F11)
  • de placer des points d’arrêts afin de stoper le programme lorsqu’il exécute une instruction à une ligne donnée (touche F9)
  • de lancer le programme jusqu’au prochain point d’arrêt ou jusqu’à la fin (touche F5)
  • de relancer le programme (touche Shift+Ctrl+F5)
  • de surveiller le contenu des variables locales (bandeau de droite, onglet Locals)
  • de surveiller d’autres variables: globales … (bandeau de droite, onglet Watch)

Et bien d’autres choses.

Toutes ses actions sont disponible à partir de la barre d’outils dans la bandeau:

Installation d’une RTC sur ArmBian

Sur les Pi Board comme le Raspberry Pi ou le Nano Pi, on ne dispose pas d’horloge temps réel (RTC pour Real Time Clock) capable de mémoriser la date et l’heure lorsqu’on coupe l’alimentation. Les concepteurs de ces cartes sont tout simplement partie du postulat que la carte sera reliée à une réseau disposant d’un serveur de temps NTP. Dans la plupart des cas c’est vrai, mais dans d’autres c’est fortement handicapant ! Cela est d’autant plus navrant, que les processeurs AllWinner H3 et H5 utilisés par les cartes Nano Pi disposent de RTC sur la puce du SoC ! Les concepteurs n’ont juste pas jugé utile de sortir sur une pastille la tension de backup de cette RTC ! La solution est donc d’ajouter un circuit intégré RTC généralement connecté à la carte par le bus I2c.

Le but de ce tutoriel est d’expliquer la procédure d’installation et de configuration d’un circuit RTC sur un système embarqué utilisant ArmBian.

Dans ce document nous utiliserons, pour l’exemple, une RTC Texas Instruments BQ32000 que nous relierons à une carte NanoPi Neo. La version de ArmBian utilisée est la Debian Stretch 5.41 (kernel 4.14.18).

NanoPi Neo

Les broches SDA et SCL de la RTC seront reliées aux broches correspondantes du bus I2c0 du connecteur GPIO (broche 3 et 5).

Vérification de la présence du driver de la RTC

Dans un premier temps, il faut vérifier la disponibilité du driver de la RTC BQ320000 sur le système :

$ sudo find / -name "*bq32*.ko"
/lib/modules/4.14.18-sunxi/kernel/drivers/rtc/rtc-bq32k.ko

Ici le driver est présent et s’appelle rtc-bq32k.ko. Si le fichier n’est pas présent, c’est qu’il n’a pas été compilé lors de la compilation du kernel 🙁 Dans ce cas, il faudra valider la compilation du driver correspondant et recompiler le système. Cette opération sort du contexte de ce document, mais il faut savoir que cela n’est pas très compliqué à condition de disposer d’un PC puissant sous Ubuntu Xenial ! Le site de ArmBian explique la procédure.

Chargement du driver au boot

Avec les noyaux modernes, le chargement des drivers se fait par l’intermédiaire de Device Tree. Device Tree que l’on peut traduire par “Arborescence matérielle” est une façon de décrire tout le matériel disponible sur un système.

Si ce nouveau système a facilité la vie des développeurs de Linux, il a sacrément compliqué celle des utilisateurs qui souhaitent juste ajouter une “chite” RTC sur leur PiBoard préférée. Disons le clairement : Device Tree c’est de la bonne veille “Usine à gaz” conçue par des informaticiens totalement crazy 😀

Heureusement les concepteurs de ArmBian ont choisi de faciliter la vie de leurs utilisateurs, mais il va falloir quand même se retrousser les manches et mettre les mains dans le cambouis !

La site ArmBian présente la procédure.

Ce qu’il faut savoir :

  • Une configuration matérielle est décrite par un fichier overlay d’extension .dtbo qui sont des fichiers binaires (dtbo pour device tree binary overlay)
  • Un fichier overlay est créé à l’aide du compilateur dtc à partir d’un fichier source .dts qui respecte la syntaxe fdt pour Flat Device Tree (et qui est loin d’être abordable pour le non-informaticien…)
  • Les fichiers overlay décrivant la configuration de base de la carte se trouvent dans /boot/dtb
  • Les fichiers overlay des circuits ajoutés se trouvent dans /boot/overlay-user

Choisir la configuration du driver

Chaque driver de circuit disposent d’options pouvant être ajoutées à l’overlay pour modifier son comportement. Ces options sont documentées directement dans les sources du kernel Sic ! Pour la BQ32000 et notre version de noyau c’est ici, voilà le fichier :

* TI BQ32000                I2C Serial Real-Time Clock

Required properties:
- compatible: Should contain "ti,bq32000".
- reg: I2C address for chip

Optional properties:
- trickle-resistor-ohms : Selected resistor for trickle charger
       Values usable are 1120 and 20180
       Should be given if trickle charger should be enabled
- trickle-diode-disable : Do not use internal trickle charger diode
       Should be given if internal trickle charger diode should be disabled
Example:
       bq32000: rtc@68 {
               compatible = "ti,bq32000";
               trickle-resistor-ohms = <1120>;
               reg = <0x68>;
       };

Comme on peut le voir au paragraphe 7.3.3 du datasheet, le BQ32000 peut être utilisé avec une pile ou un super condensateur (de plusieurs Farads !), afin de maintenir l’heure lorsque l’alimentation du Nano Pi est coupée. Dans le cas d’une pile, le circuit de charge (trickle charging) devra être désactivé, dans le cas de l’utilisation d’un super condensateur il doit être activé. C’est le sens des options :

  • trickle-diode-disable qui permet de désactiver le circuit de charge (TCH2 ouvert). Si cette option n’est pas indiquée, le circuit de charge est activé, ce qui peut conduire à l’explosion de la pile !
  • trickle-resistor-ohms qui permet de choisir la résistance du circuit de charge (TCFE ouvert ou fermé). Il sera nécessaire de consulter la documenation du super condensateur pour choisir la configuration correcte (résistance de 1120 ohms, la plupart du temps, cad TCFE ouvert)

Une explication des courants/temps de charge/décharge est présent sur le site de Maxim

Création du fichier source .dts

A partir des fichiers du dossier examples du dépôt sunxi-DT-overlays, on créée le fichier i2c-bq32000.dts suivant :

/dts-v1/;
/plugin/;

/ {
  compatible = "allwinner,sun4i-a10", "allwinner,sun7i-a20", "allwinner,sun8i-h3", "allwinner,sun50i-a64", "allwinner,sun50i-h5";

  /* 
   * Aliases can be used to set the external RTC as rtc0
   * Needs supplying the correct path to the I2C controller RTC is connected to,
   * this example is for I2C0 on H3
   * NOTE: setting time at boot by the kernel
   * may not work in some cases if the external RTC module is loaded too late
   */
  fragment@0 {
    target-path = "/aliases";
    __overlay__ {
      rtc0 = "/soc/i2c@01c2ac00/bq32000@68";
    };
  };

  fragment@1 {
    target = <&i2c0>;
    __overlay__ {
      #address-cells = <1>;
      #size-cells = <0>;
      bq32000@68 {
        compatible = "ti,bq32000";
        reg = <0x68>;
        trickle-diode-disable;
        status = "okay";
      };
    };
  };
};

L’option trickle-diode-disable; étant présente, on est dans le cas de l’utilisation d’une pile, si ce n’est pas le cas, il faudra la remplacer par trickle-resistor-ohms = <1120>; (ou 20180…).

Il faut noter que sur le NanoPi Neo, le bus I2c utilisé est le bus 0. L’adresse de son contrôleur est 0x01c2ac00. Si on utilise une autre carte et/ou un autre bus, il faudra rechercher cette adresse à l’aide de la commande :

$ sudo dtc -qq -I fs /proc/device-tree | grep -e '/soc/i2c@'

Dans le cas du NanoPi Neo cela nous donne à l’affichage :

i2c1 = "/soc/i2c@01c2b000";
i2c2 = "/soc/i2c@01c2b400";
i2c0 = "/soc/i2c@01c2ac00";
r_i2c = "/soc/i2c@01f02400";
i2c0 = "/soc/i2c@01c2ac00";

On voit que le SoC H3 du NanoPi Neo dispose de 3 bus I2c aux adresses 0x01c2ac00 pour le bus 0, 0x01c2b000 pour le bus 1 et 0x01c2b400 pour le bus 2.

Les lignes rtc0 = “/soc/i2c@… et target = <&i2c… devront alors être modifiées en conséquence.

Installation du fichier overlay .dtbo

Pour compiler les fichiers overlay, il faut installer les fichiers en-tête du kernel utilisé, cela se fait grâce à la commande :

$ sudo armbian-config

On choisit le menu Software puis Headers pour installer (attention si cela a déjà été effectuée cela désisnstalle les fichiers !). Faire Cancel et Cancel pour sortir.

Pour compiler et installer notre overlay, on utilise la commande :

$ sudo armbian-add-overlay i2c-bq32000.dts

Cela affiche le message suivant :

  Compiling the overlay
  Copying the compiled overlay file to /boot/overlay-user/
  Reboot is required to apply the changes

Un petit ls /boot/overlay-user nous permet de vérifier la précence du fichier .dtbo :

$ ls /boot/overlay-user
i2c-bq32000.dtbo

Vérifications de bon fonctionnement de la RTC

Après reboot, on peut vérifier le chargement du driver dans le journal du kernel :

$ dmesg | grep rtc
[    4.556601] sun6i-rtc 1f00000.rtc: rtc core: registered rtc-sun6i as rtc0
[    4.556613] sun6i-rtc 1f00000.rtc: RTC enabled
[    5.168535] bq32k 0-0068: rtc core: registered bq32k as rtc1

Si on ne trouve pas de trace du driver bk32k, il faudra observer les messages du kernel au démarrage du système sur la liaison série de debug (UART0).

Notre RTC a donc été connectée au fichier /dev/rtc1. Comme on peut le voir ci-dessus, la RTC du SoC a elle aussi été connectée au système par l’intermédiaire du fichier /dev/rtc0. Cette RTC n’ayant pas de tension de backup, il faudra la désactiver à l’étape suivante.

Dans un premier temps vérifions le fonctionnement de notre RTC BQ32000 en afffichant la date/heure système (NTP) et celle de notre RTC :

$ date && sudo hwclock -r -f /dev/rtc1
samedi 17 mars 2018, 16:26:02 (UTC+0100)
2018-03-17 16:24:47.160983+0100

Nous constatons que notre RTC fonctionne, mais qu’elle n’est pas à l’heure ! Pour un affichage simple de l’heure RTC, on effectue la commande

$ sudo hwclock -r -f /dev/rtc1

Pour mettre à l’heure notre RTC à partir de l’heure NTP :

$ sudo hwclock -w -f /dev/rtc1

Vérifions :

$ date && sudo hwclock -r -f /dev/rtc1
samedi 17 mars 2018, 16:30:48 (UTC+0100)
2018-03-17 16:30:47.162255+0100

Désactivation de la RTC du SoC H3

La RTC du SoC H3 doit être désactivée car le kernel va systématiquement la reconfigurer comme RTC par défaut (/dev/rtc) puisque son driver est compilé à l’intérieur du noyau !

Pour désactiver la RTC du SoC H3, il faut créer un fichier overlay…

Nous allons dans un premier temps, “décompiler” la configuration du NanoPi grâce à la commande :

$ sudo dtc -qq -I fs /proc/device-tree > nanopi-neo.dts

Cela créée le fichier source nanopi-neo.dts, une recherche avec Geany, nous permet de voir les partie qui concerne la RTC du SoC :

....
rtc = "/soc/rtc@01f00000";
....
rtc@01f00000 {
  compatible = "allwinner,sun6i-a31-rtc";
  interrupts = <0x0 0x28 0x4 0x0 0x29 0x4>;
  phandle = <0x69>;
  reg = <0x1f00000 0x54>;
  linux,phandle = <0x69>;
};
....

Le fichier source overlay rtc-disable.dts permettant de la désactiver est le suivant :

/dts-v1/;
/plugin/;

/ {
  compatible = "allwinner,sun4i-a10", "allwinner,sun7i-a20", "allwinner,sun8i-h3", "allwinner,sun50i-a64", "allwinner,sun50i-h5";

 fragment@0 {
   target = <&rtc>;

   __overlay__ {
     status = "disabled";
   };
 };
};

Une fois compilé et installé à l’aide de sudo armbian-add-overlay rtc-disable.dts et après redémarrage, on peut constater que cette rtc est effectivement désactivée :

rtc@01f00000 {
  compatible = "allwinner,sun6i-a31-rtc";
  status = "disabled";
  interrupts = <0x0 0x28 0x4 0x0 0x29 0x4>;
  phandle = <0x69>;
  reg = <0x1f00000 0x54>;
  linux,phandle = <0x69>;
};

Un **ls -l /dev/rtc***, nous permet de voir qu’il n’a plus qu’une seule rtc, la rtc0 :

lrwxrwxrwx 1 root root      4 nov.   3  2016 /dev/rtc -> rtc0
crw------- 1 root root 253, 0 nov.   3  2016 /dev/rtc0

Une recherche dans le journal du kernel nous permet de voir que c’est la BQ32000 :

$ dmesg | grep rtc
[    5.182244] bq32k 0-0068: rtc core: registered bq32k as rtc0

Un sudo hwclock -r nous permet de lire les informations de notre RTC :

2018-03-17 21:50:43.386528+0100

Mise à l’heure RTC au boot

Le circuit RTC est maintenant détecté et configuré par le noyau, mais ce n’est pas pour autant qu’il est utilisé par le système !

Nous allons créer un script qui sera lancé automatiquement par le démon de démarrage du système systemd. Cette étape est dérivée de celle présentée sur le site hackable.fr

Tout d’abord on créée un script shell qui utilise hwclock pour mettre à l’heure le système avec l’heure RTC, le fichier rtc-setup est le suivant :

#!/bin/sh
hwclock -s --utc
echo "System Time synced with RTC Time"

Puis on rend ce script exécutable :

$ chmod +x rtc-setup

On peut tester ce script et vérifier que l’heure système et bien la même que l’heure RTC :

$ sudo ./rtc-setup
$ date && sudo hwclock -r
samedi 17 mars 2018, 18:06:36 (UTC+0100)
2018-03-17 18:06:36.829015+0100

On créée ensuite le répertoire /usr/lib/systemd/scripts et on y copie notre script rtc-setup :

$ sudo mkdir -p /usr/lib/systemd/scripts
$ sudo cp rtc-setup /usr/lib/systemd/scripts

On créée ensuite un fichier service systemd pour automatiser le démarrage de rtc-setup au boot, le fichier rtc-init.service est le suivant :

[Unit]
Description=RTC Clock Setup and Time Sync
Before=cron.service

[Service]
Type=oneshot
ExecStart=/usr/lib/systemd/scripts/rtc-setup

[Install]
WantedBy=multi-user.target

On copie ce fichier dans le répertoire /etc/systemd/system :

$ sudo cp rtc-init.service /etc/systemd/system

Il ne reste plus qu’à valider le service rtc-init et à invalider le service fake-hwclock :

$ sudo systemctl enable rtc-init
$ sudo systemctl disable fake-hwclock

fake-hwclock est un service qui palie à l’absence de RTC sur un système embarqué, son rôle est d’écrire régulièrement dans un fichier l’heure système (généralement récupérée par NTP) et la restaurer au démarrage. Cela permet, en cas d’absence de réseau, d’avoir une heure cohérente mais complétement fausse.

Il est maintenant nécessaire de redémarrer et de vérifier que tout fonctionne :

$ sudo reboot
....
$ date && sudo hwclock -r

Retour à la configuration par défaut

Pour revenir à la configuration par défaut, si par exemple, on retire le circuit RTC, il suffit de dévalider le service rtc-init et de valider le service fake-hwclock :

$ sudo systemctl disable rtc-init
$ sudo systemctl enable fake-hwclock

Puis de redémarrer :

$ sudo reboot

Corriger une adresse MAC aléatoire dans Armbian sur NanoPi

Constatation du problème

Lors de chaque démarrage, l’adresse MAC de eth0 est modifiée de façon aléatoire.

Ce problème a été constaté sur des cartes FriendlyArm NanoPi Neo v1.1 et v1.2 avec Armbian utilisant un kernel 4.x. On constate que ce problème n’existe pas quand on utilise une image FriendlyCore (Xenial avec kernel 4.14.0).

Version du noyau utilisé dans ce tuto:

Linux nanopineo 4.14.18-sunxi #2 SMP Sat Feb 10 19:46:30 CET 2018 armv7l GNU/Linux

Solution rapide

Pour ceux qui n’ont pas de temps à perdre avec les explications:

sudo armbian-config

On va dans System puis Freeze. Puis:

git clone http://github.com/epsilonrt/armbian-nanopi-ethaddr-patch
cd armbian-nanopi-ethaddr-patch
cp /boot/boot.cmd .
patch -p1 < boot.cmd.patch
mkimage -C none -A arm -T script -d boot.cmd boot.scr
sudo mv /boot/boot.cmd /boot/boot.cmd.orig
sudo mv /boot/boot.scr /boot/boot.scr.orig
sudo cp boot.* /boot
sudo dtc -I dtb -O dts -o sun8i-h3-nanopi-neo.dts /boot/dtb/sun8i-h3-nanopi-neo.dtb
sudo patch -p1 < sun8i-h3-nanopi-neo.dts.patch
sudo dtc -I dts -O dtb -o sun8i-h3-nanopi-neo.dtb sun8i-h3-nanopi-neo.dts
sudo mv /boot/dtb/sun8i-h3-nanopi-neo.dtb /boot/dtb/sun8i-h3-nanopi-neo.dtb.orig
sudo cp sun8i-h3-nanopi-neo.dtb /boot/dtb
sudo reboot

Analyse du problème

Dans la mainline du kernel 4.x, le driver de la carte Ethernet (dwmac-sun8i), renvoit une adresse MAC aléatoire. Cela est dû, sans doute, à une mauvaise intégration de Device Tree dans ce driver. Sur le site linux-sunxi il est dit :

This driver is mainline, but DT was reverted in 4.13-rc7. DT should be back soon.

Voilà ce qu’indique le kernel au démarrage (dmesg) :

[ 10.889856] dwmac-sun8i 1c30000.ethernet eth0: device MAC address 1a:b2:4a:84:f7:fc
[ 10.890960] Generic PHY 0.1:01: attached PHY driver > [Generic PHY] (mii_bus:phy_addr=0.1:01, irq=POLL)
….
[ 14.009054] dwmac-sun8i 1c30000.ethernet eth0: Link is Up – 100Mbps/Full – flow control off

Le programme de boot du nanopi (u-boot) a une variable ethaddr mais qui pas utilisée par le kernel ! On peut lire cette variable en accédant à la ligne de commande de u-boot. Il faut, pour cela, connecter un adaptateur série-usb sur le connecteur UART0 (debug) du NanoPi. Au boot, il faut appuyer tout de suite sur la touche Espace, puis utiliser printenv:

printenv ethaddr

On doit avoir une adresse commencant par 02:81

Recherche de la solution

Cette solution est issue du reverse engineering du BSP de FriendlyArm.

u-boot utilise le fichier /boot/boot.scr (script de démarrage), ce fichier est une version “compilée” du fichier /boot/boot.cmd.

Dans le fichier /boot/boot.cmd de FriendlyArm, on peut voir les 2 lignes ci-dessous:

# setup MAC address 
fdt set ethernet0 local-mac-address ${mac_node}

La ligne avec fdt a pour but de passer l’adresse MAC (local-mac-address) au kernel par le device tree. Elle fait référence à ethernet0 qui utilisé pour désigner la carte eth0.

Dans le fichier sun8i-h3-nanopi-neo.dts de FriendlyArm, on peut voir que ethernet0 est un alias de /soc/ethernet@1c30000. Dans le bloc de ethernet@1c30000, on peut voir un paramètre local-mac-address:

status = "okay";
local-mac-address = [00 00 00 00 00 00];

Solution trouvée !

Mise en oeuvre détaillée de la solution

Il faut commencer par geler la mise à jour du noyau et de u-boot:

sudo armbian-config

On va dans System puis Freeze. Si on veut vérifier :

dpkg -l | grep ^hi

hi linux-dtb-next-sunxi 5.41 armhf Linux DTB, version 4.14.18-sunxi
hi linux-image-next-sunxi 5.41 armhf Linux kernel, version 4.14.18-sunxi
hi linux-stretch-root-next-nanopineo 5.41 armhf Armbian tweaks for stretch on nanopineo (next branch)
hi linux-u-boot-nanopineo-next 5.41 armhf Uboot loader 2017.11

On clone le dépôt:

git clone http://github.com/epsilonrt/armbian-nanopi-ethaddr-patch
cd armbian-nanopi-ethaddr-patch

Puis on patche le script u-boot:

cp /boot/boot.cmd .
patch -p1 < boot.cmd.patch
mkimage -C none -A arm -T script -d boot.cmd boot.scr
sudo mv /boot/boot.cmd /boot/boot.cmd.orig
sudo mv /boot/boot.scr /boot/boot.scr.orig
sudo cp boot.* /boot

Ensuite, on décompile le device tree, on le patche et on le recompile:

sudo dtc -I dtb -O dts -o sun8i-h3-nanopi-neo.dts /boot/dtb/sun8i-h3-nanopi-neo.dtb
sudo patch -p1 < sun8i-h3-nanopi-neo.dts.patch
sudo dtc -I dts -O dtb -o sun8i-h3-nanopi-neo.dtb sun8i-h3-nanopi-neo.dts
sudo mv /boot/dtb/sun8i-h3-nanopi-neo.dtb /boot/dtb/sun8i-h3-nanopi-neo.dtb.orig
sudo cp sun8i-h3-nanopi-neo.dtb /boot/dtb

Il ne faut pas tenir compte des warning affichés par dtc.

Voilà ! Il ne reste plus qu’à rebooter:

sudo reboot

Il faut juste espérer que les responsables du driver règle ce problème un jour…