04 – GTRC – Préparer l’environnement de développement Arduino

L’article précédent était consacré à la fabrication et au câblage de la télécommande GTRC.

L’étape suivante consiste à préparer l’environnement logiciel nécessaire à sa programmation, ainsi qu’à celle des futurs récepteurs installés dans les locomotives.

Si Arduino IDE est déjà installé et familier, les premières parties de cet article pourront être parcourues rapidement. Pour une première expérience avec Arduino, quelques étapes supplémentaires peuvent en revanche être nécessaires, en particulier avec certaines cartes compatibles.

Aucune connaissance particulière en programmation n’est nécessaire pour installer et utiliser GTRC.

Cet article présente également quelques principes généraux sur l’organisation du logiciel. Ils permettent de comprendre pourquoi GTRC est composé de plusieurs fichiers, contrairement aux petits programmes Arduino souvent rencontrés dans les tutoriels.

Arduino IDE

La programmation des cartes utilisées par GTRC s’effectue avec Arduino IDE.

IDE signifie Integrated Development Environment, ou environnement de développement intégré.

Ce logiciel permet notamment :

d’ouvrir le programme ;
de modifier sa configuration ;
de vérifier et compiler le programme ;
de le transférer dans l’Arduino ;
et, si nécessaire, d’afficher les informations envoyées par celui-ci sur le port série.

Arduino IDE est gratuit et disponible pour Windows, macOS et Linux.

Il n’est pas nécessaire de reproduire ici un tutoriel complet sur son installation, la documentation officielle Arduino détaillant déjà très bien la procédure.

Arduino – Télécharger et installer Arduino IDE
https://support.arduino.cc/hc/en-us/articles/360019833020-Download-and-install-Arduino-IDE

GTRC est développé avec Arduino IDE 2.

Une fois l’installation terminée, un premier lancement permet simplement de vérifier que l’environnement fonctionne correctement.

Cartes Arduino officielles et cartes compatibles

L’utilisation de cartes Arduino officielles n’est absolument pas obligatoire pour construire GTRC.

Le projet utilise des microcontrôleurs très courants et fonctionne parfaitement avec de nombreuses cartes compatibles disponibles pour quelques euros.

Dans sa version actuelle, GTRC utilise principalement :

Fonction	Carte
Télécommande	Arduino UNO / compatible UNO
Récepteur locomotive	Arduino Nano / compatible Nano / RF-Nano

Une carte compatible peut utiliser exactement le même microcontrôleur qu’une carte Arduino officielle tout en employant des composants légèrement différents autour de celui-ci.

Pour le programme GTRC, cela ne change généralement rien.

Il existe cependant un petit piège : la liaison USB avec l’ordinateur.

Le convertisseur USB/série

Sur une carte UNO ou Nano classique, le microcontrôleur ATmega328P n’est pas directement connecté au port USB de l’ordinateur.

Un autre composant assure la conversion entre l’USB et la liaison série utilisée pour programmer le microcontrôleur.

Selon les fabricants et les cartes, plusieurs circuits peuvent notamment être rencontrés :

ATmega16U2 ;
FT232 / FTDI ;
CH340 / CH341 ;
CP2102 / CP210x.

Les cartes compatibles Arduino à bas prix utilisent très souvent un CH340. Cela n’a aucune incidence sur le fonctionnement de GTRC une fois le programme installé.

En revanche, l’ordinateur doit disposer du pilote approprié pour reconnaître cette interface USB.

Ma carte n’apparaît pas dans Arduino IDE

Après avoir connecté l’Arduino avec un câble USB, un nouveau port doit normalement apparaître dans Arduino IDE.

Il est possible de le vérifier dans :

Outils → Port

Sous Windows, le Gestionnaire de périphériques permet également de vérifier sa présence dans la rubrique :

Ports (COM et LPT)

Avec une carte équipée d’un CH340, une ligne de ce type peut par exemple apparaître :

USB-SERIAL CH340 (COM5)

Le numéro COM dépend évidemment de l’ordinateur utilisé.

Si aucun nouveau port n’apparaît lors du branchement de la carte, cela ne signifie pas nécessairement que l’Arduino est défectueux.

Quelques vérifications simples sont à effectuer en premier :

vérifier que le câble USB permet bien le transfert de données et n’est pas uniquement un câble de charge ;
vérifier que la carte est correctement alimentée ;
essayer un autre port USB ;
vérifier que le pilote correspondant au convertisseur USB/série de la carte est installé.

Arduino propose une page de dépannage pour les problèmes de téléversement :

Arduino – Que faire si le programme ne se téléverse pas ?
https://support.arduino.cc/hc/en-us/articles/4403365313810-If-your-sketch-doesn-t-upload

Le cas très courant du CH340 / CH341

De nombreuses UNO et Nano compatibles sont équipées d’un circuit CH340 ou CH341. Ces composants sont extrêmement courants sur les cartes économiques. Si Windows ne reconnaît pas correctement la carte, l’installation du pilote fourni par le fabricant WCH peut être nécessaire.

Le pilote officiel est disponible ici :

WCH – Pilote CH340 / CH341 pour Windows
https://www.wch-ic.com/downloads/CH341SER_ZIP.html

WCH fournit également des pilotes pour Linux et macOS.

Après installation du pilote et reconnexion de la carte, un nouveau port COM devrait apparaître.

Un problème particulier sous Windows

Un problème assez déroutant peut également se produire avec certains CH340 et certaines versions récentes du pilote Windows.

La carte est correctement détectée, le port COM existe, la compilation fonctionne… mais le téléversement échoue avec un message ressemblant à :

avrdude: ser_open(): can't set com-state for COMx

Ce problème est suffisamment connu pour qu’Arduino lui consacre une page spécifique. Pour les CH340 concernés, Arduino recommande l’utilisation de la version 3.7.2022.01 du pilote.

La procédure complète est disponible ici :

Arduino – Erreur « can’t set com-state for COMn »
https://support.arduino.cc/hc/en-us/articles/13148652511260-avrdude-ser-open-can-t-set-com-state-for-COMn

Ce type de panne peut faire perdre beaucoup de temps : tout semble correctement configuré et pourtant aucun programme ne peut être transféré dans la carte.

Le deuxième piège : l’Arduino Nano et son bootloader

Les Arduino Nano compatibles présentent une autre petite subtilité.

Il est possible de se retrouver avec :

une carte parfaitement reconnue par Windows ;
le bon port COM ;
le bon modèle de carte sélectionné ;
un programme qui compile sans erreur ;

…et malgré tout être incapable de téléverser le programme.

Dans ce cas, le problème peut provenir du bootloader.

Le bootloader est un petit programme déjà présent dans le microcontrôleur qui permet notamment à Arduino IDE d’y transférer le programme principal.

Plusieurs versions ont été utilisées sur les Arduino Nano.

Dans Arduino IDE, après avoir sélectionné :

Outils → Type de carte → Arduino Nano

un autre choix est disponible dans :

Outils → Processeur

avec notamment :

ATmega328P
ATmega328P (Old Bootloader)

Les Nano récentes utilisent normalement ATmega328P.

Certaines Nano plus anciennes, ainsi qu’un certain nombre de cartes compatibles, nécessitent cependant :

ATmega328P (Old Bootloader)

C’est d’ailleurs le cas de certaines cartes utilisées lors du développement de GTRC.

Lorsqu’une Nano est correctement détectée mais refuse obstinément le téléversement, sélectionner Old Bootloader est donc l’une des premières choses à essayer avant de rechercher une panne plus complexe.

Arduino documente précisément cette différence ici :

Arduino – Sélectionner le bon processeur pour une Arduino Nano
https://support.arduino.cc/hc/en-us/articles/4401874304274-Select-the-right-processor-for-Arduino-Nano

Installer les bibliothèques nécessaires à GTRC

Un programme Arduino peut utiliser des bibliothèques : ce sont des ensembles de fonctions déjà écrites permettant de gérer facilement un matériel ou une fonctionnalité particulière. Il serait par exemple inutile de réécrire entièrement le programme nécessaire pour piloter l’écran OLED ou communiquer avec les modules radio NRF24L01.

GTRC utilise principalement trois bibliothèques :

Bibliothèque	Utilisation dans GTRC
U8g2	Gestion de l’écran OLED SH1106 128 × 64 de la télécommande
NRFLite	Communication radio avec les modules NRF24L01
SPI	Communication SPI avec le NRF24L01

La bibliothèque SPI fait déjà partie de l’environnement Arduino et ne nécessite aucune installation supplémentaire.

U8g2 et NRFLite doivent en revanche être installées.

Arduino IDE possède pour cela un gestionnaire de bibliothèques intégré, accessible depuis :

Outils → Gérer les bibliothèques…

Il est également accessible depuis l’icône du gestionnaire de bibliothèques située dans la barre latérale.

Une recherche sur :

U8g2

permet d’installer la bibliothèque correspondante.

La même opération est ensuite à effectuer avec :

NRFLite

La documentation officielle Arduino explique les différentes méthodes d’installation d’une bibliothèque :

Arduino – Installer des bibliothèques dans Arduino IDE
https://support.arduino.cc/hc/en-us/articles/5145457742236-Install-libraries-in-the-Arduino-IDE

Les projets des deux bibliothèques sont également disponibles directement sur leurs dépôts respectifs :

U8g2 – dépôt officiel
https://github.com/olikraus/u8g2

NRFLite – dépôt officiel
https://github.com/dparson55/NRFLite

Une bibliothèque téléchargée sous forme de fichier ZIP peut également être installée manuellement depuis :

Croquis → Inclure une bibliothèque → Ajouter la bibliothèque .ZIP

Cette méthode est notamment utile lorsqu’une version précise d’une bibliothèque doit être utilisée.

Une fois U8g2 et NRFLite installées, toutes les bibliothèques nécessaires à la télécommande GTRC sont disponibles.

Pourquoi GTRC contient-il autant de fichiers ?

L’environnement de développement est maintenant pratiquement prêt.

Avant de s’intéresser au programme GTRC proprement dit, une notion importante mérite cependant quelques explications.

De nombreux exemples Arduino disponibles sur Internet sont constitués d’un unique fichier :

.ino

Cette organisation convient parfaitement à un petit programme de quelques dizaines ou quelques centaines de lignes.

Un projet comme GTRC doit cependant gérer beaucoup plus de choses :

des boutons et des potentiomètres ;
un écran ;
une communication radio ;
plusieurs locomotives ;
des sécurités ;
différents modes de fonctionnement ;
des temporisations ;
etc.

Placer l’ensemble dans un unique fichier deviendrait rapidement difficile à lire et surtout à maintenir.

Le programme GTRC est donc découpé en plusieurs fichiers spécialisés. C’est le principe de la programmation modulaire.

L’idée est assez simple : chaque partie du programme possède une tâche précise.

Une partie peut par exemple être chargée de la communication radio tandis qu’une autre s’occupe de l’affichage.

Toutes appartiennent au même programme, mais le code est organisé par fonctions plutôt que regroupé dans un unique fichier de plusieurs milliers de lignes.

Les fichiers .ino, .h et .cpp

GTRC utilise principalement trois types de fichiers.

Le fichier .ino

Le fichier :.ino est le fichier principal d’un programme Arduino, également appelé sketch.

Il contient notamment les deux fonctions fondamentales d’un programme Arduino :

setup()

et :

loop()

setup() est exécutée une seule fois lorsque l’Arduino démarre.

loop() est ensuite exécutée continuellement tant que l’Arduino fonctionne.

Dans un programme composé de plusieurs modules, le fichier .ino joue en quelque sorte le rôle de chef d’orchestre.

Les fichiers .h

Les fichiers : .h sont appelés fichiers d’en-tête ou headers.

Sans entrer dans les détails du langage C++, ils servent notamment à définir ce qu’une partie du programme met à disposition des autres.

Une image volontairement simplifiée permet d’en retenir le principe :

le fichier .h indique ce qu’un module sait faire.

Les fichiers .cpp

Les fichiers : .cpp contiennent généralement le code qui réalise effectivement ces opérations.

Toujours de manière très simplifiée :

le fichier .cpp explique comment le module le fait.

C’est pour cette raison que de nombreux fichiers fonctionnent par paire :

NomDuModule.h

et :

NomDuModule.cpp

Les deux appartiennent au même module.

Comment tous ces fichiers communiquent-ils ?

Chaque fichier ne constitue pas un petit programme indépendant.

Tous ces fichiers constituent ensemble un seul programme.

Le fichier principal peut appeler une fonction située dans un autre module. Ce module peut à son tour utiliser des informations ou des fonctions définies ailleurs.

Le principe peut être représenté de manière très simplifiée :

                    PROGRAMME PRINCIPAL
                          (.ino)
                            │
          ┌─────────────────┼─────────────────┐
          │                 │                 │
          ▼                 ▼                 ▼
       Module A          Module B          Module C
       .h / .cpp         .h / .cpp         .h / .cpp
          │                 │                 │
          └─────────────────┼─────────────────┘
                            │
                      Configuration

Le programme principal coordonne ainsi différents modules spécialisés.

Ce découpage peut paraître plus compliqué lors de la première ouverture du projet, simplement à cause du nombre de fichiers présents.

Mais dès que le programme prend de l’ampleur, c’est exactement l’inverse : cette organisation permet de retrouver beaucoup plus facilement la partie du code correspondant à une fonction donnée.

Séparer le programme de sa configuration

La séparation entre le fonctionnement interne du programme et la configuration propre à chaque installation constitue un principe important de GTRC.

L’utilisation du système ne nécessite normalement pas de comprendre comment sont programmées toutes les fonctions internes de la télécommande ou des récepteurs.

L’adaptation à un réseau particulier repose essentiellement sur quelques paramètres clairement identifiés.

Ils permettent par exemple de définir :

les locomotives disponibles ;
leurs noms ;
leurs identifiants ;
certains paramètres matériels ;
certaines temporisations ou options.

L’objectif est de permettre l’utilisation et la personnalisation de GTRC sans avoir à devenir programmeur C++.

Le code source reste évidemment entièrement accessible à ceux qui souhaitent comprendre son fonctionnement ou aller plus loin dans sa modification.

Faut-il apprendre le C++ pour utiliser GTRC ?

Non.

GTRC est programmé en C++, comme la plupart des projets Arduino, mais la maîtrise de ce langage n’est pas nécessaire pour utiliser le système.

Dans la pratique, l’installation d’un programme GTRC consiste essentiellement à :

télécharger le projet ;
l’ouvrir dans Arduino IDE ;
modifier quelques paramètres clairement identifiés ;
sélectionner le modèle de carte Arduino ;
sélectionner le bon port USB ;
compiler le programme ;
le téléverser dans la carte.

Savoir modifier quelques valeurs dans un fichier texte et suivre les différentes étapes de configuration suffit donc pour commencer à utiliser GTRC.

Le code source reste disponible pour ceux qui souhaitent ensuite découvrir plus en détail le fonctionnement interne du système.

L’environnement de développement est prêt

À ce stade, l’ordinateur utilisé pour programmer GTRC doit disposer de :

Arduino IDE 2 ;
la prise en charge des Arduino UNO et Nano ;
la bibliothèque U8g2 ;
la bibliothèque NRFLite ;
éventuellement le pilote CH340/CH341 si la carte utilisée en a besoin.

Lorsqu’une carte Arduino est connectée, son port série doit également apparaître dans Arduino IDE.

Et si une Nano compatible refuse obstinément le téléversement alors que tout semble correctement configuré, le choix :

ATmega328P (Old Bootloader)

fait désormais partie des premières vérifications à effectuer.

Ces quelques précautions peuvent éviter de longues heures de recherche, en particulier lors des premiers essais avec des cartes Arduino compatibles.

Dans le prochain article

L’environnement nécessaire à la programmation de GTRC est désormais installé.

Le prochain article sera consacré au logiciel de la télécommande GTRC.

Ce sera l’occasion de découvrir son organisation réelle, le rôle des différents fichiers et surtout d’identifier ceux qui permettent d’adapter la télécommande à un réseau particulier.

La configuration des locomotives, de leurs identifiants et des noms affichés sur l’écran sera également détaillée.

La dernière étape consistera à compiler cette configuration puis à la téléverser dans l’Arduino UNO.

La partie logicielle de la télécommande GTRC sera alors terminée, avant de passer à la fabrication et à la programmation des récepteurs installés dans les locomotives.