Comment puis-je tester l'unité code Arduino?

StackOverflow https://stackoverflow.com/questions/780819

Question

Je voudrais pouvoir tester mon unité code Arduino. Idéalement, je serais en mesure d'exécuter des tests sans avoir à télécharger le code à l'Arduino. Quels sont les outils ou les bibliothèques peuvent me aider?

Il y a un émulateur Arduino dans le développement qui pourrait être utile, mais il n » t semblent encore être prêt à l'emploi.

AVR Studio d'Atmel contient un simulateur de puce qui pourrait être utile, mais je ne vois pas comment je l'utiliser conjointement avec l'IDE Arduino.

Était-ce utile?

La solution 2

En l'absence de cadres de tests unitaires pré-existants pour Arduino, j'ai créé ArduinoUnit . Voici une simple esquisse Arduino montrant son utilisation: 

#include <ArduinoUnit.h>

// Create test suite
TestSuite suite;

void setup() {
    Serial.begin(9600);    
}

// Create a test called 'addition' in the test suite
test(addition) {
    assertEquals(3, 1 + 2);
}

void loop() {
    // Run test suite, printing results to the serial port
    suite.run();
}

Autres conseils

Ne pas exécuter des tests unitaires sur l'appareil ou Arduino Emulator

Le cas contre microcontrôleur Appareil / Emulator / tests basés-Sim

  

Il y a beaucoup de discussions sur ce que test unitaire moyens et je ne suis pas   vraiment essayer de faire un argument à ce sujet ici. Ce poste est pas   vous dire d'éviter tous tests pratiques sur votre cible ultime   Matériel. Je suis en train de faire un point sur l'optimisation de votre   cycle de rétroaction de développement en éliminant votre matériel cible de   vos tests les plus banales et fréquentes. Les unités en cours de test sont supposées   être beaucoup plus petit que l'ensemble du projet.

Le but des tests unitaires est de tester la qualité de votre propre code. Les tests unitaires devraient tester généralement jamais la fonctionnalité de facteurs hors de votre contrôle.

Pensez-y de cette façon: Même si vous deviez tester le fonctionnement de la bibliothèque Arduino, le matériel de micro-contrôleur ou un émulateur, il est absolument impossible pour les résultats des tests pour vous dire quoi que ce soit au sujet de la la qualité de votre travail. Par conséquent, il est beaucoup plus utile et efficace pour écrire des tests unitaires qui ne fonctionnent pas sur le périphérique cible (ou émulateur).

Des analyses fréquentes sur votre matériel cible a un cycle très lent:

  1. Tweak votre code
  2. Compiler et télécharger à l'appareil Arduino
  3. Observer le comportement et deviner si votre code fait ce que vous attendez
  4. Répéter

L'étape 3 est particulièrement agressif si vous vous attendez à recevoir des messages de diagnostic via le port série, mais votre projet lui-même a besoin d'utiliser uniquement le port série du matériel de votre Arduino. Si vous pensez que la bibliothèque SoftwareSerial pourrait aider, vous devriez savoir que cela est susceptible de perturber toute fonctionnalité qui nécessite une synchronisation précise comme générer d'autres signaux en même temps. Ce problème est arrivé à moi.

Encore une fois, si vous deviez tester votre esquisse à l'aide d'un émulateur et votre routine de temps critiques se est parfaitement jusqu'à ce que vous l'téléversé Arduino réelle, la seule leçon que vous allez apprendre est que l'émulateur est défectueuse - et sachant cela révèle encore rien de la qualité de votre travail.

Si c'est idiot de tester sur l'appareil ou l'émulateur, que devrait je faire?

Vous utilisez probablement un ordinateur pour travailler sur votre projet Arduino. Cet ordinateur est des ordres de grandeur plus rapide que le micro-contrôleur. Écrivez les tests pour construire et exécuter sur votre ordinateur .

Rappelez-vous, le comportement de la bibliothèque Arduino et microcontrôleur doit être supposé être soit correct ou au moins toujours incorrect .

Lorsque vos tests produisent contraire de sortie à vos attentes, alors vous avez probablement une faille dans votre code qui a été testé. Si votre sortie de test correspond à vos attentes, mais le programme ne se comporte pas correctement lorsque vous téléchargez à l'Arduino, alors vous savez que vos tests reposaient sur des hypothèses incorrectes et vous avez probablement un test erroné. Dans les deux cas, vous aurez donné de vraies idées sur ce que vos prochaines modifications du code devraient être. La qualité de vos commentaires est améliorée de " quelque chose est cassé" "ce code spécifique est cassé" .

Comment construire et exécuter des tests sur votre PC

La première chose que vous devez faire est de identifier vos objectifs de test . Pensez à ce que les parties de votre propre code que vous voulez tester et assurez-vous de construire votre programme de telle sorte que vous pouvez isoler des parties discrètes pour les tests.

Si les pièces que vous souhaitez tester appeler toutes les fonctions Arduino, vous devrez fournir le remplacement de la maquette dans votre programme de test. Cela est beaucoup moins de travail qu'il n'y paraît. Vos maquettes ne doivent pas faire quoi que ce soit, mais apporter une contribution prévisible et sortie pour vos tests.

De votre propre code que vous avez l'intention de tester doit exister dans la source des fichiers autres que l'esquisse de .pde. Ne vous inquiétez pas, votre croquis compilera encore même avec un code source en dehors de l'esquisse. Lorsque vous obtenez vraiment à elle, un peu plus que le point d'entrée normal de votre programme doit être défini dans le fichier croquis.

Tout ce qui reste est d'écrire les tests réels, puis le compiler en utilisant votre compilateur C ++ préféré! Ceci est probablement mieux illustré par un exemple du monde réel.

Un exemple de travail effectif

L'un de mes projets pour animaux de compagnie trouvé a quelques tests simples qui fonctionnent sur le PC. Pour cette soumission de réponse, je vais aller sur la façon dont je moquais-up certaines des fonctions de bibliothèque Arduino et les tests que j'ai écrit pour tester les maquettes. Ce n'est pas contraire à ce que je l'ai dit de ne pas tester le code d'autres personnes parce que je suis celui qui a écrit les maquettes. Je voulais être certain que mes maquettes étaient correctes.

Source de mock_arduino.cpp, qui contient du code qui fait double emploi avec des fonctionnalités de support fourni par la bibliothèque Arduino: 

#include <sys/timeb.h>
#include "mock_arduino.h"

timeb t_start;
unsigned long millis() {
  timeb t_now;
  ftime(&t_now);
  return (t_now.time  - t_start.time) * 1000 + (t_now.millitm - t_start.millitm);
}

void delay( unsigned long ms ) {
  unsigned long start = millis();
  while(millis() - start < ms){}
}

void initialize_mock_arduino() {
  ftime(&t_start);
}

J'utilise la maquette suivante pour produire une sortie lisible lorsque mon code écrit des données binaires sur le périphérique matériel série.

fake_serial.h 

#include <iostream>

class FakeSerial {
public:
  void begin(unsigned long);
  void end();
  size_t write(const unsigned char*, size_t);
};

extern FakeSerial Serial;

fake_serial.cpp 

#include <cstring>
#include <iostream>
#include <iomanip>

#include "fake_serial.h"

void FakeSerial::begin(unsigned long speed) {
  return;
}

void FakeSerial::end() {
  return;
}

size_t FakeSerial::write( const unsigned char buf[], size_t size ) {
  using namespace std;
  ios_base::fmtflags oldFlags = cout.flags();
  streamsize oldPrec = cout.precision();
  char oldFill = cout.fill();

  cout << "Serial::write: ";
  cout << internal << setfill('0');

  for( unsigned int i = 0; i < size; i++ ){
    cout << setw(2) << hex << (unsigned int)buf[i] << " ";
  }
  cout << endl;

  cout.flags(oldFlags);
  cout.precision(oldPrec);
  cout.fill(oldFill);

  return size;
}

FakeSerial Serial;

et enfin, le programme de test réel: 

#include "mock_arduino.h"

using namespace std;

void millis_test() {
  unsigned long start = millis();
  cout << "millis() test start: " << start << endl;
  while( millis() - start < 10000 ) {
    cout << millis() << endl;
    sleep(1);
  }
  unsigned long end = millis();
  cout << "End of test - duration: " << end - start << "ms" << endl;
}

void delay_test() {
  unsigned long start = millis();
  cout << "delay() test start: " << start << endl;
  while( millis() - start < 10000 ) {
    cout << millis() << endl;
    delay(250);
  }
  unsigned long end = millis();
  cout << "End of test - duration: " << end - start << "ms" << endl;
}

void run_tests() {
  millis_test();
  delay_test();
}

int main(int argc, char **argv){
  initialize_mock_arduino();
  run_tests();
}

Ce poste est assez long, donc s'il vous plaît se référer à mon projet sur GitHub pour voir plus de cas de test en action. Je garde mes œuvres en cours dans les branches autres que maître, afin de vérifier ces branches pour des tests supplémentaires, aussi.

J'ai choisi d'écrire mes propres routines de test légers, mais des cadres plus robustes tests unitaires comme CppUnit sont également disponibles.

J'ai unité de succès considérable tester mon code PIC par abstraire le accès matériel et il se moquant dans mes tests.

Par exemple, je fais abstraction PORTA avec 

#define SetPortA(v) {PORTA = v;}

Alors SetPortA peut facilement être moquée, sans ajout de code en tête dans la version PIC.

Une fois l'abstraction matérielle a été testé un certain temps, je trouve bientôt que le code général va du banc d'essai au PIC et fonctionne première fois.

Mise à jour:

J'utilise un cordon de #include pour le code d'unité, #including le code d'unité dans un fichier C ++ pour la plate-forme de test, et un fichier C pour le code cible.

Comme exemple, je veux multiplexer quatre afficheurs 7 segments, un port d'entraînement des segments et une seconde sélection de l'affichage. Les interfaces de code d'affichage à l'affichage par l'intermédiaire de SetSegmentData(char) et SetDisplay(char). Je peux se moquer de ceux-ci dans mon banc d'essai C ++ et vérifier que je reçois les données que j'attends. Pour la cible que j'utilise #define pour que je reçois une affectation directe sans la surcharge d'un appel de fonction 

#define SetSegmentData(x) {PORTA = x;}

Il semble que emulino ferait le travail parfaitement.

  

Emulino est un émulateur pour la plate-forme Arduino par Greg Hewgill. ( Source)

dépôt GitHub

simavr est un AVR simulateur avec avr-gcc.

Il prend en charge déjà quelques ATtiny et micro-contrôleurs ATMEGA, et - selon l'auteur - il est facile d'ajouter un peu plus

.

Dans les exemples se trouve simduino, un émulateur Arduino. Il prend en charge l'exécution du bootloader Arduino et peut être programmé avec avrdude par Socat (une version modifiée Netcat ).

Vous pouvez tester l'unité en Python avec mon projet, PySimAVR . Arscons est utilisé pour la construction et simavr pour la simulation.

Exemple: 

from pysimavr.sim import ArduinoSim    
def test_atmega88():
    mcu = 'atmega88'
    snippet = 'Serial.print("hello");'

    output = ArduinoSim(snippet=snippet, mcu=mcu, timespan=0.01).get_serial()
    assert output == 'hello'

Test de démarrage: 

$ nosetests pysimavr/examples/test_example.py
pysimavr.examples.test_example.test_atmega88 ... ok

Je ne suis pas au courant de toute plate-forme qui permet de tester le code Arduino.

Cependant, il y a la plate-forme Fritzing , que vous pouvez utiliser pour modéliser le matériel et plus tard sur les diagrammes de PCB à l'exportation et d'autres choses.

Vaut la peine.

Nous utilisons les cartes Arduino pour l'acquisition de données dans une grande expérience scientifique. Nous avons ensuite appuyer plusieurs cartes Arduino avec des implémentations différentes. J'ai écrit utilitaires Python pour charger dynamiquement les images hexagonales Arduino lors de tests unitaires. Le code se trouve sur le lien ci-dessous est compatible avec Windows et Mac OS X via un fichier de configuration. Pour savoir où vos images hexagonales sont placées par l'IDE Arduino, appuyez sur la touche Maj enfoncée avant d'appuyer sur le bouton de construction (lecture). Appuyez sur la touche Maj enfoncée tout en appuyant sur le téléchargement pour savoir où votre avrdude (ligne de commande utilitaire télécharger) se trouve sur votre système / version Arduino. Vous pouvez également regarder les fichiers de configuration inclus et utiliser votre emplacement d'installation (actuellement sur Arduino 0020).

http://github.com/toddstavish/Python-Arduino-Unit-Testing

Ce programme permet de lancer automatique de plusieurs tests unitaires Arduino. Le processus de test est démarré sur le PC, mais les tests effectués sur le matériel Arduino réelle. Un ensemble de tests unitaires est généralement utilisé pour tester une bibliothèque Arduino. (Ce

Forum Arduino: http://arduino.cc/forum/index.php?topic = 140027,0

GitHub page du projet: http://jeroendoggen.github.com/Arduino-TestSuite

Page dans le pypi: http://pypi.python.org/pypi/arduino_testsuite

Les tests unitaires sont écrits avec la "Unité Arduino Testing Library": http://code.google. com / p / arduinounit

Les étapes suivantes sont effectuées pour chaque série de tests unitaires:

  • Lire le fichier de configuration pour savoir quels tests à exécuter
  • Le script compile et télécharge un sketch Arduino qui contient le code de tests unitaires.
  • Les tests unitaires sont exécutés sur la carte Arduino.
  • Les résultats du test sont imprimés sur le port série et analysées par le script Python.
  • Le script démarre le test suivant, en répétant les étapes ci-dessus pour tous les tests qui sont demandés dans le fichier de configuration.
  • Le script affiche un résumé montrant un aperçu de tous les essais ont échoué / passé dans la suite de tests complète.

Gardez le code spécifique au matériel séparé ou abstraire loin du reste afin que vous puissiez tester et déboguer que plus « repos » sur toute plate-forme pour laquelle vous avez de bons outils et que vous connaissez le plus.

En gros, essayez de construire autant de code final d'autant de blocs de construction au travail connu que possible. Le travail restant matériel spécifique sera alors beaucoup plus facile et plus rapide. Vous pouvez terminer en utilisant émulateurs existants et / ou émule les périphériques de votre propre. Et puis, bien sûr, vous aurez besoin de tester la vraie chose en quelque sorte. En fonction des circonstances, qui peuvent ou peuvent ne pas être très bien automatisable (à savoir qui ou ce qui appuyer sur les boutons et fournir d'autres entrées? Qui ou quoi observeront et interpréter les différents indicateurs et résultats?).

James W. Grenning écrit de grands livres et celui-ci est sur le point de tests unitaires du code embarqué C test Driven Development pour embedded C .

J'utilise Searduino lors de l'écriture du code Arduino. Searduino est un simulateur Arduino et un environnement de développement (Makefile, le code C ...) qui le rend facile à pirater en C / C ++ en utilisant votre éditeur préféré. Vous pouvez importer des croquis Arduino et de les exécuter dans le simulateur.

Capture de Searduino 0.8: http: // searduino. files.wordpress.com/2014/01/jearduino-0-8.png

0,9 Searduino seront libérés et seront enregistrés dès la dure tests sont effectués une vidéo .... en un jour ou deux.

Test sur le simulateur ne doit pas être considéré comme des tests réels, mais il m'a aidé ont certainement beaucoup à trouver des erreurs stupides / logiques (en oubliant de faire pinMode(xx, OUTPUT), etc.).

BTW: Je suis l'une des personnes en développement Searduino

.

Je arduino_ci à cet effet. Bien qu'il soit limité à tester les bibliothèques Arduino (et non croquis autonomes), il permet des tests unitaires à exécuter soit le système local ou sur un CI (comme Travis CI ou Appveyor).

Tenir compte une bibliothèque très simple dans votre répertoire de la bibliothèque Arduino, appelé DoSomething, avec do-something.cpp: 

#include <Arduino.h>
#include "do-something.h"

int doSomething(void) {
  return 4;
};

Vous'D unité tester comme suit (avec un fichier de test appelé test/is_four.cpp ou quelque): 

#include <ArduinoUnitTests.h>
#include "../do-something.h"

unittest(library_does_something)
{
  assertEqual(4, doSomething());
}

unittest_main()  // this is a macro for main().  just go with it.

C'est tout. Si cette syntaxe assertEqual et la structure test semble familier, c'est parce que j'adopté certaines bibliothèque ArduinoUnit Matthew Murdoch  dont il a parlé dans sa réponse .

Voir Reference.md pour plus d'informations sur les tests unitaires I / O broches, l'horloge, des ports série, etc.

Ces tests unitaires sont compilés et exécutés à l'aide d'un script contenu dans un bijou rubis. Pour des exemples de la façon de mettre en place que, consultez le README.md ou tout simplement copier d'un de ces exemples:

Il y a un projet appelé ncore , qui fournit noyau natif pour Arduino. Et vous permet d'écrire des tests pour le code Arduino.

De la description du projet

  

Le noyau natif vous permet de compiler et d'exécuter des croquis Arduino sur le   PC, généralement sans modification. Il fournit des versions natives de   fonctions standard Arduino et un interepreter de ligne de commande pour donner   entrées à votre croquis qui viennent normalement du matériel   lui-même.

En outre sur le "que dois-je utiliser il section »

  

Si vous voulez construire les tests, vous aurez besoin de cxxtest    http://cxxtest.tigris.org . NCORE a été testé avec cxxtest 3.10.1.

Si vous voulez coder unité test à l'extérieur MCU (sur le bureau), consultez libcheck: https://libcheck.github.io/check/

Je l'ai utilisé pour tester mon propre code embarqué quelques fois. Il est cadre assez robuste.

Vous pouvez utiliser emulare - vous pouvez glisser et déposer un microcontrôleur sur un diagramme et exécutez votre code dans Eclipse. La documentation sur le site vous indique comment le configurer.

Utilisez Proteus VSM avec une bibliothèque Arduino pour déboguer votre code ou pour le tester.

Il est une meilleure pratique avant d'obtenir votre code à bord, mais assurez-vous avec des timings parce que la simulation ne fonctionne pas en temps réel comme ils courent sur la carte.

Essayez simulateur de circuit Autodesk . Il permet de tester le code Arduino et des circuits avec de nombreux autres composants matériels.

Dans Arduino de base est écrit en C et C ++, même les bibliothèques de arduino sont écrits en C et C ++. Donc, en termes simples gérer simplement le code comme C et C ++ et essayer de faire les tests unitaires. Ici, le mot « Handle » Je vous veux dire de changer toute la syntaxe de base comme Serial.println à sysout, pinMode à varaibles, boucle vide à boucle while () qui casse soit en keystock ou après une itération.

Je sais que cela est peu un processus long et pas droit forward.On mon expérience personnelle, une fois que vous arrivez à faire avec elle, ce se révèle être plus fiable.

-Nandha_Frost

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top