Eu gostaria de poder testar meu código do Arduino. Idealmente, eu seria capaz de executar qualquer teste sem precisar fazer o upload do código no Arduino. Quais ferramentas ou bibliotecas podem me ajudar com isso?

Existe um emulador do Arduino em desenvolvimento que pode ser útil, mas ainda não parece estar pronto para uso.

O AVR Studio da Atmel contém um simulador de chip que pode ser útil, mas não vejo como o utilizaria em conjunto com o Arduino IDE.

Não execute testes de unidade no dispositivo ou emulador do Arduino

O caso contra o microcontrolador Device / Emulator / Sim-based test

Há muita discussão sobre o que significa teste de unidade e não estou tentando argumentar sobre isso aqui. Esta publicação não está lhe dizendo para evitar todos os testes práticos no seu hardware de destino final. Estou tentando enfatizar a otimização do seu ciclo de feedback de desenvolvimento, eliminando o hardware de destino dos testes mais comuns e mundanos. As unidades em teste são consideradas muito menores que o projeto inteiro.

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

Pense da seguinte maneira: mesmo se você testasse a funcionalidade da biblioteca do Arduino, do hardware do microcontrolador ou de um emulador, é absolutamente impossível que esses resultados de teste lhe digam algo sobre a qualidade do seu próprio trabalho. Portanto, é muito mais valioso e eficiente escrever testes de unidade que não são executados no dispositivo de destino (ou emulador).

Os testes frequentes no hardware de destino têm um ciclo dolorosamente lento:

1. Ajuste seu código
2. Compilar e fazer upload para o dispositivo Arduino
3. Observe o comportamento e adivinhe se seu código está fazendo o que você espera
4. Repetir

A Etapa 3 é particularmente desagradável se você espera receber mensagens de diagnóstico via porta serial, mas seu projeto precisa usar a única porta serial de hardware do Arduino. Se você estava pensando que a biblioteca SoftwareSerial pode ajudar, você deve saber que isso pode atrapalhar qualquer funcionalidade que exija tempo preciso, como gerar outros sinais ao mesmo tempo. Este problema aconteceu comigo.

Novamente, se você testasse seu esboço usando um emulador e suas rotinas com tempo crítico funcionassem perfeitamente até você fazer o upload para o Arduino real, a única lição que você aprenderá é que o emulador é defeituoso - e sabendo disso ainda não revela nada sobre a qualidade do seu próprio trabalho.

Se for tolo testar no dispositivo ou emulador, o que devo fazer?

Você provavelmente está usando um computador para trabalhar no seu projeto do Arduino. Esse computador é uma ordem de grandeza mais rápida que o microcontrolador. Escreva os testes para criar e executar no seu computador .

Lembre-se de que o comportamento da biblioteca e do microcontrolador do Arduino deve ser considerado correto ou pelo menos consistentemente incorreto .

Quando seus testes produzem resultados contrários às suas expectativas, você provavelmente tem uma falha no seu código que foi testada. Se a saída do seu teste corresponder às suas expectativas, mas o programa não se comportar corretamente quando você o enviar para o Arduino, você saberá que seus testes foram baseados em suposições incorretas e é provável que você tenha um teste defeituoso. Em ambos os casos, você terá informações reais sobre quais devem ser suas próximas alterações de código. A qualidade dos seus comentários foi aprimorada de " algo está quebrado" para "esse código específico está quebrado" .

Como criar e executar testes no seu PC

A primeira coisa que você precisa fazer é identificar suas metas de teste . Pense em quais partes do seu próprio código você deseja testar e, em seguida, certifique-se de construir seu programa de forma que você possa isolar partes discretas para teste.

Se as peças que você deseja testar chamarem alguma função do Arduino, será necessário fornecer substituições de maquete em seu programa de teste. Isso é muito menos trabalho do que parece. Suas maquetes não precisam fazer nada além de fornecer entradas e saídas previsíveis para seus testes.

Qualquer código seu que você pretenda testar precisa existir em arquivos de origem que não sejam o esboço .pde. Não se preocupe, seu esboço ainda será compilado, mesmo com algum código-fonte fora dele. Quando você realmente faz isso, pouco mais do que o ponto de entrada normal do seu programa deve ser definido no arquivo de esboço.

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

Um exemplo de trabalho real

Um dos meus projetos de estimação encontrados aqui tem alguns testes simples que são executados no PC. Para enviar esta resposta, mostrarei como simulei algumas das funções da biblioteca do Arduino e os testes que escrevi para testar essas maquetes. Isso não é contrário ao que eu disse antes sobre não testar o código de outras pessoas, porque fui eu quem escreveu os modelos. Eu queria ter certeza de que minhas maquetes estavam corretas.

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

Uso o seguinte modelo para produzir uma saída legível quando meu código grava dados binários no dispositivo serial de 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();
}

Como este post é longo o suficiente, consulte o meu projeto no GitHub para ver mais casos de teste em ação. Eu mantenho meus trabalhos em andamento em ramos que não sejam mestre, portanto verifique esses ramos para testes extras também.

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

Na ausência de estruturas de teste de unidade pré-existentes para o Arduino, criei o ArduinoUnit . Aqui está um esboço simples do Arduino 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();
}

Tenho um sucesso considerável ao testar meu código PIC, abstraindo o acesso ao hardware e zombando dele em meus testes.

Por exemplo, eu abstraio PORTA com

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

Em seguida, o SetPortA pode ser facilmente zombado, sem adicionar código adicional na versão PIC.

Depois que a abstração de hardware é testada há algum tempo, logo percebo que geralmente o código vai do equipamento de teste ao PIC e funciona pela primeira vez.

Atualizar:

Uso uma costura #include para o código da unidade, #incluindo o código da unidade em um arquivo C ++ para a plataforma de teste e um arquivo C para o código de destino.

Como exemplo, quero multiplexar quatro displays de 7 segmentos, uma porta direcionando os segmentos e uma segunda selecionando o display. O código do display faz interface com os displays via SetSegmentData(char)e SetDisplay(char). Eu posso zombar deles no meu equipamento de teste C ++ e verificar se recebo os dados que espero. Para o destino que uso #definepara obter uma atribuição direta sem a sobrecarga de uma chamada de função

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

Parece que emulino faria o trabalho perfeitamente.

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

Repositório do GitHub

O simavr é um simulador de AVR usando o avr-gcc.

Ele já suporta alguns microcontroladores ATTiny e ATMega e, segundo o autor, é fácil adicionar um pouco mais.

Nos exemplos está o simduino, um emulador do Arduino. Ele suporta a execução do gerenciador de inicialização Arduino e pode ser programado com avrdude através do Socat (um Netcat modificado ).

Você pode testar a unidade em Python com meu projeto, PySimAVR . Arscons é usado para construção e simavr para 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'

Iniciar teste:

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

Não conheço nenhuma plataforma que possa testar o código do Arduino.

No entanto, existe a plataforma Fritzing , que você pode usar para modelar o hardware e, posteriormente, exportar diagramas de PCB e outras coisas.

Vale a pena conferir.

Estamos usando placas Arduino para aquisição de dados em um grande experimento científico. Posteriormente, temos que suportar várias placas Arduino com diferentes implementações. Eu escrevi utilitários Python para carregar dinamicamente imagens hexadecimais do Arduino durante o teste de unidade. O código encontrado no link abaixo suporta Windows e Mac OS X através de um arquivo de configuração. Para descobrir onde suas imagens hexadecimais são colocadas pelo Arduino IDE, pressione a tecla Shift antes de pressionar o botão de compilação (reprodução). Pressione a tecla Shift enquanto pressiona o upload para descobrir onde o seu avrdude (utilitário de upload da linha de comando) está localizado no seu sistema / versão do Arduino. Como alternativa, você pode ver os arquivos de configuração incluídos e usar o local de instalação (atualmente no Arduino 0020).

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

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

Fórum do Arduino: http://arduino.cc/forum/index.php?topic=140027.0

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

Página no índice do pacote Python: http://pypi.python.org/pypi/arduino_testsuite

Os testes de unidade são gravados com a "Biblioteca de testes de unidade do Arduino": http://code.google.com/p/arduinounit

As etapas a seguir são executadas para cada conjunto de testes de unidade:

• Leia o arquivo de configuração para descobrir quais testes executar
• O script compila e carrega um esboço do Arduino que contém o código de teste da unidade.
• Os testes de unidade são executados na placa Arduino.
• Os resultados do teste são impressos na porta serial e analisados ​​pelo script Python.
• O script inicia o próximo teste, repetindo as etapas acima para todos os testes solicitados no arquivo de configuração.
• O script imprime um resumo mostrando uma visão geral de todos os testes que falharam / passaram no teste completo.

Mantenha o código específico do hardware separado ou abstrato do resto para poder testar e depurar esse "resto" maior em qualquer plataforma para a qual você tenha boas ferramentas e com a qual você esteja mais familiarizado.

Basicamente, tente criar o máximo do código final a partir do maior número possível de blocos de construção conhecidos. O restante trabalho específico do hardware será muito mais fácil e rápido. Você pode finalizá-lo usando emuladores existentes e / ou dispositivos de emulação por conta própria. E então, é claro, você precisará testar a coisa real de alguma forma. Dependendo das circunstâncias, isso pode ou não ser muito bem automatizável (ou seja, quem ou o que pressionará os botões e fornecerá outras entradas? Quem ou o que 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 .

Estou usando o Searduino ao escrever o código do Arduino. O Searduino é um simulador do Arduino e um ambiente de desenvolvimento (Makefiles, código C ...) que facilita o hack no C / C ++ usando o seu editor favorito. Você pode importar esboços do Arduino e executá-los no simulador.

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

O Searduino 0.9 será lançado e um vídeo será gravado assim que os últimos testes forem concluídos ... em um dia ou dois.

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

BTW: Eu sou uma das pessoas que desenvolvem o Searduino.

Eu construí arduino_cipara esse fim. Embora seja limitado ao teste de bibliotecas do Arduino (e não de esboços independentes), ele permite que os testes de unidade sejam executados localmente ou em um sistema de CI (como Travis CI ou Appveyor).

Considere uma biblioteca muito simples no diretório Arduino Library, chamada DoSomething, com do-something.cpp:

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

int doSomething(void) {
  return 4;
};

Você testaria a unidade da seguinte maneira (com um arquivo de teste chamado test/is_four.cppou algo parecido):

#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 assertEqualestrutura de sintaxe e teste parece familiar, é porque eu adotei parte da biblioteca ArduinoUnit de Matthew Murdoch a que ele se referiu em sua resposta .

Consulte o Reference.md para obter mais informações sobre os testes de unidade dos pinos de E / S, o relógio, as portas seriais etc.

Esses testes de unidade são compilados e executados usando um script contido em uma gema de rubi. Para exemplos de como configurar isso, consulte o arquivo README.md ou copie de um destes exemplos:

• Um exemplo prático, testando uma implementação de Fila
• Outro conjunto de testes em outro projeto de Fila
• Um exemplo complexo, simulando uma biblioteca que controla um dispositivo interativo por uma conexão SoftwareSerial como parte da biblioteca Adafruit FONA
• A biblioteca de exemplo DoSomething mostrada acima, usada para testar o próprio arduino_ci

Existe um projeto chamado ncore , que fornece núcleo nativo para o Arduino. E permite que você escreva testes para o código do Arduino.

A partir da descrição do projeto

O núcleo nativo permite compilar e executar esboços do Arduino no PC, geralmente sem modificações. Ele fornece versões nativas das funções padrão do Arduino e um interepretor de linha de comando para fornecer entradas ao seu esboço que normalmente viriam do próprio hardware.

Também na seção "o que eu preciso para usá-lo"

Se você deseja criar os testes, precisará do cxxtest em http://cxxtest.tigris.org . O NCORE foi testado com o cxxtest 3.10.1.

Se você quiser testar o código de unidade fora do MCU (na área de trabalho), consulte libcheck: https://libcheck.github.io/check/

Usei-o para testar meu próprio código incorporado algumas vezes. É uma estrutura bastante robusta.

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

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

É uma prática recomendada antes de integrar seu código, mas certifique-se dos intervalos, pois a simulação não é executada em tempo real, como é feita no quadro.

Experimente o simulador de circuitos da Autodesk . Permite testar o código e os circuitos do Arduino com muitos outros componentes de hardware.

No básico, o Arduino é escrito com C e C ++, até as bibliotecas do arduino são escritas em C e C ++. Portanto, em termos simples, manipule o código como C e C ++ e tente fazer o teste de unidade. Aqui, com a palavra "handle", quero dizer que você altere toda a sintaxe básica como serial.println para sysout, pinmode para varaibles, void loop para while () loop que quebra no keytock ou após alguma iteração.

Sei que este é um processo um pouco longo e não é tão direto. Na minha experiência pessoal, quando você o faz, isso se torna mais confiável.

-Nandha_Frost

Caso você esteja interessado em executar um esboço INO e fazer check-out da saída serial, eu tenho uma implementação funcional disso no meu projeto de soma de verificação Arduino NMEA .

O script a seguir pega o arquivo e usa a CLI do Arduino para compilá-lo em um arquivo HEX que é carregado no SimAVR que o avalia e imprime a saída serial. Como todos os programas do Arduino são executados para sempre sem realmente ter a opção de se matar ( exit(0)não funciona), deixo o rascunho por alguns segundos e depois difiro a saída capturada com a saída esperada.

Faça o download e extraia a CLI do Arduino (neste caso, versão 0.5.0 - mais recente no momento da redação):

curl -L https://github.com/arduino/arduino-cli/releases/download/0.5.0/arduino-cli_0.5.0_Linux_64bit.tar.gz -o arduino-cli.tar.gz
tar -xvzf arduino-cli.tar.gz

Agora você pode atualizar o índice e instalar o núcleo apropriado:

./arduino-cli core update-index
./arduino-cli core install arduino:avr

Supondo que seu esboço seja nomeado nmea-checksum.ino, para obter ELF e HEX, execute:

./arduino-cli compile -b arduino:avr:uno nmea-checksum.ino

Em seguida, o SimAVR para executar o HEX (ou ELF) - eu construo a partir do código-fonte porque a versão mais recente não funcionou para mim:

sudo apt-get update
sudo apt-get install -y build-essential libelf-dev avr-libc gcc-avr freeglut3-dev libncurses5-dev pkg-config
git clone https://github.com/buserror/simavr.git
cd simavr
make

A compilação bem-sucedida fornecerá o simavr/run_avrque você pode usar para executar o esboço. Como eu disse, timeoutcaso contrário, nunca terminará:

cd simavr
timeout 10 ./run_avr -m atmega168 -f 16000000 ../../nmea-checksum.ino.arduino.avr.uno.elf &> nmea-checksum.ino.clog || true

O arquivo gerado terá caracteres de controle de código de cores ANSI envolvendo a saída serial, para se livrar deles:

cat nmea-checksum.ino.clog | sed -r "s/\x1B\[([0-9]{1,2}(;[0-9]{1,2})?)?[mGK]//g" > nmea-checksum.ino.log
cat nmea-checksum.ino.log

Agora, tudo o que você precisa fazer é comparar esse arquivo com um arquivo conhecido:

diff nmea-checksum.ino.log ../../nmea-checksum.ino.test

Se não houver diferenças, diffsairá com o código 0, caso contrário, o script falhará.