LOCODUINO

Forum de discussion
Dépôt GIT Locoduino
Flux RSS

mardi 17 octobre 2017

45 visiteurs en ce moment

Bien utiliser l’IDE d’Arduino (2)

. Par : Thierry

Après l’installation de l’IDE, et le descriptif de toutes les options du menu, il convient d’apprendre à se servir de cet outil gratuitement mis à notre disposition par la communauté Arduino.

A quoi ça sert ?

Votre but est de faire fonctionner l’Arduino comme vous le voulez. Pour y arriver, vous devrez taper du texte ésotérique, puis demander à l’Arduino de l’exécuter. Pour vous aider, vous avez installé un outil dédié, l’IDE, qui va vous permettre de répéter inlassablement (ou pas) :

  1. Ecrire/modifier le croquis
  2. Vérifier/Téléverser
  3. Tester

Bien entendu, impossible de sauter une étape, mais il est toujours possible d’en écourter une, en prenant un exemple qui est forcément bon comme l’exemple Blink, ou en téléversant directement puisque l’IDE fait la compilation avant d’envoyer la nouvelle version à l’Arduino. Et si le test final n’est pas satisfaisant, retour à la première action !

Pour comprendre le rôle de l’IDE, il faut d’abord comprendre les termes qui seront employés dans le reste de cet article, mais aussi partout ailleurs sur le site.

Terminologie

  • Éditeur de texte : c’est un programme informatique qui modifie un fichier texte. Notepad en est un sous Windows, comme vi sous linux tout comme SimpleText ou TextEdit sur Mac. Word, Lotus et LibreOffice/OpenOffice n’en sont pas, parce que le résultat n’est pas un fichier texte, mais quelque chose de bien plus complexe avec des notions de formatage (paragraphes, enchaînements…) et de typographie (gras, souligné, italique, exposant, images, tableaux…) inutiles pour nous, et incompréhensibles pour un IDE.
  • Code source : c’est le texte que vous devez taper pour faire faire ce que vous voulez à votre l’Arduino, grâce à un éditeur de texte. En clair, le fichier .ino, ou le croquis, ou le sketch dans la langue de Jonny Wilkinson.
  • Compilation : c’est l’action de conversion de ce texte en quelque chose de compréhensible par l’Arduino.
  • Compilateur : c’est l’outil utilisé pour cette conversion. Il est installé par l’IDE, vous n’avez pas à vous en préoccuper.
  • Téléversement : action d’envoyer le résultat de cette compilation à l’Arduino via une prise USB.
  • Bibliothèque : code source déjà écrit par quelqu’un d’autre qu’il vous permet d’utiliser pour vous faciliter la vie. Ce peut être le moyen d’accéder facilement à un dispositif matériel (écran, servo, carte SD…) ou une utilisation pointue et particulière de l’Arduino (EEPROM, PWM  …). Certaines bibliothèques sont livrées avec l’IDE, d’innombrables autres sont téléchargeables sur le Web, et notamment sur Locoduino !

Et alors ?

Tout IDE recouvre tout cela, et celui d’Arduino n’échappe pas à cette règle :

C’est d’abord un éditeur de texte capable de coloration syntaxique. Cela veut juste dire que selon ce qu’il lit l’IDE est capable de mettre les commentaires dans une couleur, les noms de variables dans une autre, et caetera. Attention, les couleurs ne sont pas sauvées dans le fichier texte. Si vous ouvrez un fichier .ino dans un éditeur simple comme Notepad sous Windows, vous ne verrez plus que le texte. A l’inverse, cela signifie aussi que n’importe quel éditeur de texte peut modifier les croquis… L’IDE possède les commandes de base de tout bon éditeur : plusieurs fichiers peuvent être modifiés simultanément grâce aux onglets, des fonctions de recherche et de copier/coller sont présentes au menu.

L’IDE permet ensuite via des boutons de compiler le texte et d’obtenir un rapport signalant les erreurs éventuelles. Cette compilation produit plusieurs fichiers cachés dans les répertoires temporaires du système, dont un fichier résultat binaire de la compilation.

Un autre bouton permet d’envoyer ce fichier résultat dans l’Arduino via la prise USB. C’est le téléversement.

Enfin, lorsque l’Arduino est en marche, il peut à son tour envoyer via l’USB des messages que l’IDE peut afficher sur sa console série. C’est un bon moyen pour tenter de comprendre ce qui se passe dans l’Arduino…

Comment ça marche ?

Les répertoires

Selon votre système, vos projets se trouveront à des endroits différents :

  • sketchbook pour GNU/Linux,
  • Documents/Arduino pour Mac,
  • Mes Documents/Arduino ou Documents/Arduino pour Windows, selon la version.

mais le contenu sera toujours le même. Chaque projet contient un répertoire qui porte le nom du projet, et dedans il y a un fichier .ino portant ce même nom, et éventuellement d’autres fichiers.

Si vous regardez dans l’IDE, le menu ’Fichier/Carnets de croquis’, c’est exactement ce que contient ce répertoire. L’IDE vous permet ainsi d’ouvrir directement un projet sans passer par un explorateur de fichier.

Si vous n’avez jamais fait de croquis, que vous venez d’installer l’IDE, ce répertoire est vide. Le menu ’Fichier/Carnet de croquis’ l’est également. Lorsque rien n’est présent dans le répertoire, l’ouverture de l’IDE a considéré que vous vouliez créer un nouveau projet et vous fourni le ’squelette’ de tout croquis Arduino :

  1. void setup() {
  2. // put your setup code here, to run once:
  3.  
  4. }
  5.  
  6. void loop() {
  7. // put your main code here, to run repeatedly:
  8.  
  9. }

Ce code est tel quel exécutable, mais il est vide, il ne fera donc pas grand chose… Plutôt que de tenter d’inventer un petit programme pour tester, l’IDE vous permet d’ouvrir l’un des exemples fournis par son installation avec l’option ’Fichier/Exemples’. Le point de départ est normalement ’01.Basics/Blink’ qui fait clignoter la DEL   présente sur l’Arduino lui-même. C’est un des rares exemples qui produit un résultat visible sans nécessiter d’autre matériel que l’Arduino lui même !

Sélectionner le modèle d’Arduino.

Avant de compiler quoi que ce soit en appuyant sur le bouton ’Vérifier’ ou ’Téléverser’, il faut être sûr de le faire pour le bon Arduino. En effet, selon le modèle d’Arduino auquel vous destinez le téléversement, des changements dans votre source peuvent être nécessaires. Prenons l’exemple ’Blink’ :

  1. // the setup function runs once when you press reset or power the board
  2. void setup() {
  3. // initialize digital pin 13 as an output.
  4. pinMode(13, OUTPUT);
  5. }
  6.  
  7. // the loop function runs over and over again forever
  8. void loop() {
  9. digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)
  10. delay(1000); // wait for a second
  11. digitalWrite(13, LOW); // turn the LED off by making the voltage LOW
  12. delay(1000); // wait for a second
  13. }

À sa lecture, on peut deviner que tout se passe sur la broche ’13’ de l’Arduino. Cette broche est disponible pour vos besoins, mais elle est en plus reliée à la DEL   montée sur l’Arduino d’origine.
Le code qui est là, fourni par l’IDE lui même, n’est pas compatible avec tous les Arduino. Par exemple l’un des derniers, le MKR1000, utilise sa broche 6 pour sa DEL ! Donc Blink ne fonctionnera pas pour lui. Pour résoudre ce problème deux solutions :

La première consiste à modifier le croquis pour mettre des 6 partout, mais on voit bien qu’à chaque changement d’Arduino, il faudra refaire ce travail. Ce n’est pas bien grave sur Blink, mais sur un programme plus vaste ça pourrait devenir pénible, et surtout cause de problèmes, un oubli est si vite arrivé…

L’autre solution consiste à utiliser un alias, un define. On va mettre dans le code une constante fournie par l’IDE dans ses versions les plus récentes, LED_BUILTIN (qui signifie ’DEL incluse’ dans la langue de Paul Pogba), à la place de 13. Et c’est l’IDE qui va effectuer l’échange que je vous proposais dans la première solution. C’est quand même plus confortable, non ? La seule contrepartie, c’est que l’IDE doit maintenant savoir pour quel matériel il doit compiler le croquis. Ça lui permettra de changer pour la bonne valeur. Il y a d’autre subtilités encore plus problématiques d’un modèle d’Arduino à un autre, comme le nombre de liaisons série, d’interruptions ou de broches capables de faire du PWM  … Et si ça ne suffisait pas, certains modèles ne parlent carrément pas le même langage, comme le Due ou les Teensy 32 bits équipés d’un processeur ARM et pas ATMEL… Une bonne partie de tout cela sera transparent pour vous, à condition de bien choisir le modèle d’Arduino dans le menu ’Outils/Type de carte’ . Le type courant est rappelé en bas à droite de la fenêtre de l’IDE.

Sélectionner le port de communication

L’autre grande option de configuration que vous devez absolument vérifier avant de faire quoi que ce soit avec l’IDE, c’est le port de communication.
L’Arduino et l’IDE communiquent via un port USB, qui est un port série. Sur un ordinateur normalement constitué, plusieurs ports USB sont disponibles, et éventuellement d’autres ports série, comme du RS232C . Il faut donc dire à l’IDE à quel port est connecté votre Arduino, faute de quoi la communication ne pourra pas se faire et donc votre programme créé et compilé dans l’IDE ne pourra pas être téléversé dans la mémoire de l’Arduino…
Par chance, l’IDE tente automatiquement d’identifier le port qui va bien, mais il peut échouer, et en particulier il peut se perdre si des Arduino sont branchés, puis débranchés puis rebranchés. Attention, un port identifié une fois ne sera pas forcément le même à la reconnexion du même module Arduino. Les systèmes d’exploitation modernes attribuent des noms virtuels à de vrais ports physiques. Ces noms sont dynamiquement alloués et donc pas nécessairement identiques d’une session à un autre.
Dans le menu ’Outils/Port’, si l’Arduino est connecté, si son nom apparaît à côté de l’un des ports, c’est évidemment celui là qu’il faut choisir…

Ports de communication sous Windows


Ports de communication sur un Mac

Le port de communication actuellement sélectionné est également rappelé à côté du type d’Arduino dans la barre de statut, en bas de la fenêtre de l’IDE.

Produire le programme qui va bien

Comme décrit plus haut trois étapes sont nécessaires…

La première étape est la frappe du croquis. La syntaxe du croquis est unique, incontournable, et absolument pas négociable… A l’exception des commentaires, des espaces et des sauts de ligne, tout caractère est nécessaire et important. Tout caractère manquant est tout aussi important. Je veux parler par exemple des point-virgules et des accolades qui doivent absolument se trouver aux bons endroits… Mais ça vous le savez puisque vous avez lu La programmation, qu’est ce que c’est

Vérifier

Vous avez bien travaillé, votre code est parfait, bien structuré, bien documenté, bref, vous êtes prêts pour le grand saut !
La première option à utiliser, c’est ’Croquis / Vérifier/Compiler’ . L’appui sur l’icône la plus à gauche en haut de l’écran de l’IDE lance aussi la vérification :

L’IDE va alors lancer le compilateur qui va utiliser le croquis présent dans l’IDE, même si vous ne l’avez pas encore sauvé ! Le compilateur, cet outil utilisé par l’IDE et installé avec lui, va traduire votre croquis en langage compréhensible par le type d’Arduino désigné plus tôt.

Le résultat de cette compilation donnera au choix deux types de texte dans la fenêtre d’information, en bas de l’IDE.

Soit tout s’est bien passé, et vous aurez le droit à un bilan mémoire du projet : la mémoire programme pour la partie exécutable en valeur et en pourcentage, et la mémoire dynamique [1] pour les variables, ici pour Blink pour un Arduino Uno :

Le croquis utilise 928 octets (2%) de l'espace de stockage de programmes. Le maximum est de 32'256 octets.
Les variables globales utilisent 9 octets (0%) de mémoire dynamique, ce qui laisse 2'039 octets pour les variables locales. Le maximum est de 2'048 octets.

Des messages de type ’Warning’ peuvent apparaître… Ils n’empêchent pas la génération du fichier résultat, mais il est de bon goût de faire disparaître ces warnings, surtout parce que très souvent ils annoncent de potentiels problèmes…

Si au contraire la moindre erreur a été relevée, alors vous aurez du texte rouge, et pas de félicitations ! Voyons ce qui se passe si j’enlève le point virgule derrière l’appel à pinMode de Blink :

La première ligne donne la localisation du problème : dans le fichier Blink.ino, dans la fonction setup(). La ligne suivante donne le numéro de ligne : 21, et enfin la description de l’erreur : "expected ’ ;’ before ’’ token", soit " ’ ;’ attendu avant le ’’ " dans la langue de Frank Ribéry [2]. Cette même description est répétée dans une bande orange entre le texte du croquis et la zone d’information. Notez le bouton à droite de la ligne orange ’Recopier les messages d’erreur’ : il copie (au sens de copier/coller) le rapport de compilation complet dans le presse papier, permettant ensuite de le coller sur un forum ou dans un mail pour demander de l’aide !

L’IDE tente aussi de positionner le curseur sur la ligne à problème. Si ce n’est pas le cas, déplacez le avec les flèches au clavier jusqu’à ce que le numéro de ligne affiché en bas à gauche de l’IDE corresponde. sinon il faut utiliser l’option Edition/Aller à la ligne du menu… Il ne reste plus qu’à corriger l’erreur avant de relancer la commande ’Vérifier’. Notez qu’en général une erreur de compilation en génère de multiples sur le reste du source. Lorsque plusieurs erreurs se produisent, en corrigeant la première vous avez toutes les chances d’en corriger d’un coup plusieurs, voire toutes ! Alors faites dans l’ordre, commencez par le début, vous gagnerez du temps.
Un détail sur l’erreur trouvée dans l’exemple : le message signale un problème à la ligne 21 parce qu’il attend un point-virgule après la parenthèse fermante de pinMode de la ligne 20, mais que le premier caractère trouvé incorrect est l’accolade de la ligne 21…

Téléverser

La compilation est achevée sans erreur notable, le rapport de mémoire utilisée ne fait pas état non plus d’un usage excessif, alors il ne reste plus qu’à essayer ! L’Arduino est branché, le deuxième icône ’Téléverser’ (ou l’option du menu) peut être utilisé pour transmettre le programme.
A noter que pour l’IDE, le téléversement commence par une compilation, puis le transfert s’effectue ensuite si aucune erreur de syntaxe n’est apparue. C’est ce qui explique le nom de l’option ’Vérifier’ qui ne sert qu’à… vérifier que la syntaxe est bonne avant de lancer la vraie commande : Téléverser…
Les deux diodes Rx/Tx de l’Arduino vont clignoter pendant le transfert, et le programme démarrera immédiatement sur l’Arduino. Bien entendu, si l’Arduino n’est pas connecté, ou que le port est utilisé par un autre programme, ou que le mauvais outil de transfert (option ’Outils/Programmateur’) a été sélectionné, alors les DEL ne clignoteront pas et le transfert va échouer. L’IDE va faire plusieurs essais avant de crier forfait et d’afficher un message d’erreur qui ressemble à :

Il faut alors vérifier toute la chaîne, la sélection du bon modèle d’Arduino, du port de communication, voire du programmateur si vous y avez touché. Vérifier aussi la bonne connexion du câble USB, et notamment que vous n’êtes pas en train d’utiliser un câble d’alimentation USB ! En effet, certains câbles sont faits uniquement pour recharger des appareils (portables, tablettes, liseuses…) et ne transportent que le courant, les fils de données ne sont pas branchés ! Pour être sûr, mieux vaut faire les premiers tests avec le câble livré avec l’Arduino…

Tester

Vous y êtes. Le programme est compilé, téléversé et donc exécuté sur votre Arduino. Pourtant, rien ne se passe comme prévu : les diodes ne clignotent pas, les moteurs ne bougent pas, bref, ça ne marche pas. Comment faire pour trouver le problème ? Quelques pistes :

  1. Vérifiez à nouveau que vous avez bien compilé pour le bon modèle d’Arduino…
  2. Vérifiez le câblage, et notamment les numéros de broche et l’alimentation de vos accessoires diodes, moteurs etc… Les petits fils utilisés pour les branchements font parfois de mauvais contacts !
  3. Etes vous sûr que votre Arduino est capable de délivrer la puissance électrique nécessaire à tout ce qui branché dessus ? Rappelez vous qu’il ne peut alimenter que quelques diodes, ou un servo moteur. Au delà, un circuit de puissance comme l’ULN2803 ou le LMD18200 avec une alimentation externe est nécessaire. Attention : si vous tirez trop sur l’Arduino, il risque de ne pas le supporter et de crier définitivement forfait.
  4. Utilisez le bouton ’Reset’ certainement présent sur votre Arduino. Ce n’est pas dur de le trouver, c’est probablement le seul ! Le programme va redémarrer. Certains modèles d’Arduino n’aiment pas lancer directement l’exécution après le téléversement…
  5. Refaites un tour dans votre croquis pour en détailler le fonctionnement et vous assurer que le comportement codé est bien celui prévu.

Si rien ne donne de résultat, vous devrez avancer pas à pas pour trouver la source du problème. Pour vous y aider, vous avez un grand ami du développeur de croquis, c’est le moniteur série. En haut à droite de l’IDE se trouve une icone avec une loupe qui permet d’activer ce moniteur série, appelé aussi la console.

C’est un moyen de communication avec l’Arduino pendant son exécution. L’Arduino peut y envoyer des messages dans la grande fenêtre, et vous pouvez envoyer un ordre à votre Arduino par le champ de saisie tout en haut avec son bouton ’envoyer’. Sous réserve bien sûr de coder ce qu’il faut dans le croquis pour récupérer cet ordre et y réagir, ça ne se fera pas tout seul…
La case à cocher ’Défilement automatique’ activée par défaut permet, en la décochant, de geler l’affichage de la grande fenêtre centrale pour prendre le temps de lire son contenu. Vous constaterez à l’usage qu’il est très facile de saturer cette fenêtre avec des choses plus ou moins utiles. Le combo (liste déroulante fermée au repos) à la droite de la case à cocher fixe la terminaison des messages envoyés vers l’Arduino. A régler uniquement si vous utilisez le champ d’envoi et son bouton ’Envoyer’.
Enfin le combo tout à droite fixe la vitesse de communication de cette fenêtre. elle doit impérativement correspondre à celle fixée dans votre croquis à l’aide de Serial.begin(…) . Le valeur par défaut est 9600 bauds (bits par seconde), ce qui est très faible. Je préconise un minimum de 115200 bauds, ce qui limitera le temps passé à lire et échanger des données. Tous les Arduino sont capables sans problème de tenir cette vitesse, et sans doute beaucoup plus. La limite de la console est à 2000000 (2Mbauds !).
Mais revenons à notre croquis qui ne marche pas. Avant tout, il faut savoir à quel moment se trouve le problème. L’Arduino arrive t-il jusqu’au début du setup ? Est ce qu’il le termine correctement ? Arrive-t-on au loop ?

Pour dialoguer par la liaison série, il suffit d’initialiser le port série ’Serial’ avec la vitesse voulue au tout début du setup :

  1. void setup()
  2. {
  3. Serial.begin(115200);
  4. ...
  5. }

Ajoutons une ligne pour signaler le début, et une autre pour signaler la fin de l’exécution du setup :

  1. void setup()
  2. {
  3. Serial.begin(115200);
  4. Serial.println("Debut");
  5. ...
  6. Serial.println("fin");
  7. }

Attention de bien utiliser println() qui va afficher tout de suite, et pas print() qui va attendre la fin de la ligne, c’est à dire le prochain println(), pour tout afficher… C’est comme ça qu’on se retrouve sur de fausses pistes !
Pour éviter de saturer votre console, je vous conseille de ne pas mettre tout de suite les mêmes appels avec debut et fin dans loop !
Lancez tel quel, et observez le résultat.
Deux solutions : vous voyez apparaître ’Debut’ sur la console, et on peut passer à la suite, soit vous ne le voyez pas, et là encore deux solutions : la vitesse de la console et du Serial.begin() sont elles les mêmes ? Si c’est le cas, vous avez un plantage pendant l’initialisation des variables globales, extérieures au setup et au loop. Sinon, réglez les vitesses et recommencez…
Si vous voyez bien "Debut", mais pas "Fin", c’est que quelque chose cloche au milieu de setup. Pour préciser le problème, vous pouvez ajouter des affichages après chaque ligne du setup comme Serial.println("1") en changeant bien sûr le numéro à chaque ajout…
Enfin, si vous voyez "Debut" et "Fin", il ne vous reste plus qu’à poser des Serial.println() à divers endroits de la loop pour vous assurer que son contenu réagit comme vous le voudriez…
Il faudrait sans doute un article complet pour décrire à le fois les problèmes les plus courants des débuts de la programmation, et les techniques à appliquer pour en venir à bout…

Les bibliothèques

Les bibliothèques sont des morceaux de code destinés à vous éviter de réinventer la roue. En installer une a déjà été expliqué dans cet article, je n’y reviendrais pas. Si j’en parle ici, c’est parce qu’une bibliothèque a une vie, tout comme votre croquis. Elle a été créée puis distribuée un jour, mais son auteur a sans doute continué à l’améliorer, à corriger les bugs qui s’y trouvent, ou à l’adapter aux nouvelles versions de l’IDE ou de l’éventuel matériel piloté… Et puis elle est devenue obsolète ou pire, inutile…

Dans le menu, l’option ’Croquis/Inclure une bibliothèque’ vous fournit une liste des bibliothèques installées. Au dessus de cette liste, se trouvent deux options fort utiles.

Je ne parlerais pas de la seconde qui est traitée dans l’installation des bibliothèques.

Par contre, la toute première option, Gestionnaire de bibliothèques, permet de gérer celles qui sont installées, d’en trouver de nouvelles, les installer, les mettre à jour, puis de désinstaller celles ne sont plus souhaitées.

Tout en haut se trouvent les filtres qui permettent de limiter la liste en dessous à ce qui vous intéresse.
A gauche, le combo ’Type’ vous permet de filtrer par type de bibliothèques : celles installées, celles disponibles directement depuis cette interface, celles qui demandent une mise à jour, ou carrément toutes !
Le combo du milieu filtre parmi celles qui restent du premier filtre, selon leur rôle : capteurs, entrées/sorties, affichage, communications, etc…
Enfin, si il en reste encore trop, il est aussi possible de donner une liste de mots séparés par des espaces. Les bibliothèques qui resteront seront celles dont le texte complet présent dans le cadre, pas que le nom, contient au moins une fois chacun des mots donnés.

Pour information, les bibliothèques présentes dans cette fenêtre regroupent :

  • toutes les bibliothèques installées par l’IDE (marquées ’built-in’ et ’INSTALLED’).
  • toutes les bibliothèques installées par l’utilisateur (marquées ’INSTALLED’).
  • toutes les bibliothèques gérées par le site Arduino.cc (leur auteur est ’Arduino’).
  • toutes les bibliothèques trouvées sur les grands sites de partage de code que sont GitHub, BitBucket et GitLab. Malheureusement, Framagit, le site de partage de code utilisé par Locoduino n’en fait pas partie. Mais fort heureusement, vous êtes sur le bon site pour combler cette lacune !

Lorsque vous avez trouvé la bonne bibliothèque, cliquez quelque part dans son cadre pour la sélectionner. Vous pouvez alors l’installer avec le bouton idoine si elle ne l’est pas encore, quelquefois en devant choisir avant la version à installer dans un combo (prenez la plus récente, c’est rarement un mauvais choix…). Vous pouvez la désinstaller avec le bouton du même nom si elle est déjà présente chez vous, et qu’elle n’est plus utile. Attention, il n’y a pas de contrôle sur la réelle utilisation ou non de la bibliothèque que vous désinstallez. Si vous retirez une bibliothèque, les croquis qui l’utilisent ne se compilerons plus ! Vous pouvez aussi en réinstaller une autre version si celle déjà en place vous pose des problèmes. Ne faites cela qu’en dernier recours… Enfin un lien ’More info’ vous renvoie souvent sur le site internet qui gère cette bibliothèque. Ce peut être la source d’information qui manque pour apprendre à s’en servir…

Les exemples

Parmi toutes les options de l’IDE, il en est une qui est vraiment essentielle, c’est ’Fichier/Exemples’.

Elle permet de trouver des exemples simples de programmation des Arduino, comme le cultissime Blink, mais aussi et surtout les exemples fournis avec toutes les bibliothèques installées, que ce soit par l’IDE ou par vos soins.
L’exemple reste le plus sûr moyen de comprendre le fonctionnement d’une bibliothèque, même s’il faut quelquefois avoir recours à de la documentation lorsque le problème est trop ardu…
Pour les bibliothèques livrées avec l’IDE, les exemples fournis sont particulièrement bien écrits, documentés (en Anglais par contre…) et simples à comprendre. Dans les critères de choix d’une bonne bibliothèque, hormis la nécessaire adéquation entre votre besoin et les services qu’elle fournit, il y a la présence d’exemples simples, documentés et fonctionnels (j’en ai vu qui ne marchaient pas, même parmi les miennes !), et si en plus une vraie documentation est accessible sur le site de l’auteur, c’est le Graal ! Méfiez vous d’une bibliothèque dont la dernière mise à jour remonte à plus de deux ans. Vous aurez peut être des problèmes de compatibilité avec les versions récentes de l’IDE ou des autres bibliothèques qu’elles utilisent…
Et si un problème devait se poser à l’usage, (ce n’est pas rare…) n’hésitez pas à contacter l’auteur sur son site pour lui soumettre votre problème. Il vous faudra sans doute le faire en Anglais, et en ayant réduit votre croquis à juste le problème posé. Le reste ne l’intéresse pas, compliquerait la recherche du problème et pourrait même l’induire en erreur.

// Mode autosatisfaction="On"
Je me permet de vous rappeler la chance qui est la vôtre de pouvoir sur ce site utiliser nos bibliothèques particulièrement efficaces, de pouvoir dialoguer avec leurs auteurs, et le tout en Français ! Vive Locoduino !
// End Mode

Cet article est déjà long, pourtant de nombreux autres points pourraient être traités ici tant les possibilités de ce ’petit’ IDE sont déjà importantes.

[1Voir l’article Bibliothèque MemoryUsage pour une explication du fonctionnement de la mémoire d’un Arduino

[2Si, si, je suis sûr qu’il parle le C++ couramment :))

3 Messages

Réagissez à « Bien utiliser l’IDE d’Arduino (2) »

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

Rubrique « Programmation »

Comment gérer le temps dans un programme ?

La programmation, qu’est ce que c’est

Types, constantes et variables

Installation de l’IDE Arduino

Répéter des instructions : les boucles

Les interruptions (1)

Instructions conditionnelles : le if … else

Instructions conditionnelles : le switch … case

Comment gérer l’aléatoire ?

Calculer avec l’Arduino (1)

Calculer avec l’Arduino (2)

Les structures

Systèmes de numération

Les fonctions

Trois façons de déclarer des constantes

Transcription d’un programme simple en programmation objet

Les chaînes de caractères

Trucs, astuces et choses à ne pas faire !

Processing pour nos trains

Arduino : toute première fois !

Démarrer en Processing (1)

Le monde des objets (1)

Le monde des objets (2)

Le monde des objets (3)

Le monde des objets (4)

Les pointeurs (1)

Les pointeurs (2)

Les Timers (I)

Les Timers (II)

Les Timers (III)

Les Timers (IV)

Les Timers (V)

Bien utiliser l’IDE d’Arduino (1)

Bien utiliser l’IDE d’Arduino (2)

Piloter son Arduino avec son navigateur web et Node.js (1)

Piloter son Arduino avec son navigateur web et Node.js (2)

Piloter son Arduino avec son navigateur web et Node.js (3)

Les derniers articles

Processing pour nos trains


Pierre59

Piloter son Arduino avec son navigateur web et Node.js (3)


bobyAndCo

Piloter son Arduino avec son navigateur web et Node.js (2)


bobyAndCo

Démarrer en Processing (1)


DDEFF

Piloter son Arduino avec son navigateur web et Node.js (1)


bobyAndCo

Arduino : toute première fois !


Christian

Bien utiliser l’IDE d’Arduino (2)


Thierry

Bien utiliser l’IDE d’Arduino (1)


Christian, Dominique, Jean-Luc, Thierry

Les Timers (V)


Christian

Trucs, astuces et choses à ne pas faire !


Dominique

Les articles les plus lus

Les interruptions (1)

Les Timers (I)

Répéter des instructions : les boucles

Calculer avec l’Arduino (1)

Les Timers (II)

Les Timers (III)

Démarrer en Processing (1)

Piloter son Arduino avec son navigateur web et Node.js (1)

Les chaînes de caractères

Les pointeurs (1)