Como pode código que eu teste de unidade Arduino?

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

Pergunta

Eu gostaria de ser capaz de unidade de teste meu código Arduino. Idealmente, eu seria capaz de executar todos os testes sem ter que carregar o código para o Arduino. Que ferramentas ou bibliotecas podem me ajudar com isso?

Há um Arduino emulador no desenvolvimento que poderia ser útil, mas ele doesn' t ainda parecem estar pronto para uso.

AVR Studio da Atmel contém um simulador de chips que poderiam ser útil, mas eu não posso ver como eu iria usá-lo em conjunto com o Arduino IDE.

Foi útil?

Solução 2

Na ausência de quaisquer estruturas de teste de unidade pré-existente para Arduino, eu criei ArduinoUnit . Aqui está uma simples Arduino esboço demonstrando seu uso: 

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

Outras dicas

NÃO testes Run unidade no dispositivo Arduino ou Emulator

O caso contra Dispositivo microcontrolador / baseados em SIM Emulator / testes

Há muita discussão sobre o que teste de unidade meio e eu não sou realmente tentando fazer um argumento sobre isso aqui. Este post é não dizendo-lhe para evitar todas testes práticos em seu alvo final hardware. Eu estou tentando fazer um ponto sobre como otimizar seu ciclo de feedback de desenvolvimento, eliminando o hardware de destino de seus testes mais banais e frequentes. As unidades em teste são assumidos a ser muito menor do que todo o projecto.

O objetivo do teste de unidade é testar a qualidade de seu próprio código. Os testes de unidade deve geralmente não testar a funcionalidade de fatores fora de seu controle.

Pense nisso desta maneira: Mesmo se você fosse para testar a funcionalidade da biblioteca Arduino, o hardware microcontrolador, ou um emulador, é absolutamente impossível para os resultados destes testes para lhe dizer nada sobre o qualidade de seu próprio trabalho. Por isso, é muito mais valioso e eficiente para testes de unidade de gravação que não são executados no dispositivo de destino (ou emulador).

Os testes frequentes sobre o hardware de destino tem um ciclo dolorosamente lento:

  1. Tweak seu código
  2. Compilação e upload para o dispositivo Arduino
  3. Observe o comportamento e adivinhar se o código está fazendo o que você espera
  4. Repita

Passo 3 é particularmente desagradável se você espera obter mensagens de diagnóstico via porta serial, mas seu projeto em si precisa usar a porta de série única de hardware do Arduino. Se você estava pensando que o SoftwareSerial ajuda biblioteca de poder, você deve saber que isso é susceptível de perturbar qualquer funcionalidade que requer tempo exato como gerar outros sinais ao mesmo tempo. Este problema já aconteceu comigo.

Novamente, se você fosse para testar o seu esboço usando um emulador e suas rotinas de tempo crítico correu perfeitamente até que você carregado para o Arduino real, então a única lição que você vai aprender é que o emulador é falho - e sabendo que esta ainda revela nada sobre a qualidade do seu próprio trabalho.

Se é bobagem para teste no dispositivo ou emulador, o que deve eu faço?

Você está provavelmente usando um computador para trabalhar em seu projeto Arduino. Esse computador é ordens de magnitude mais rápido do que o microcontrolador. Escrever os testes para construir e rodar em seu computador .

Lembre-se, o comportamento da biblioteca Arduino e microcontrolador deve ser assumido ser correto ou, pelo menos, consistentemente incorreta .

Quando os testes de produzir saída contrário às suas expectativas, então você provavelmente tem uma falha em seu código que foi testado. Se a sua saída de teste corresponda às suas expectativas, mas o programa não se comporta corretamente quando você enviá-lo para o Arduino, então você sabe que seus testes foram baseadas em suposições incorretas e você provavelmente tem um teste falho. Em ambos os casos, você terá sido dada percepções reais sobre o que seus próximos alterações de código deve ser. A qualidade do seu feedback é melhorada a partir de " algo está quebrado" para "esta código específico está quebrado" .

Como construir e executar testes em seu PC

A primeira coisa que você precisa fazer é identificar seus objetivos de teste . Pense sobre o que partes do seu próprio código que você deseja testar e, em seguida, certifique-se de construir o seu programa de tal forma que você pode peças discretas isolar para o teste.

Se as peças que você quer chamada de teste quaisquer funções Arduino, você precisará fornecer substituições mock-up em seu programa de teste. Isto é muito menos trabalho do que parece. Suas maquetes não tem que realmente fazer alguma coisa, mas fornecendo entrada e saída previsível para seus testes.

Qualquer um de seu próprio código que você pretende necessidades de teste de existir em outros do que o esboço .pde arquivos de origem. Não se preocupe, o seu esboço ainda irá compilar mesmo com alguns fora código-fonte do esboço. Quando você realmente começar a ele, pouco mais do que ponto de entrada normal do seu programa deve ser definido no arquivo de desenho.

Tudo o que resta é escrever os testes reais e, em seguida, compilá-lo usando seu C ++ favorito compilador! Este é provavelmente o melhor ilustrado com um exemplo do mundo real.

Um exemplo real de trabalho

Um dos meus projetos de estimação encontrados aqui tem alguns testes simples que são executados no PC. Para esta submissão resposta, vou apenas passar por cima como eu ridicularizado-up alguns dos Arduino funções de biblioteca e os testes que eu escrevi para testar essas mock-ups. Isto não é contrário ao que eu disse antes sobre não testar o código de outras pessoas, porque eu era o único que escreveu os mock-ups. Eu queria ser muito certo de que meus mock-ups estavam corretas.

Fonte de mock_arduino.cpp, que contém o código que duplica algumas funcionalidades suporte fornecido pela biblioteca 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);
}

Eu uso o seguinte mock-up para produzir saída legível quando meu código grava dados binários para o dispositivo serial hardware.

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, finalmente, o programa de teste real: 

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

Este post é longo o suficiente, portanto, consulte meu projeto no GitHub para ver mais alguns casos de teste em ação. Eu mantenho meus trabalhos em andamento em diferentes mestre ramos, de modo a verificar os ramos para testes extras também.

Eu escolhi para escrever minhas próprias rotinas de teste leves, mas estruturas de teste de unidade mais robustas como CppUnit também estão disponíveis.

Eu tenho unidade de considerável sucesso testando meu código PIC abstraindo o acesso ao hardware e ridicularizando-o em meus testes.

Por exemplo, eu PORTA abstrato com 

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

Então SetPortA pode facilmente ser escarnecido, sem adicionar código de sobrecarga na versão PIC.

Uma vez que a abstração de hardware foi testado um tempo eu logo descobrir que geralmente código vai desde o equipamento de teste para o PIC e trabalha primeira vez.

Update:

Eu uso uma costura #include para o código da unidade, #including o código de unidade em um arquivo C ++ para a plataforma de teste, e um arquivo de C para o código-alvo.

Como um exemplo Quero multiplexar quatro 7 exibe segmento, uma porta que accionam os segmentos e uma segunda escolhido a visualização. As interfaces de código de exibição com os monitores via SetSegmentData(char) e SetDisplay(char). I pode zombar estes em minha C ++ equipamento de teste e verificar que eu obter os dados que eu esperava. Para o #define alvo uso I para que eu recebo uma atribuição direta sem a sobrecarga de uma chamada de função 

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

Parece que emulino iria fazer o trabalho perfeitamente.

Emulino é um emulador para a plataforma Arduino por Greg Hewgill. ( Fonte )

GitHub repositório

simavr é um AVR simulador usar avr-gcc.

Ele já suporta alguns microcontroladores ATTINY e ATMEGA, e - de acordo com o autor. - É fácil de adicionar um pouco mais

Nos exemplos mentiras simduino, um emulador Arduino. Ele suporta a execução do bootloader Arduino e pode ser programado com avrdude através socat (a modificado Netcat ).

Você pode teste de unidade em Python com o meu projeto, PySimAVR . Arscons é usado para a construção e simavr para a simulação.

Exemplo: 

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'

teste inicial: 

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

Eu não estou ciente de qualquer plataforma que pode testar Arduino código.

No entanto, existe a Fritzing plataforma , que você pode usar para modelar o hardware e mais tarde em diagramas PCB exportação e outras coisas.

vale a pena conferir.

Estamos usando Arduino placas para aquisição de dados em um grande experimento científico. Posteriormente, temos de apoiar várias placas Arduino com diferentes implementações. Eu escrevi utilitários Python para carregar dinamicamente Arduino imagens hex durante testes de unidade. O código encontrado no link abaixo suportes Windows e Mac OS X através de um arquivo de configuração. Para descobrir onde suas imagens hexadecimais são colocados pelo Arduino IDE, pressione a tecla Shift antes de você apertar o botão de construção (play). Bata a tecla shift enquanto batendo upload para descobrir onde seu avrdude (utilitário de upload linha de comando) está localizado no seu sistema / versão do Arduino. Alternativamente, você pode olhar para os arquivos de configuração incluídos e usar o seu local de instalação (atualmente no Arduino 0020).

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

Este programa permite automatizado de execução de vários testes de unidade Arduino. O processo de teste é iniciado no PC, mas os testes executados no hardware Arduino real. Um conjunto de testes de unidade é normalmente usada para testar uma biblioteca Arduino. (Este

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

página do projeto GitHub: http://jeroendoggen.github.com/Arduino-TestSuite

Página no Python Package Index: http://pypi.python.org/pypi/arduino_testsuite

Os testes unitários são escritos com o "Arduino Unit Testing Library": http://code.google. com / p / arduinounit

Os seguintes passos são realizados para cada conjunto de testes de unidade:

  • Leia o arquivo de configuração para saber quais testes para executar
  • As compilações de script e uploads um esboço Arduino que contém o código de teste de unidade.
  • Os testes de unidade são executados na placa Arduino.
  • Os resultados do teste são impressos através da porta série e analisadas pelo script Python.
  • O script começa o próximo teste, repetindo os passos acima para todos os testes que são solicitados no arquivo de configuração.
  • O script imprime um resumo mostrando uma visão geral de todos os fracassados ??testes / passavam na testsuite completa.

Mantenha código específico de hardware separado ou abstraído longe do resto para que você possa testar e depurar que maior "descanso" em qualquer plataforma para o qual você tem boas ferramentas e com o qual você está familiarizado mais.

Basicamente, tentar construir o máximo de código final de como muitos conhecidos ao trabalho blocos de construção possível. Os restantes trabalhos específicos de hardware, então, ser muito mais fácil e mais rápido. Você pode terminá-lo usando emuladores existentes e / ou emular dispositivos em seu próprio país. E depois, claro, você vai precisar para testar a coisa real de alguma forma. Dependendo das circunstâncias, que podem ou não estar muito bem automatizável (ou seja, quem ou o que vai pressionar os botões e fornecer outros insumos? Quem ou o que vai observar e interpretar vários indicadores e saídas?).

James W. Grenning escreve grandes livros e este é sobre a unidade de teste de código C incorporado Test Driven Development para incorporado C .

Eu estou usando Searduino ao escrever Arduino código. Searduino é um Arduino simulador e um ambiente de desenvolvimento (código Makefiles, C ...) que o torna fácil de cortar em C / C ++ usando seu editor favorito. Você pode importar Arduino esboços e executá-los no simulador.

Captura de tela de Searduino 0,8: http: // searduino. files.wordpress.com/2014/01/jearduino-0-8.png

Searduino 0.9 será lançado e um vídeo será gravado tão logo a dura testes são feitos .... em um dia ou dois.

Os testes no simulador não deve ser considerado como testes reais, mas certamente me ajudou muito a encontrar erros estúpidos / lógica (esquecendo de fazer pinMode(xx, OUTPUT), etc.).

BTW: Eu sou uma das pessoas que desenvolvem Searduino

.

arduino_ci para esta finalidade. Embora seja limitado a testar bibliotecas Arduino (e desenhos não autónomos), que permite que testes de unidade para ser executado localmente ou em um sistema de IC (como Travis CI ou Appveyor).

Considere uma biblioteca muito simples em seu diretório Arduino Biblioteca, chamado DoSomething, com do-something.cpp: 

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

int doSomething(void) {
  return 4;
};

Você iria teste de unidade que o seguinte (com um arquivo teste chamado test/is_four.cpp ou algo assim): 

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

Isso é tudo. Se essa estrutura de sintaxe assertEqual e teste parece familiar, é porque eu adotei alguns dos biblioteca ArduinoUnit do Matthew Murdoch que se refere o sua resposta .

Consulte Reference.md para obter mais informações sobre os testes de unidade I / o pins, o relógio, portas série, etc.

Estes testes unitários são compilados e executados usando um script contido em uma jóia de rubi. Para exemplos de como configurar isso, veja o README.md ou apenas cópia de um desses exemplos:

Há um projeto chamado ncore , que fornece núcleo nativo para Arduino. E permite testes de gravação para código Arduino.

A partir da descrição do projeto

O núcleo nativo permite que você compilar e executar esboços Arduino no PC, geralmente com nenhuma modificação. Ele fornece versões nativas de funções padrão Arduino, e um interepreter de linha de comando para dar entradas para o seu esboço que normalmente vêm do hardware em si.

Também no "o que eu preciso para usar -o" seção

Se você quiser construir os testes, você vai precisar cxxtest de http://cxxtest.tigris.org . NCORE foi testado com cxxtest 3.10.1.

Se você quiser código-teste de unidade fora MCU (no desktop), confira libcheck: https://libcheck.github.io/check/

Eu usei-o para testar o meu próprio código incorporado algumas vezes. É quadro bastante robusto.

Você pode usar emulare - você pode arrastar e soltar um microcontrolador em um diagrama e executar seu código em Eclipse. A documentação sobre o site diz-lhe como configurá-lo.

Use Proteus VSM com uma biblioteca Arduino para depurar seu código ou para testá-lo.

É uma boa prática antes de começar o seu código a bordo, mas não se esqueça, com horários, porque a simulação não é executado em tempo real, que correm no tabuleiro.

Tente circuito simulador Autodesk . Ele permite testar Arduino código e circuitos com muitos outros componentes de hardware.

Em básica Arduino é escrito com C e C ++, mesmo bibliotecas de arduino são escritos em C e C ++. Assim, em termos simples, apenas lidar com o código como C e C ++ e tente fazer o teste de unidade. Aqui, a palavra "alça" Quer dizer que você mude toda a sintaxe básica como Serial.println para sysout, pinMode para varaibles, void loop para loop while (), que quebras tanto na keystock ou após algum iteração.

Eu sei que isso é pouco um processo longo e não tão reto forward.On minha experiência pessoal, uma vez que você começa a ver com isso, este passa a ser mais confiável.

-Nandha_Frost

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top