Come posso unit test codice Arduino?

https://stackoverflow.com/questions/780819

13-09-2019
|

Domanda

Mi piacerebbe essere in grado di unit test il mio codice Arduino.L'ideale sarebbe essere in grado di eseguire qualsiasi test, senza dover caricare il codice per Arduino.Quali strumenti o librerie che mi può aiutare con questo?

C'è un Arduino emulatore di sviluppo che potrebbe essere utile, ma non sembra ancora pronto per l'uso.

AVR Studio da Atmel contiene un chip simulatore che potrebbe essere utile, ma non vedo come avrei potuto utilizzare in combinazione con l'IDE di Arduino.

Soluzione 2

In assenza di framework di unità preesistenti per Arduino, ho creato ArduinoUnit . Ecco un semplice schizzo Arduino dimostrando il suo utilizzo:

#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();
}

Altri suggerimenti

Non Eseguire Unit Test su Arduino Dispositivo o un Emulatore

Il caso contro il microcontrollore Dispositivo/Emulatore/Sim-based test

C'è un sacco di discussione su ciò che unit test mezzi e io non sono davvero cercando di fare un ragionamento che qui.Questo post è non dire di evitare tutti prove pratiche sul tuo obiettivo finale hardware.Sto cercando di fare un punto su come ottimizzare l' sviluppo ciclo di feedback, eliminando l'hardware di destinazione da il più banali e frequenti test.L'unità sotto test sono assunti per essere molto più piccolo rispetto a tutto il progetto.

Lo scopo di unit test per verificare la qualità del proprio codice.Unit test in genere dovrebbero mai verificare la funzionalità di fattori al di fuori del vostro controllo.

Pensate in questo modo:Anche se si dovesse verificare la funzionalità di Arduino biblioteca, l'hardware del microcontrollore o un emulatore, è assolutamente impossibile per tali risultati dei test di dire nulla circa la qualità del proprio lavoro.Quindi, è molto più valido ed efficiente per scrivere unit test non eseguito sul dispositivo di destinazione (o emulatore).

Frequenti controlli sul vostro hardware di destinazione è dolorosamente lento ciclo:

Modificare il codice
Compilare e caricare su Arduino dispositivo
Osservare il comportamento e indovinare se il il codice è fare ciò che ci si aspetta
Ripetere

Passo 3 è particolarmente sgradevole, se ci si aspetta di ricevere messaggi di diagnostica, tramite porta seriale, ma il suo progetto ha bisogno di utilizzare il vostro Arduino, solo l'hardware della porta seriale.Se state pensando che la biblioteca della seriale software può aiutare, si dovrebbe sapere che così facendo è probabile che rovinare qualsiasi funzionalità che richiedono tempi precisi, come la generazione di altri segnali allo stesso tempo.Questo problema è successo a me.

Di nuovo, se si prova il vostro disegno con un emulatore e il tuo tempo routine critiche ha funzionato alla perfezione fino a quando hai caricato l'effettivo Arduino, quindi l'unica lezione che si sta andando a imparare è che l'emulatore è viziata--e sapendo questo rivela ancora oggi nulla circa la qualità di proprio lavoro.

Se è stupido test del dispositivo o di un emulatore, che dovrebbe Posso fare?

Probabilmente stai usando un computer per lavorare sul vostro progetto Arduino.Il computer è ordini di grandezza più veloce rispetto al microcontrollore.Scrivere il test per costruire e eseguire sul vostro computer.

Ricordate, il comportamento di Arduino biblioteca e il microcontrollore deve essere presume essere corretto o almeno costantemente errata.

Quando il test di produrre un output contrariamente alle sue aspettative, allora è probabile che hanno un difetto nel codice che è stato testato.Se il test di uscita corrisponde alle vostre aspettative, ma il programma non si comporta correttamente quando si caricare su Arduino, poi si sa che i test sono basati su presupposti errati e, probabilmente, sono un esperto di test.In entrambi i casi, è stato dato reale, approfondimenti su ciò che il vostro prossimo modifiche al codice dovrebbe essere.La qualità del vostro feedback è migliorato da "qualcosa è rotto" per "questo specifiche codice è rotto".

Come compilare ed Eseguire Test sul Tuo PC

La prima cosa che devi fare è identificare gli obiettivi del test.Pensare a quali parti del il tuo codice si desidera verificare e assicurarsi di costruire il vostro programma in modo che si può isolare le parti discrete per il test.

Se le parti che si desidera chiamata di prova qualsiasi Arduino funzioni, è necessario fornire mock-up sostituzioni nel vostro programma di test.Questo è molto meno lavoro di quello che sembra.Il mock-up non è necessario fare nulla, ma fornisce un prevedibile di ingresso e di uscita per i test.

Qualsiasi codice che si intende test deve esistere nel file di origine diversa .pde schizzo.Non preoccuparti, il tuo sketch compilerà comunque anche con il codice sorgente al di fuori del disegno.Quando si ha realmente arriva al dunque, poco più del vostro programma normale punto di ingresso deve essere definito nel file di disegno.

Tutto ciò che rimane è quello di scrivere i test e poi compilarlo utilizzando il tuo preferito compilatore C++!Questo è probabilmente il meglio illustrato con un esempio del mondo reale.

Un vero e proprio lavoro di esempio

Uno dei miei progetti personali trovato qui ha alcuni semplici test che girano su PC.Per questo la risposta di presentazione, mi limiterò a andare oltre come ho deriso alcuni di Arduino funzioni di libreria e le prove che ho scritto per mettere alla prova gli mock-up.Questo non è contrario a ciò che ho detto prima non prova codice degli altri perché ero quello che ha scritto il mock-up.Volevo essere sicuro che il mio mock-up sono stati corretti.

Fonte di mock_arduino.cpp che contiene il codice che duplica alcune supportare le funzionalità fornite da Arduino libreria:

#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);
}

Io uso il seguente mock-up per produrre output leggibile quando il mio codice e scrive i dati binari con l'hardware del dispositivo seriale.

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;

e, infine, il test vero e proprio programma:

#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();
}

Questo post è abbastanza lungo, quindi si prega di consultare il mio progetto su GitHub vedere più casi di test in azione.Io tengo i miei lavori in corso in altri rami di master, in modo da controllare quei rami per test extra, troppo.

Ho scelto di scrivere il mio leggero routine di test, ma più robusto di unit test di framework come CppUnit sono inoltre disponibili.

Ho un notevole successo unità testare il mio codice PIC astraendo l'accesso all'hardware e beffardo nei miei test.

Per esempio, io PORTA astratto con

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

Poi SetPortA può essere facilmente deriso, senza l'aggiunta di codice in testa nella versione PIC.

Una volta che l'astrazione hardware è stato testato un po 'ho presto che in genere il codice va dal banco di prova per il PIC e lavora prima volta.

Aggiornamento:

Io uso una cucitura # include per il codice unità, #including il codice di unità in un file di C ++ per il banco di prova, e un file C per il codice di destinazione.

Come esempio voglio multiplex quattro display a 7 segmenti, una porta di guida dei segmenti e una seconda selezione della visualizzazione. Le interfacce di codice di visualizzazione con i display tramite SetSegmentData(char) e SetDisplay(char). Posso prendere in giro questi nel mio C ++ banco di prova e verificare che ottengo i dati mi aspetto. Per l'obiettivo che uso #define modo che ho un affidamento diretto senza il sovraccarico di una chiamata di funzione

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

Sembra che emulino avrebbe fatto il lavoro perfettamente.

Emulino è un emulatore per la piattaforma Arduino da Greg Hewgill. ( Fonte )

GitHub repository

simavr è un AVR simulatore usando avr-gcc.

E 'già supporta alcuni ATTiny e microcontrollori ATmega, e - secondo l'autore - è facile aggiungere un po' di più

Negli esempi si trova simduino, un emulatore Arduino. Esso supporta l'esecuzione il bootloader di Arduino e può essere programmato con avrdude attraverso Socat (una versione modificata Netcat ).

È possibile verificare unità in Python con il mio progetto, PySimAVR . Arscons è usato per la costruzione e simavr per la simulazione.

Esempio:

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'

Inizio di test:

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

Non sono a conoscenza di qualsiasi piattaforma che può testare il codice Arduino.

Tuttavia, v'è la Fritzing piattaforma , che può essere utilizzato per modellare l'hardware e più tardi gli schemi PCB esportazione e roba.

Vale la pena.

Stiamo usando schede Arduino per l'acquisizione dei dati in un grande esperimento scientifico. Successivamente, dobbiamo sostenere diverse schede Arduino con diverse implementazioni. Ho scritto utilità Python per caricare dinamicamente le immagini esagonali Arduino durante test di unità. Il codice trovato sul link sottostante supporta Windows e Mac OS X tramite un file di configurazione. Per scoprire dove le immagini esadecimali sono posti dalla Arduino IDE, premere il tasto shift prima di premere il pulsante di build (play). Hit il tasto Shift mentre colpisce di upload per scoprire dove il vostro avrdude (caricare utilità riga di comando) si trova sul vostro sistema / versione di Arduino. In alternativa, è possibile guardare i file di configurazione inclusi e utilizzare il percorso di installazione (attualmente in Arduino 0020).

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

Questo programma permette esecuzione automatica di vari test di unità Arduino. Il processo di test è stato avviato sul PC, ma i test eseguito sul hardware reale Arduino. Una serie di test di unità è tipicamente usato per testare una libreria Arduino. (Questo

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

pagina del progetto GitHub: http://jeroendoggen.github.com/Arduino-TestSuite

Pagina in Python Package Index: http://pypi.python.org/pypi/arduino_testsuite

I test di unità sono scritti con la "Arduino Unit Testing Library": http://code.google. com / p / arduinounit

Le seguenti operazioni vengono eseguite per ogni insieme di test unitari:

Leggi il file di configurazione per scoprire i test da eseguire
Lo script compila e carica uno schizzo Arduino che contiene il codice di test di unità.
Le unit test vengono eseguiti sulla scheda Arduino.
I risultati del test vengono stampate tramite la porta seriale e analizzati dallo script Python.
Lo script inizia il prossimo test, ripetendo i passaggi precedenti per tutti i test che sono richiesti nel file di configurazione.
Lo script stampa una sintesi che mostra una panoramica di tutti i test falliti / superato nella suite di test completo.

Mantenere codice specifico hardware separato o astratta lontano dal resto in modo da poter testare e fare il debug che più grande "riposo" su qualsiasi piattaforma per cui si dispone di buoni strumenti e con la quale si ha familiarità più.

In sostanza, cercare di costruire il maggior numero di codice finale da altrettanti blocchi noto-lavoro possibili. Il lavoro specifico per l'hardware restante sarà quindi molto più facile e più veloce. Si può finire utilizzando emulatori esistenti e / o emulare i dispositivi da soli. E poi, naturalmente, è necessario testare la cosa reale in qualche modo. A seconda delle circostanze, che può o non può essere molto ben automatizzabile (cioè chi o cosa premere pulsanti e fornire altri input? Chi o cosa osservare e interpretare vari indicatori e uscite?).

James W. Grenning scrive grandi libri e questo è di test di unità incorporata di codice C test Driven Development per embedded C .

Searduino quando si scrive codice Arduino. Searduino è un simulatore di Arduino e un ambiente di sviluppo (codice Makefiles, C ...) che lo rende facile da incidere in C / C ++ utilizzando il vostro editor preferito. È possibile importare schizzi Arduino ed eseguirli nel simulatore.

Cattura schermo di Searduino 0.8: http: // searduino. files.wordpress.com/2014/01/jearduino-0-8.png

Searduino 0.9 verrà rilasciato un video e saranno registrate non appena la dura test sono fatti .... in un giorno o due.

Test sul simulatore non è da considerare come i test veri e propri, ma certamente mi hanno aiutato molto nella ricerca di errori stupidi / logiche (dimenticando di fare pinMode(xx, OUTPUT), ecc.).

A proposito: io sono una delle persone in via di sviluppo Searduino

arduino_ci per questo scopo. Anche se è limitato al test librerie Arduino (e schizzi non standalone), consente unit test per essere eseguito localmente o su un sistema di CI (come Travis CI o Appveyor).

Si consideri una libreria molto semplice nella directory Arduino Biblioteca, chiamato DoSomething, con do-something.cpp:

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

int doSomething(void) {
  return 4;
};

Si sarebbe unità di prova come segue (con un file di test chiamato test/is_four.cpp o qualcosa del genere):

#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.

Questo è tutto. Se che la sintassi assertEqual e testare la struttura sembra familiare, è perché ho adottato alcuni dei di Matthew Murdoch ArduinoUnit biblioteca che ha fatto riferimento al sua risposta .

Reference.md per ulteriori informazioni di test di unità I / O pin, l'orologio, porte seriali, ecc.

Queste unit test vengono compilati ed eseguiti utilizzando uno script contenuto in una gemma rubino. Per esempi di come impostare che fino, vedere la README.md o semplicemente copiare da uno di questi esempi:

Un esempio pratico, test un'implementazione coda
Un'altra serie di test su un altro progetto coda
Un esempio complesso, simulando una libreria che controlla un dispositivo interattivo tramite una connessione SoftwareSerial come parte della biblioteca Adafruit FONA
biblioteca esempio DoSomething mostrato sopra, utilizzato per testare arduino_ci stessa

C'è un progetto chiamato ncore , che prevede nucleo nativo per Arduino. E ti permette di scrivere i test per il codice Arduino.

Dalla descrizione del progetto

Il nucleo originario permette di compilare ed eseguire schizzi Arduino sulla PC, generalmente senza alcuna modifica. Esso fornisce versioni native di funzioni Arduino standard e un interepreter riga di comando invia ingressi per lo schizzo che normalmente provengono da l'hardware stesso.

Anche sul "che cosa ho bisogno di usare it" sezione

Se si vuole costruire i test, avrete bisogno di cxxtest da http://cxxtest.tigris.org . NCORE è stato testato con cxxtest 3.10.1.

Se si vuole codice unità-test al di fuori MCU (sul desktop), controlla libcheck: https://libcheck.github.io/check/

L'ho usato per testare il mio codice incorporato paio di volte. E 'quadro piuttosto robusto.

È possibile utilizzare emulare - è possibile trascinare e rilasciare un microcontrollore su un diagramma ed eseguire il codice in Eclipse. La documentazione sul sito spiega come configurarlo.

Usa Proteus VSM con una libreria di Arduino per il debug del codice o per testarlo.

Si tratta di una buona pratica prima di ottenere il codice a bordo, ma essere sicuri con tempi perché la simulazione non viene eseguito in tempo reale mentre corrono sul tabellone.

Prova Autodesk circuito simulatore . Esso consente di testare il codice Arduino e circuiti con molti altri componenti hardware.

In base Arduino è scritto in C e C ++, anche le librerie di Arduino sono scritti in C e C ++. Quindi, in termini semplici basta gestire il codice come C e C ++ e provare a fare il test di unità. Qui, con la parola "manico" Voglio dire di cambiare tutta la sintassi di base come Serial.println a SYSOUT, pinMode a varaibles, void loop a ciclo while () che rompe sia in keystock o dopo qualche iterazione.

So che questo è poco un processo lungo e non così dritto forward.On la mia esperienza personale, una volta che si arriva a fare con esso, questo risulta essere più affidabile.

-Nandha_Frost

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow