rcnavy

RC Navy (2012-2023)

I. Présentation (très) rapide des ARDUINO

Les cartes arduino sont des cartes de prototypage rapide utilisant des micro-contrôleurs AVR de chez ATMEL.

Ces cartes disposent de connecteurs "femelles" dans lesquels on peut "planter" des fils reliés à des capteurs (interrupteurs, potentiomètres, etc...) ou des actionneurs (LED, servo, etc...).

Il y a plusieurs modèles, entre autres:

arduino UNO: idéale pour le débutant

arduino MEGA: pour des projets un peu plus ambitieux

arduino Digispark: pour des projets compacts avec développement "à la arduino" (téléversement du sketch directement en USB depuis l'IDE)

I.1. Programmation ARDUINO

Ces cartes se programment en un langage également appelé arduino, qui est très proche du langage C et C++, mais propose des bibliothèques (des collections de fonctions "toutes faites") pour faciliter la vie de l'utilisateur. Le programme arduino est développé sur PC dans l'Environnement de Développement Intégré (EDI ou IDE) arduino et est chargé par un lien USB. Il faut donc un câble USB entre la carte UNO et MEGA et un port USB du PC sauf pour l'arduino Digispark qui se branche directement sur le port USB. Dans le jargon arduino, un programme s'appelle un "sketch".

Les bibliothèques sont appelées "libraries" en anglais. Très souvent, on utilise en français le terme "librairie", ou "lib", ce qui est incorrect, mais qui se comprend facilement.

Dans ces pages, je m'efforcerai d'employer le bon terme en français, à savoir: "bibliothèque".

L'Environnement de Développement Intégré arduino sur le PC:

L'Environnement de Développement Intégré "arduino" (EDI ou IDE)

Tous les sketches arduino ont la même structure:

Inclusion éventuelle de bibliothèque par un "#include <nom_de la_bibliothèque>",
Déclaration éventuelle de macro par un "#define NOM_MACRO",
Déclaration éventuelle de variables,
La fonction void setup(): c'est dans cette fonction que sont faites toutes les initialisations. Cette fonction est appelée automatiquement une seule fois.
La fonction void loop(): c'est la boucle principale du programme (boucle infinie), c'est là que sont faits tous les traitements. Cette fonction est appelée automatiquement et en permanence.

I.2. Miniaturisation ARDUINO

Ces cartes arduino sont très pratiques pour développer un prototype, mais elles restent encombrantes pour des applications en modélisme où la place est comptée.

Il existe cependant une solution: l'environnement de développement arduino permet de développer des programmes (sketches) pouvant être directement chargés dans des micro-contrôleurs plus petits:

l'ATtiny84 (14 broches) et son brochage "arduino"

l'ATtiny85 (8 broches) et son brochage "arduino"

Les ATtiny84 et ATtiny85 ne sont pas des arduino, au sens où il ne s'agit pas de carte de prototypage: il s'agit de puces "nues". Par abus de langage, on les appelle arduino, puisque ces puces peuvent être programmées en langage arduino avec les mêmes outils de développements installés sur le PC.

En effet, les programmes peuvent être mis au point en premier lieu sur une carte arduino UNO, puis sont recompilés pour l'ATtiny84 ou ATtiny85 avant d'être chargés dans la puce ATtiny84 et ATtiny85.

Cerise sur le gâteau, il n'y a pas besoin de programmateur spécifique pour charger le programme arduino dans l'ATtiny84 ou ATtiny85: c'est la carte arduino (UNO) qui sert de programmateur.

Limitations des ATtiny84 et ATtiny85:

1) La fréquence d'horloge des ATtiny84 et ATtiny85 est 2 fois plus faible que celle de l'UNO (8MHz contre 16MHz): ils exécutent donc 2 fois moins d'instructions dans le même intervalle de temps que l'UNO, mais restent cependant très performants. La fréquence d'horloge interne à 8MHz des ATtiny84 et ATtiny85 n'est pas très précise, ce qui peut poser des problèmes dans certains cas d'utilisations, mais l'auteur détaillera bientôt dans ces pages une solution efficace. Il est possible de faire tourner l'ATtiny85 à 16MHz en utilisant la PLL interne.

2) Contrairement à l'arduino UNO, l'ATtiny85 ne dispose pas d'un Timer 16 bits. Un Timer 16 bits est très utile pour lire et générer des impulsions RC. Un Timer 16 bits peut compter de 0 à 65535.
Pour l' ATtiny85, c'est un Timer 8 bits qui est utilisé pour mesurer les impulsions RC entrantes et sortantes. Un Timer 8 bits peut compter de 0 à 255. Ceci implique une perte de résolution et entraine davantage de contraintes "temps-réel" que pour les arduino UNO. Cependant, comme le démontrent les exemples en bas de page, avec un peu d'astuce, il est possible d'obtenir facilement de très bons résultats en terme de qualité de mesure d'impulsion et de génération d'impulsion.

3) Contrairement à l'arduino UNO, les ATtiny84 et ATtiny85 ne disposent pas d'un port série natif (UART) permettant de dialoguer avec un PC ou un GPS, par exemple. Il n'est donc pas possible de dialoguer directement avec la Serial Console de l'EDI arduino. (C'est possible indirectement en utilisant la bibliothèque <SoftSerial>: voir ci-dessous l'exemple 7).

4) La broche Reset (la broche physique 4 de l'ATtiny84 et la broche physique 1 de l'ATtiny85) ne peut pas être utilisée comme broche d'Entrée/Sortie pour le sketch arduino: ce n'est pas supporté en environnement arduino. En conséquence, seules 11 broches d'Entrées/Sorties sont supportées pour l'ATtiny84 et 5 broches d'Entrées/Sorties sont supportées pour l'ATtiny85.
Note: sur le Digispark, basé sur un ATtiny85, la broche Reset est utilisable en tant qu'I/O (ce qui porte le nombre d'I/O utilisables à 6) puisque celui-ci se programme via un bootloader (pas en ISP).

5) La taille maximum du programme arduino (le sketch) est limité à 8Ko pour l'ATtiny84 et l'ATtiny85 (contre environ 31Ko pour l'UNO).
Pour un Digispark, la taille maximale du sketch est de 6Ko, puisque le bootloader occupe environ 2Ko.

Malgré ces petites limitations, les ATtiny84 et ATtiny85 restent d'excellents micro-contrôleurs, très performants et permettent de réaliser facilement en environnement arduino des petites merveilles, fiables et très compactes.

I.3. Mise en oeuvre rapide des ARDUINO

Pour l'installation de tout le nécessaire pour créer des projets arduino avec des ATtiny84 et ATtiny85 et charger le programme, voir cet excellent lien (normal, j'y ai contribué :-) ), sur le site d'Alain CLAVERIE.

Note à l'attention des utilisateurs d'arduino sous Window$:

La version de compilateur avr-gcc livrée avec le pack d'installation 1.0.1 pour Window$ du site officiel arduino est trop ancienne pour travailler correctement avec les ATtiny84 et ATtiny85.

Il est donc fortement recommandé d'utiliser le pack d'installation arduino pour Window$ proposé sur le site d'Alain: il inclut directement une version récente du compilateur avr-gcc.

Pour les utilisateurs d'arduino sous Linux, ils peuvent conserver la version du pack d'installation 1.0.1 proposé sur le site officiel.

II. Programmation avancée des ARDUINO

II.1. Le problème à résoudre: ça bloque?

Sur le présent site, l'auteur ne va pas se focaliser sur la mise en oeuvre des arduino UNO, ATtiny84 et ATtiny85 (c'est très bien fait sur le site d'Alain), mais plutôt sur les aspects "programmation" et "organisation logicielle".

En effet, bien qu'abordable pour le débutant, la programmation arduino souffre d'un mal qui n'est pas assez mis en évidence sur les différents forums arduino: la plupart des fonctions et bibliothèques arduino sont synchrones, c'est-à-dire "bloquantes". Par exemple, pendant un delay(5000), l'arduino est incapable de lire une impulsion RC venant d'un récepteur à l'aide de la fonction pulseIn().

La conséquence est que bon nombre d'utilisateurs d'arduino se posent la question: mais comment faire en sorte que l'arduino fasse plusieurs choses "en même temps"?

Sur ce site, l'auteur va présenter des solutions pour qu'un arduino puisse faire beaucoup de choses "en même temps". Evidemment, compte-tenu du thème du site RC Navy, les applications seront orientées "modélisme radio-commandé".

II.2. Une solution: la programmation asynchrone

La programmation asynchrone consiste "simplement" à ne pas attendre qu'un critère soit atteint avant d'exécuter la suite d'un programme arduino.

Sans rentrer dans le détail, cela consiste simplement à tester dans la boucle principale du programme un indicateur qui signale si le critère est atteint ou pas et de faire ou ne pas faire d'action en fonction de l'état de l'indicateur.

Afin d'aider l'utilisateur, l'auteur a développé pour arduino UNO, ATiny84, ATtiny85 et ATtiny167 toute une collection de bibliothèques asynchrones dédiées au modélisme capables de lire des impulsions issues de récepteur RC et capables de générer des impulsions pour piloter des servos ou des variateurs électroniques:

Bibliothèque <TinyPinChange>:	détection des changements d'état des broches de l'arduino en interruption,
Bibliothèque <SoftRcPulseIn>:	lecture d'impulsion RC,
Bibliothèque <SoftRcPulseOut>:	génération d'impulsion RC,
Bibliothèque <RcSeq>:	lecture d'impulsion RC et lancement de séquences prédéfinies de servos et/ou d'actions courtes,
Bibliothèque <SoftSerial>:	port série logiciel compatible de <TinyPinChange> pour ATtiny84, ATtiny85, ATtiny167, UNO et MEGA.
Bibliothèque <RcTxSerial>:	partie émission pour port série unidirectionnel à 200 bauds entre émetteur et récepteur RC.
Bibliothèque <RcRxSerial>:	partie réception pour port série unidirectionnel à 200 bauds entre émetteur et récepteur RC.
Bibliothèque <TinyCppmGen>:	génération en interruption d'un train PPM exactement identique à celui disponible sur la prise "écolage" d'un émetteur RC.
Bibliothèque <TinyCppmReader>:	lecture en interruption d'un train PPM, extraction du nombre de voies transportées et de leur largeur d'impulsion.
Bibliothèque <TinySoftPwm>	permet d'utiliser n'importe quelle broche d'un ATtiny85 pour faire du PWM de manière logicielle.
Bibliothèque <TinyOscCal>	permet de calibrer l'oscillateur interne des ATtiny84 et ATtiny85 pour une utilisation fiable des ports séries logiciels <SoftSerial>.

Organisation des librairies asynchrones

Comme il s'agit de bibliothèques, la complexité de la programmation est "cachée" dans les bibliothèques, (les boîtes jaunes-pailles dans la figure ci-dessus). L'utilisateur n'a plus qu'à inclure dans son sketch les bibliothèques, (par un #include <nom_de la_bibliothèque.h>) et à utiliser des fonctions prédéfinies et simples pour son application.

Ces fonctions prédéfinies constituent ce que l'on appelle l'Application Programming Interface (API) ou Interface de Programmation d'Application (IPA): il s'agit de la partie visible de la bibliothèque, on appelle cela aussi les fonctions publiques de la bibliothèque. Ce sont les seules dont l'utilisateur doit avoir connaissance.

Toutes ces bibliothèques ont été testées pour l'arduino UNO par l'auteur et pour les arduino ATtiny84 et ATtiny85 par Alain et sont disponibles, avec aides et exemples commentés, sur la page: la collection de bibliothèques asynchrones.

II.3. Exemples de programmes asynchrones

III. OpenDaqCalc

III.1. Présentation
L'utilitaire PLX-DAQ de la société PARALLAX permet de faire l'acquisition en temps réel d'échantillons de mesure directement dans une feuille Excel via un port série. Bien que PLX-DAQ ait été créé pour les micro-contrôleurs PARALLAX, il fonctionne évidemment pour tous les micro-contrôleurs disposant d'un port série, donc avec les arduinos.
Malheureusement, PLX-DAQ ne fonctionne que sous Windows et avec une version payante d'Excel.
C'est pourquoi votre serviteur a créé OpenDaqCalc: un clone open source de PLX-DAQ utilisant LibreOffice/Calc.
La grande différence est que OpenDaqCalc fonctionne sous Windows et sous Linux à l'aide du tableur gratuit LibreOffice/Calc: pas besoin d'une version payante d'Excel.
Cerise sur le gâteau, il n'y a qu'un seul et unique package OpenDaqCalc contenant tout le nécessaire pour fonctionner sous Linux et sous Windows.
OpenDaqCalc permet, tout comme PLX-DAQ, de faire l'acquisition en temps réel d'échantillons de mesure de capteur directement dans une feuille de tableur.
Il est donc possible de tracer en temps réel des courbes de mesure.
OpenDaqCalc V2.0 a été testé sous Linux Ubuntu 20.04 LTS avec LibreOffice 6.4.7.2 et n'a pas été retesté sous Windows avec LibreOffice Calc.
OpenDaqCalc devrait également fonctionner sous OpenOffice/Calc (non testé).

La suite gratuite LibreOffice est complète et contient:

    - Calc (Tableur, équivalent de Excel),
    - Writer (Traitement de texte, équivalent de Word),
    - Impress (Outil pour faire des présentations, équivalent de PowerPoint)
    - Draw (Outil pour dessiner).
Si ce n'est déjà fait, télécharger et installer la dernière version stable de LibreOffice : Télécharger LibreOffice

III.2. Capture avec OpenDaqCalc sous LibreOffice Calc

La capture ci-dessous a été réalisée sous Linux Ubuntu. Il est évidemment possible de la réaliser sous Windows toujours avec LibreOffice Calc.

Les mesures sont collectées à la volée et la courbe se crée en temps réel.

Depuis la version OpenDaqCalc V2.0, le nombre d'échantillon par seconde est affiché lors de l'acquisition des données.

Pour réaliser cette capture, le sketch chargé dans un arduino UNO était le suivant:

int x = 0;
int row = 0;

void setup()
{
Serial.begin(115200); // opens serial port, sets data rate to 115200 bps
Serial.println("CLEARDATA");
Serial.println("LABEL,Time,x,sin(x)");
}

void loop()
{
Serial.print("DATA,TIME,"); Serial.print(x); Serial.print(","); Serial.println(sin(x*PI/180));
delay(200);
row+=2;
x+=2;
if (row >= 360)
   {
    row=0;
    Serial.println("ROW,SET,2");
    delay(200);
   }
}

Quand la variable row (ligne) atteint 360, le message "ROW,SET,2" est émis vers le PC (donc vers Calc), pour signaler à Calc que la prochaine les prochaines valeurs devront être stockées au début de la feuille Calc.

III.3. Installation et utilisation

Prérequis: LibreOffice doit être installé sur la machine faisant l'acquisition.

Concernant OpenDaqCalc, il n'y a pas d'installation, il suffit juste de télécharger package OpenDaqCalc.zip (Version courante: V2.0), le copier sur le disque dur de votre machine (ça ne marche pas depuis une clé USB ou un CD/DVD).

Important: le chemin du répertoire de stockage ne doit pas contenir de caractères spéciaux tels qu'espaces ou caractères accentués.

Une fois le package OpenDaqCalc.zip décompressé, vous obtenez un répertoire OpenDaqCalc contenant tout le nécessaire pour Windows et pour Linux.

Aller dans le répertoire OpenDaqCalc et double-cliquer sur le fichier OpenDaqCalc.ods: Calc s'ouvre automatiquement et demande d'activer la macro contenu dans ce fichier. Cliquer sur "Activer les macros".

Pour lancer la macro:
- aller dans Outils -> Macros -> Exécuter la macro
- déplier l'arborescence sous OpenDaqCalc.ods pour atteindre OpenDaqCalc.ods -> Standard -> Module1

- dans la liste "Nom de la macro", double-cliquer sur "Main": l'interface d'accès au port série s'ouvre.

Depuis la version OpenDaqCalc V2.0, un appui sur F3 lance directement l'interface graphique de la macro.

Note:

Pour que OpenDaqCalc puisse accéder au port série de la machine, la Serial Console de l'EDI arduino ne doit pas être ouverte.

IV. Le debugger TinyDbg pour arduino

TinyDbg est une bibliothèque permettant de faire le debug de sketch arduino en utilsant juste un port série. Ce port peut être un Hardware Serial ou un Software Serial ou n'importer quel objet de type Stream: il est donc tout à fait possible de faire du debug à travers un réseau IP si le stream est un socket IP/UDP par exemple!
Il supporte les points d'arrêt et l'inspection de variable, le dump des mémoires RAM, EEPROM et FLASH.
Elle s'utilise en plaçant dans le sketch les breakpoints et les inspecteurs de variables.
Du pas-à-pas basique peut être réalisé en plaçant des breakpoints successifs.
Il est également possible de modifier les variables pendant l'exécution du sketch.
Le debug se fait en ligne de commande dans un terminal série.
Cette bibliothèque utilise un peu plus de 10 Ko de FLASH et environ 200 octets de RAM. Elle est donc essentiellement destinée au debug sur les arduino UNO, Leonardo, Nano et MEGA qui disposent d'au moins 32 Ko de FLASH.

IV.1. Utilisation de la bibliothèque TinyDbg

Dans le sketch à mettre au point:

Inclure la bibliothèque TinyDbg (#include <TinyDbg.h>)
Initialiser un objet stream, par exemple un port série Serial
Dans le setup(), appeler la méthode TinyDbg_init(&Serial)
Dans la loop(), appeler la méthode TinyDbg_event()
Délarer les inspecteurs de variable sur les variables à inspecter (xxWATCH())
Placer les points d'arrêt BREAK(x)
Ouvrir un terminal série et utilser les commandes en ligne du debugger
Bon debug!

Screenshot d'un sketch de test pour debug
Sketch de test pour TinyDbg

Session de debug avec TinyDbg
Session de debug avec TinyDbg

Pour en savoir plus, rendez-vous sur mon dépot GitHub.

Retour