Comment déboguer une esquisse Arduino?

J'ai commencé à coder pour Arduino très récemment. Et ces bogues dans le code me tuent. Comme il n'y a pas de débogueur matériel dans l'Arduino, serial.print () est mon seul recours. Quelles sont les méthodes / pratiques que vous implémentez pour déboguer le code Arduino?

La modularité est votre amie. Écrivez votre boucle principale pour faire son travail en appelant des fonctions, qui appellent des fonctions, ..., jusqu'au niveau auquel vos fonctions seraient simples. Commencez avec la boucle principale et le niveau suivant, créez des fonctions de stub; soit vide:

function foo(){
    ;
}

ou faux:

function read_temperature(){
    return(95);
}

, qui ne font que renvoyer tout ce dont le niveau d'appel a besoin pour qu'il puisse continuer. Lorsque ce niveau fonctionne, descendez d'un niveau et commencez à remplir du code simple qui appelle également les fonctions de stub. Décompressez progressivement une fonction à la fois jusqu'à ce que vous ayez une application fonctionnelle.

Pour déboguer une fonction qui renvoie une mauvaise valeur, ou pour en créer une sans aucune influence du reste de votre application, vous pouvez créer un échafaudage - une simple esquisse qui alimente simplement la fonction quelques exemples de valeurs, et dans la fonction, imprimer les valeurs des paramètres et quelques valeurs intermédiaires, jusqu'à ce que vous ayez un aperçu de la partie de la fonction qui échoue. J'ai même créé des fonctions de simulation qui m'invitent sur le terminal à renvoyer une valeur. (Évidemment, cette technique ne peut fonctionner que si le système peut tolérer la vitesse relativement glaciaire de nous les humains! Une autre utilisation pour les échafaudages.)

Le stubbing fonctionne particulièrement bien pour remplacer les fonctions qui s'interfacent avec le matériel, ce qui vous permet de lancer l'application avant de plonger dans les fiches techniques, les problèmes de synchronisation et d'autres minuties (comme, ne pas avoir les pièces!) Qui pourraient autrement bloquer. vos progrès.

En parlant de problèmes de synchronisation, le basculement d'une broche de sortie à un point particulier de votre programme, comme l'entrée et la sortie d'un ISR, vous donne une onde carrée à la broche Arduino dont la fréquence ou le rapport cyclique peut vous donner un aperçu du calendrier interne de votre programme. La forme d'E / S de port direct, par exemple,

PORTC ^= 0x01;

, faussera moins le timing que l'appel digitalWrite(). Utile si vous avez un oscilloscope à portée de main ou l'un des multimètres numériques avec la capacité de mesurer la fréquence et / ou le rapport cyclique.

De même, vous pouvez utiliser une broche de sortie analogique pour émettre une valeur numérique vers votre compteur depuis l'intérieur du programme sans trop perturber le timing ou gonfler le code avec les fonctions d'E / S série. Utilisez également les formulaires d'E / S directes ici.

J'utilise Serial.print () et je fais clignoter les LED.

C'est à peu près tout ce que vous pouvez faire.

De plus, je m'assure que le code est lisible et facile à comprendre. Décomposez les choses en étapes simples et créez des fonctions pour chaque étape, afin que vous puissiez voir la séquence exacte des événements.

3 autres techniques:

• Développez les fonctionnalités d'un programme en testant lentement à chaque étape, de cette façon, vous ne rencontrez qu'un petit ensemble de bogues à la fois.

• Construisez le programme autour d'un interpréteur de commandes afin de pouvoir travailler avec des sections à la fois comme ici .

• Pulse out à des moments significatifs et utilisez un oscilloscope.

Le plugin Visual Micro pour Visual Studio fournit Arduino Debug . Comprend la trace et la coupure du code source permet également aux expressions et aux variables d'être «surveillées» et / ou modifiées.

En partant d'outils de luxe comme ARM ou d'autres plates-formes (AVR, PIC avec des outils décents), je conviens que les fonctionnalités de débogage Arduino sont trop limitées. Mais c'est un outil de démarrage à faible entrée.

Serial.print () est votre ami. Pour mon projet particulier (collège), je n'avais pas de LED attachées, donc Serial.print () c'est le cas. Si je veux tester si le code s'exécute correctement dans les instructions, je place généralement Serial.print ("A"); , puis aller à B, C, etc. ou quelque chose dans la section que je débogue. Je compare les lettres de débogage avec ce que je pense que cela devrait faire.

En dehors de cela, il n'y a pas de points d'arrêt ou de progression de code. Arduino n'est rien de plus qu'une carte avec une puce AVR atmega, un bootloader + environnement de développement et une tonne de bibliothèques de logiciels. Malheureusement, travailler avec un chargeur de démarrage limite les capacités de débogage.

Pour rendre l'utilisation de serial.printplus contrôlée, vous pouvez définir une variable booléenne globale pour activer et désactiver le débogage. Toutes les lignes de serial.printseront encapsulées dans une ifinstruction qui sera exécutée uniquement si l'indicateur de débogage est activé. De cette façon, vous pouvez laisser les lignes de débogage dans le code même lorsque vous avez terminé, mais assurez-vous de définir l'indicateur de débogage sur OFF plus tard.

Mieux que directement serial.print, utilisez des macros. Exemple:

#ifdef TRACE1
#define trace1(s) serial.print(s)
#define traceln1(s) serial.println(s)
#else
#define trace1(s)
#define traceln1(s)
#endif

Utilisez-le comme ceci:

function doIt(param1, param2) {
    trace1("->doIt("); trace1("param1: "); trace1(param1); trace1(" param2: "); trace1(param2); traceln1(")");

    ...

    traceln1("<-doIt");
}

Vous pouvez avoir différents niveaux de trace (#ifdef TRACE2 ...)avec plus de détails.

Et vous pouvez utiliser la macro « F », (trace1(F("param1"));). La macro "F" empêche que la chaîne utilise la quantité extrêmement limitée de SRAM.

LED clignotantes, imprimez des éléments sur le port série et écrivez et déboguez de petites sections de code à la fois, parfois seulement quelques lignes.

Il y a des moments où vous pouvez modulariser. Si en C, par exemple, vous pouvez développer et tester une fonction de calcul par exemple qui ne touche pas le matériel sur un ordinateur hôte, un autre processeur, envelopper la fonction avec un banc de test pour alimenter ses entrées et vérifier les sorties, etc.

Une autre manière similaire pourrait être d'utiliser un simulateur de jeu d'instructions si vous y avez accès (sinon, c'est un projet très éducatif et gratifiant, après en avoir fait quelques-uns, vous pouvez en frapper un en un week-end ou deux). Encore mieux si quelqu'un possède un clone Verilog ou VHDL du processeur ( OpenCores par exemple), vous pouvez essayer GHDL, Verilator ou Icarus Verilog . Il peut être suffisamment proche pour inclure les périphériques qui vous intéressent et vous pouvez obtenir une visibilité du niveau du signal sur ce qui se passe à l'intérieur.

Certes, ce n'est probablement pas un clone parfait, mais cela pourrait être suffisant. Verilator facilite vraiment la création de périphériques en C / C ++ afin que vous puissiez simuler tout ce à quoi votre appareil AVR est connecté.

Sortie UART et LED clignotantes et / ou lignes GPIO clignotantes et utilisant un oscilloscope ou un voltmètre. La clé pour ne pas devenir fou est d'écrire et de déboguer de petites sections de code. Il vaut mieux écrire 10 lignes à la fois et effectuer 100 tests que 1000 lignes et essayer de les déboguer toutes en une seule fois. Surtout lorsque vous découvrez que la plupart des fiches techniques et que les manuels de référence des programmeurs pour le matériel ne sont pas toujours corrects. Un piratage est toujours nécessaire.