Como posso testar o código do Arduino?

187

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.

Matthew Murdoch
fonte
Há outra discussão sobre esta questão a partir de 2011 em arduino.cc/forum/index.php?action=printpage;topic=54356.0
Jakob
Obrigado @Jakob. Um simulador do Arduino mencionado nesse segmento (com outros links potencialmente úteis na parte inferior da página): arduino.com.au/Simulator-for-Arduino.html
Matthew Murdoch
5
Infelizmente, é apenas para Windows, gostaria de ver uma maneira de simplesmente compilar e executar o código do Arduino a partir da linha de comando, sem nenhuma dependência de fonte ou hardware fechada.
Jakob
3
Uma pequena atualização, cinco anos depois: o Simavr ainda está muito ativo e melhorou muito desde que a pergunta foi feita, então eu pensei que merecia ser esbarrado mais perto do topo. E pode ser a ferramenta certa para testes de regressão, testes baseados em cenário e por que não também testes de unidade. Dessa forma, o código testado é o mesmo do hardware de destino.
Zmo 29/05
Para projetos importantes, considere um testador de hardware; outro MCU que pode cronometrar e testar reações de botão / chave, tempo de inicialização, temperatura, uso de v / ma, permutações de opções estranhas etc. Sim, é mais hardware para construir, mas pode adicionar uma camada de segurança à revisão. muitos dispositivos profissionais usam jtag et al.
dandavis

Respostas:

137

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.

Salvador de Ferro
fonte
1
Esta é uma ótima resposta! Obrigado!
Jonathan Arkell
5
@WarrenMacEvoy Novamente, acho que você aceitou meu conselho e transformou em algo que não é. Você certamente deve testar seu código em seu ambiente real EM ALGUM PONTO. Meu argumento é que você não deve fazer isso todos os dias e certamente não deve chamá-lo de teste de unidade.
Iron Savior
1
@toasted_flakes Não tenho certeza de onde você conseguiu essa citação, mas não é algo que eu disse. Os testes de unidade em execução no dispositivo têm muitos problemas - loop de feedback muito lento, talvez você não tenha nenhuma porta serial ou qualquer outro meio de E / S no seu dispositivo de destino e eles têm uma capacidade muito limitada que pode afetar o escopo do sua suíte de teste.
Iron Savior
1
@ChristianHujer Você certamente deve testar em hardware real - ninguém está dizendo que você nunca deve testar em hardware de destino. Meu post é sobre como apertar o seu ciclo de feedback diário de desenvolvimento com testes de unidade em sua máquina de desenvolvimento. Sua sobrecarga de teste é minimizada dessa maneira, porque você só testará no hardware de destino quando for necessário.
Iron Saviev
1
@Benjohn Os arquivos-fonte de esboço do Arduino costumavam ter a extensão "pde", mesmo sendo C ++. arduino.cc/en/Guide/Environment#toc1
Iron Saviour
63

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();
}
Matthew Murdoch
fonte
18
Os testes parecem ser executados apenas no arduino, portanto você não pode executá-los automaticamente na sua máquina de desenvolvimento. A idéia básica dos testes de unidade é executá-los automaticamente, para que o projeto atual pareça ser mais uma ferramenta de depuração, mas não uma estrutura real de teste de unidade.
Jakob
1
Você está certo. Para poder executá-los em um PC, além disso, seria necessário um emulador Arduino ou AVR. Não há uma camada real de abstração de hardware nas bibliotecas do Arduino (no momento) e nos emuladores do AVR, quando olhei, ainda estavam em desenvolvimento. Se as coisas mudaram agora, em princípio, isso poderia ser feito.
Matthew Murdoch
12
@MatthewMurdoch Receio que você esteja incorreto. Por definição, os testes de unidade nunca são executados no ambiente de destino. De fato, a própria idéia por trás do teste de unidade é eliminar completamente o ambiente de destino do teste. Eles sempre são executados em um ambiente de laboratório que zomba de toda a atividade externa à unidade sendo testada, a fim de garantir que o sucesso ou a falha do teste reflita APENAS na unidade em teste. Essa é uma das maiores razões pelas quais as pessoas usam o conceito de Inversão de controle em projetos complexos.
Iron Savior
2
@ marcv81 As áreas em que existem esses problemas de portabilidade provavelmente serão um sujeito pobre para testes de unidade. Lembre-se de que os testes de unidade devem testar apenas SEU código, portanto, limite seu escopo de acordo. Com a grande disparidade de hardware que estamos falando aqui, posso aceitar que algumas dessas circunstâncias podem ser inevitáveis. Nesses casos, um engenheiro deve permanecer consciente e tomar medidas atenuantes. Isso pode significar alterar seu design para melhorar a testabilidade ou até algo tão simples quanto apenas documentar os fatos relevantes.
Iron Savior
2
@Iron Savior um teste de unidade testa seu código, mas seu código é executado em algum lugar. Se esse contexto é ou emula um contexto do Arduino; o ArdunoUnit o ajudará a escrever testes de unidade. Se você observar o projeto ArduinoUnit, o meta-teste da estrutura carrega, executa e verifica automaticamente os resultados do teste no destino de plataforma cruzada. Assim como você faria em outros destinos de plataforma cruzada. Seu ponto de vista é uma desculpa para não testar código em um ambiente incorporado, onde a correção é tão importante, se não muitas vezes mais, quanto outros contextos.
Warren MacEvoy
21

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;}
David Sykes
fonte
Eu posso ver, em princípio, como posso usar a costura do pré-processador para testes de unidade. No entanto, eu não sei como eu posso fazer isso sem ter um emulador no qual executar os ensaios ou um compilador compatível avr-gcc que saídas (no meu caso) binários do Windows ...
Matthew Murdoch
Obrigado pela atualização. Você executa os testes de unidade no PIC ou no seu PC?
27415 Matthew Murdoch
Os testes de unidade são executados em um Mac usando o Xcode. Para executá-los no Pic provavelmente seria necessário algum tipo de emulador. Abstraindo-lo para que ele funcione no Mac faz processadores de comutação muito easieer
David Sykes
O ambiente do Arduino usa o compilador avr-gcc, que possui algumas idiossincrasias, o que significa que compilar com o gcc (ou outro compilador C ++) e rodar em um PC pode não significar que o código também será compilado no avr-gcc.
Matthew Murdoch
De que tipo de diferença você está falando? São coisas que não podem ser tratadas com algumas diretivas de pré-processador?
Joseph Lisee
15

Parece que emulino faria o trabalho perfeitamente.

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

Repositório do GitHub

Gonzo
fonte
12

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

Gonzo
fonte
9

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
pónei
fonte
6

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.

Yuval Adam
fonte
6

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

toddstavish
fonte
+1 Ótimas coisas! Você tem alguma informação sobre como você testou sua unidade após o upload das imagens?
Matthew Murdoch
Usamos testes nos para executar nossos testes de unidade no lado do python. A configuração de cada teste carrega a imagem hexadecimal correta para esse teste. Começamos pequenos e depois trabalhamos em testes mais abrangentes. Verifique se a comunicação serial está funcionando, verifique se a integração serial à interface do usuário está funcionando, verifique a integração serial ao banco de dados, etc. O analog_read_speed pde e py mostram o básico disso (consulte o link do github acima). Eventualmente, abriremos o código inteiro do projeto, portanto, fique atento. :)
toddstavish
6

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.
jeroendoggen
fonte
5

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?).

Alexey Frunze
fonte
5

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.

user3183814
fonte
5

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:

Ian
fonte
Parece interessante, mas não tenho certeza se está testando corretamente o código do Arduino. A partir da saída que você postou, está compilando a arquitetura x86_64, que obviamente não é usada para o Arduino. Isso pode introduzir bugs causados ​​por conflitos entre implementações de tipo.
Cerin
Esse tipo de bug é certamente possível. Você tem um exemplo que eu poderia usar para um caso de teste?
31418 Ian
3

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.

Sudar
fonte
Este é um projeto interessante. Infelizmente, parece que agora está morto, pois não há progresso há 6 anos.
Cerin
2

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.

ezaquarii
fonte
A única desvantagem é que isso não suporta o g ++, o que o torna inútil para testar a maioria das bibliotecas do Arduino que usam recursos do C ++.
Cerin
1

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.

Imre
fonte
1

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.

sathish
fonte
1

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

Sidhant Goyal
fonte
0

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

Nandha Frost
fonte
0

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

Tomáš Hübelbauer
fonte