Premier pas avec le BeagleBone Green

On parle beaucoup de Raspberry, d’Arduino… mais peu de BeagleBone / BeagleBoard.

Le BeagleBone me serait resté inconnu si un ami ne m’en avait pas parlé au détour d’une conversation.

Dans ce projet, je parle plus du coté ‘tutoriel’ du projet plus que la simple réalisation technique.

J’aborderai la présentation des BeaglesBones, l’installation des outils de programmation,… Afin de ne pas vous submerger d’information et d’y aller calmement, je pense que le mieux est de présenter ce projet en plusieurs parties.

[sommaire]


Présentation de BeagleBone

C’est une plateforme hardware développée autour d’un processeur Arm Cortex A8 de Texas-Instrument. Le design est Open source et provient de la plateforme originale BeagleBoard. Elle se décline en plusieurs séries : Beagle Board Blue, Black, Green…

Les BeaglesBones reposent sur la même solution hardware mais sont issues d’un développement conjoint entre la société non lucrative BeagleBoard et Seed Studio.

Pour le projet, je m’intéresse à la version BeagleBone Green, qui a les mêmes performances que la carte BeagleBoard Black mais qui diffère par des interfaces différentes.

Le BeagleBone Green, c’est un processeur ARM Cortex A8 – 1GHz – AM335x, 512Mo de RAM, un accélérateur graphique 3D, un port USB, un port ethernet, 46 pins I/O (incluant des entrées analogiques) et des connecteurs Grove.

C’est donc un réel ordinateur (même plus comme on le verra ci-dessous) capable de faire tourner différents types de systèmes d’exploitation (Linux, Android, …). En plus du processeur ARM, deux micro-contrôleurs (nommés PRUs) sont directement implantés et ont accès aux ports et à une mémoire partagée avec le processeur.

Il est donc tout à fait possible d’exploiter la carte dans un environnement temps réel très contraint, sans subir les possibles latences inhérentes au système d’exploitation.

Cependant, il faut le dire : l’approche et la mise en main de la carte n’est pas des plus aisées, et encore plus pour un public qui ne fréquente pas la langue de Shakespeare quotidiennement ! (c’est l’une des raisons qui m’a motivé à revoir mon projet et à le décliner plus sous une forme de tutoriel complet).

Il y a beaucoup de documentation, mais celle-ci est fortement dépendante du noyau Linux utilisé et les PRUs sont peu ou mal documentés. Ce qui est dommage, car cela ralenti fortement la prise en main initiale.


Le projet

Pour le projet, j’ai pensé utiliser une partie de la puissance des PRUs pour détecter un signal morse reçu sur un canal audio. Un programme tournant sur le système d’exploitation serait responsable du décodage et de l’affichage du message.

On peut se dire que pour un tel projet, un BeagleBone est sur-dimensionné (ce qui est vrai) et qu’un simple microcontrôleur peut faire l’affaire. Mais l’idée de ce projet n’est pas de pousser le BeagleBone dans ses retranchements, mais de le prendre en main et de se rendre compte de ses possibilités.

N’étant pas un spécialiste du filtrage, des transformées de Fourrier,… j’utiliserai l’algorithme de Goertzel pour détecter la fréquence audio émise lorsque le code morse est généré (par ex : 1200Hz). 

Pour améliorer la détection, on créera également un filtre passe bas. Le tout sera fait de manière numérique. Les seuls composants analogiques sont utilisés pour adapter la tension d’entrée aux entrées analogiques du BeagleBone.

Dans les faits, l’algorithme que j’utilise pourrait être embarqué pour détecter les identifiants des stations de radionavigations utilisées en aéronautique (par exemple), ou décoder des messages émis en CW sur les ondes radios.


Installation

Petit aperçu

La BeagleBone Green se présente dans une petite boite blanche, verte et bleue. A l’intérieur, pas de grand bloc de mousse pour caler la bête… juste la carte, un micro câble USB et un micro notice qui vous permettra de débuter.

La mise en place est assez simple : il suffit de connecter le câble USB à un port USB. Celui-ci assurera l’alimentation de la carte et également un moyen d’accès à la carte.

Accéder aux informations sur la carte

Deux solutions s’offrent à vous :

  • Soit vous passer intégralement par l’USB. Dans ce cas-là, il vous faudra installer des drivers pour que le BB soit reconnu comme un port Ethernet. Après l’installation, vous pourrez y accéder à l’adresse http://192.168.7.2.

Cette solution est assez efficace sous Windows, mais elle à ses limitations tout de même car diverses bibliothèques utilisables pour le BB ne sont disponibles que pour Linux.

  • Soit vous connectez votre BeagleBoard à votre réseau ethernet et vous y accédez via son adresse IP (que vous pourrez connaître en allant sur la page de configuration de votre Box).

J’ai pour ma part retenu cette solution qui me permet de m’interfacer au BeagleBoard sans avoir à installer de drivers et d’utiliser efficacement un compilateur extérieur (cross compilation).

Dans les deux cas, vous pouvez facilement accéder au serveur web du BeagleBoard et à des outils de programmation directement installé sur le BeagleBoard en utilisant le lien http://beaglebone.local dans votre explorateur (excepté Internet Explorer, d’après le site Beagleboard.org).

Cette même adresse permet également de retrouver les informations hardware (http://beaglebone.local/bone101/Support/bone101/#hardware)

Programmation

Pour programmer le BeagleBone, plusieurs solutions s’offre à vous :

  • Soit utiliser les outils accessibles directement depuis le BeagleBone, à savoir :

Node-RED est une interface graphique OpenSource développée par IBM. L’interface permet de concevoir et de déployer rapidement des programmes.

N’ayant pas utilisé cet outil, je vous laisserai le découvrir en allant visiter https://nodered.org pour obtenir plus d’informations.

C’est un IDE embarqué directement sur le BeagleBone. Il permet de programmer sous différents langages (javascript, cpp, python…).

Pour ceux qui ont déjà des bases de programmation, c’est un bon début, car on peut accéder facilement aux exemples disponibles sur le BB.

  • Soit effectuer de la cross-compilation :

D’après Wikipédia, la cross-compilation consiste à compiler une application pour un environnement d’exécution différent de celui où est effectuée la compilation. Ce qui dans notre cas, consiste à compiler un programme destiné au BeagleBone sur notre PC (qui en principe ne propose pas un environnement ARM).

La cross-compilation est intéressante sur divers points :

  • On peut programmer de gros projets en profitant pleinement des IDE existants (Eclipse, …),
  • La compilation s’effectuera plus rapidement (malgré la puissance du ARM Cortex dispo sur la carte on perçoit la différence),
  • On peut développer sans avoir besoin de la carte (on peut débugger du code sur son PC en le compilant de façon standard, puis le cross compiler pour l’exécuter sur le BB ultérieurement).

Cependant, il y a quelques inconvénients :

  • Il faut rapatrier le code sur le BB,
  • il faut gérer les diverses bibliothèques (notamment celles associées au GPIO),
  • elle ne peut se réaliser que sous Linux (de ce que j’ai compris).

Etant donné que je souhaite réaliser ultérieurement un ‘gros’ projet, je me suis orienté vers la solution de cross-compilation.


Mise en place d’un environnement de cross-compilation.

La première étape consiste à installer Eclipse C/C++ depuis https://eclipse.org/ide/

Une fois l’installation réalisée, on va se connecter au travers de l’IDE à notre BeagleBone en utilisant SSH (j’utilise une connexion au travers du réseau, votre BeagleBone devra donc être connecté et alimenté).

Connexion SSH au BB sous Eclipse

Ouvrez dans Eclipse une nouvelle perspective ‘Remote System Explorer’ (accessible depuis le menu Window/Perspective/Open Perspective/others).

Note : le plugin Remote System Explorer est installé par défaut, si ce n’est pas le cas, il faut l’ajouter au travers des addons Eclipse

Un nouvel onglet ‘Remote System Details ‘apparaitra dans une des fenêtre secondaires d’Eclipse. Dans celui-ci, effectuez un clic-droit, pour sélectionner ‘New / Connection’. Dans la fenêtre qui apparaît, on sélectionne les infos de connexion, notamment dans le champ Host Name on indique l’adresse IP du BeagleBone.

Appuyez sur Suivant, puis dans la fenêtre suivante sélectionner la configuration SSH.files (pour ma part, je n’ai pas le choix) :

Cliquez enfin sur Finish : vous devez désormais voir la nouvelle connexion dans l’onglet ‘Remote System’. En faisant un clic-droit sur cette nouvelle connexion, vous pouvez vous connecter en sélectionnant ‘Connect’ .

Dans la fenêtre qui s’ouvre saississez l’user ID.
Par défaut, lors de la première utilisation l’unique user ID accessible est ‘root’ et il n’est pas nécessaire de donner de mot de passe.
→ C’est une brèche de sécurité importante. Je vous conseille vivement de vous créer un compte spécifique et de mettre un mot de passe pour le compte Root de votre BeagleBone.

Une fois connecté, vous pourrez naviguer sans encombre dans l’architecture de fichiers du BeagleBone depuis l’onglet ‘Remote System’ d’Eclipse. Voilà pour la connexion vers le BeagleBone.

Il nous reste maintenant à ajouter le compilateur ARM

Installation du compilateur ARM

Mon choix s’est porté sur le compilateur Linaro (d’autres compilateurs existent). Installez-le où vous voulez sur votre PC ( mais gardez en tête qu’il doit être facilement accessible car nous allons l’ajouter dans Eclipse). Nous allons ensuite configurer Eclipse pour qu’il connaisse l’existence de ce nouveau compilateur.

Nous allons créer un nouveau projet C/C++ dans Eclipse et créer un projet ‘Hello World’. En principe deux compilateurs (toolchains) devraient être disponibles.

Choisissez « Cross GCC »

Faire next et finish directement (cela nous permettra de compiler pour du Debug ou pour de la Release).

Ensuite dans l’onglet Project Explorer (s’il n’est pas visible faire Menu Window / Show View / Project Explorer)

Cliquez droit sur le projet, puis allez dans les propriétés afin de se rendre dans le menu C/C++ Build / Settings

Dans le champ « Prefix », indiquez alors « arm-linux-gnueabihf- » et dans le champ Path, le chemin vers la racine du compilateur Linaro.

L’utilisation du champ « Prefix » permet d’éviter la redéfinition des compilateurs Gcc, G++,.. Ceux-ci gardant leur commande gcc, g++… Lors de la compilation Eclipse ajoutera directement le préfix, ce qui permettra l’exécution du bon compilateur.

Maintenant, il nous reste à faire un Projet / Build All ou Ctrl + B pour construire notre Hello World.

Nous devons maintenant avoir dans l’arbre de notre projet une branche Binaries qui contient notre projet construit se terminant par [arm/le].

N’essayez pas de l’exécuter tel quel sur votre PC, cela ne fonctionnera pas… (il n’a pas été construit pour)

Sélectionnez ce fichier binaire, puis faire clique droit puis copier. Aller ensuite dans l’onglet ‘Remote Systems’, et le copier où vous le souhaitez dans l’arbre de fichiers du BeagleBone.

Pour ma part, je l’ai collé directement dans ‘My Home’, ce qui permet de le retrouver facilement et de l’exécuter facilement par SSH également.

Pour exécuter le programme, ouvrez un Shell dans Eclipse en cliquant du droit sur « Ssh Shells » (dans l’onglet Remote System), puis « New Shell ».

Un nouvel onglet ‘Remote Shell’ s’ouvrira.

Etant donné que le shell s’ouvrira directement dans notre Home, il n’est pas nécessaire de naviguer dans un autre répertoire.

Pour executer le fichier, il suffit de taper dans la ligne command : « ./+nomfichier ».

Dans mon cas, vu que j’ai nommé mon fichier crossGcc, l’execution de la commande ./crossGcc m’affiche un magnifique Hello World.

Voilà pour l’installation et la vérification de la CrossCompilation.


Conclusion

Comme vous pouvez le voir, les premières étapes peuvent être un peu délicates lorsque l’on n’est pas habitué à travailler sur une telle plateforme. Cela demande des connaissances en cross-compilation et de bien connaitre son IDE également.

Tout du moins, les étapes décrites ci-dessus permettent de mettre en œuvre un environnement de programmation efficace.

Si vous estimez que l’installation d’Eclipse, la cross-compilation, … est rebutante ou trop délicate, n’oubliez pas que les outils NodeRed et Cloud9 sont disponibles sur le BeagleBone.

Pour la suite, nous verrons :

  • La configuration des ports GPIO (General Purpose IO),
  • L’utilisation du PRU
  • Et enfin, la mise en place du code du projet.

Sources complémentaires

Plus d’informations sur le site officiel de BeagleBoard.