Como depurar um esboço do Arduino?

Comecei a codificar para o Arduino muito recentemente. E esses erros no código estão me matando. Como não há depurador de hardware no Arduino, serial.print () é meu único recurso. Quais são os métodos / práticas que você implementa para depurar o código do Arduino?

A modularidade é sua amiga. Escreva seu loop principal para fazer isso chamando funções, que chamam funções, ..., até o nível em que suas funções seriam simples. Comece com o loop principal e o próximo nível abaixo, faça funções de stub; ou vazio:

function foo(){
    ;
}

ou falso:

function read_temperature(){
    return(95);
}

, que não fazem nada além de retornar o que o nível de chamada precisa para que ele possa continuar. Quando esse nível funcionar, desça um nível e comece a preencher um código simples que também chama funções de stub. Remova gradualmente uma função de cada vez até que você tenha um aplicativo em funcionamento.

Para depurar uma função que retorna um valor incorreto ou criar uma sem influência do restante do aplicativo, você pode criar andaimes - um esboço simples que apenas alimenta a função com alguns exemplos de valores e, dentro da função, imprime valores de parâmetros e alguns valores intermediários, até você ter uma ideia de qual parte da função está falhando. Eu até criei funções de falsificação que me pedem no terminal um valor para retornar. (Obviamente, essa técnica só funcionará se o sistema puder tolerar a velocidade relativamente glacial de nós humanos! Outro uso para andaimes.)

O stubbing funciona especialmente bem para substituir as funções que fazem interface com o hardware, permitindo que você inicie o aplicativo antes de mergulhar em folhas de dados, problemas de tempo e outras minúcias (como não ter as peças!) Que, de outra forma, poderiam parar seu progresso.

Falando de problemas de tempo, alternar um pino de saída em um ponto específico do seu programa, como entrada e saída de um ISR, fornece uma onda quadrada no pino do Arduino cuja frequência ou ciclo de trabalho pode fornecer uma visão sobre o tempo interno do seu programa. O formato de porta / E / S direta, por exemplo,

PORTC ^= 0x01;

, distorcerá o tempo menos que a chamada digitalWrite(). Útil se você tiver um escopo acessível, ou um dos DMMs com a capacidade de medir a frequência e / ou o ciclo de trabalho.

Da mesma forma, você pode usar um pino de saída analógica para emitir um valor numérico para o seu medidor de dentro do programa sem atrapalhar muito o tempo ou inchar o código com as funções de E / S seriais. Use os formulários de E / S diretos aqui também.

Uso Serial.print () e faço os LEDs piscarem.

Isso é tudo o que você pode fazer.

Além disso, garanto que o código seja legível e fácil de entender. Divida as coisas em etapas simples e crie funções para cada etapa, para que você possa ver a sequência exata de eventos.

3 Outras técnicas:

• Construa a funcionalidade de um programa testando lentamente a cada estágio, para enfrentar apenas um pequeno conjunto de bugs por vez.

• Crie o programa em torno de um interpretador de comandos para poder trabalhar com seções por vez, como aqui .

• Pulso em momentos significativos e use um escopo.

O plug-in do Visual Micro para o Visual Studio fornece a depuração do Arduino . Inclui rastreamento e quebra de código-fonte, permitindo que expressões e variáveis ​​sejam "monitoradas" e / ou modificadas.

Indo de ferramentas de luxo como ARM ou outras plataformas (AVR, PIC com ferramentas decentes), eu concordo que as instalações de depuração do Arduino são muito limitadas. Mas é uma ferramenta inicial com baixa entrada.

Serial.print () é seu amigo. Para o meu projeto em particular (faculdade), eu não tinha nenhum LED conectado, então Serial.print () é. Se eu quiser testar se o código é executado corretamente através das instruções, geralmente coloco Serial.print ("A"); , indo para B, C, etc. ou algo na seção que estou depurando. Comparo as cartas de depuração com o que espero que deva fazer.

Fora isso, não há pontos de interrupção ou etapa de código. O Arduino nada mais é do que uma placa com um chip AVR atmega, um ambiente de desenvolvimento de bootloader + e uma tonelada de bibliotecas de software. Infelizmente, trabalhar com um carregador de inicialização limita os recursos de depuração.

Para fazer o uso de serial.printmais controlado, você pode definir uma variável booleana global para ativar e desativar a depuração. Quaisquer linhas de serial.printserão agrupadas em uma ifinstrução que será executada apenas se o sinalizador de depuração estiver ativado. Dessa maneira, você pode deixar as linhas de depuração no código mesmo quando terminar, mas certifique-se de definir o sinalizador de depuração como OFF mais tarde.

Melhor do que diretamente serial.print, use macros. Exemplo:

#ifdef TRACE1
#define trace1(s) serial.print(s)
#define traceln1(s) serial.println(s)
#else
#define trace1(s)
#define traceln1(s)
#endif

Use-o assim:

function doIt(param1, param2) {
    trace1("->doIt("); trace1("param1: "); trace1(param1); trace1(" param2: "); trace1(param2); traceln1(")");

    ...

    traceln1("<-doIt");
}

Você pode ter diferentes níveis de rastreio (#ifdef TRACE2 ...)com mais detalhes.

E você pode usar a macro "F" (trace1(F("param1"));),. A macro "F" impede que a cadeia use a quantidade extremamente limitada de SRAM.

Pisque os LEDs, imprima coisas na porta serial e escreva e depure pequenas seções de código de cada vez, às vezes apenas algumas linhas.

Há momentos em que você pode modularizar. Se em C, por exemplo, você pode desenvolver e testar uma função de computação, por exemplo, que não toque no hardware de um computador host ou outro processador, envolva a função com uma bancada de testes para alimentar as entradas e verificar as saídas, etc.

Outra maneira semelhante pode ser o uso de um simulador de conjunto de instruções se você tiver acesso a um (se não, é um projeto muito educativo e gratificante, depois de fazer alguns deles, você pode digitar um em um final de semana ou dois). Ainda melhor se alguém tiver um clone do processador Verilog ou VHDL ( OpenCores, por exemplo), você pode tentar o GHDL, o Verilator ou o Icarus Verilog . Pode estar perto o suficiente para incluir os periféricos de seu interesse e você pode obter visibilidade no nível do sinal do que está acontecendo no interior.

Concedido que provavelmente não é um clone perfeito, mas pode ser bom o suficiente. O Verilator facilita muito a criação de periféricos em C / C ++, para que você possa simular o que quer que esteja conectado ao seu dispositivo AVR.

Saída UART e LEDs piscando e / ou linhas GPIO piscando e usando um osciloscópio ou voltímetro. A chave para não enlouquecer é escrever e depurar pequenas seções de código. É melhor escrever 10 linhas por vez, executar 100 testes que 1000 linhas e tentar depurar todas de uma só vez. Especialmente quando você descobre que a maioria das planilhas de dados e manuais de referência para programadores nem sempre estão corretos. Alguns hackers são sempre necessários.