Como Projetar para Teste em Sistemas Embarcados

| Criada: Outubro 17, 2023 | Atualizada: Julho 1, 2024

Seja projetando uma PCB de alta velocidade ou um sistema embarcado complexo, será necessário algum nível de teste. Para os sistemas avançados de alta velocidade e RF, isso geralmente significa simulações comparadas a medições de VNA ou osciloscópio. Para o software e firmware embarcado, os passos de teste podem ser bastante diferentes. Na verdade, existem algumas coisas que você pode fazer no design do seu protótipo para ajudar a acelerar o processo de teste e eliminar a necessidade de sondar com um multímetro.

Neste artigo, vou mostrar algumas dicas simples que podem tornar o teste e a depuração de um protótipo muito mais fáceis. Isso significa adotar uma abordagem de design voltada para o teste e aplicá-la tanto ao software quanto ao hardware. Aqui vai uma dica: o melhor caminho para o teste de sistemas embarcados envolve mais do que apenas colocar pads de teste ou pontos de teste.

Design Para Teste em Hardware Embarcado

Existem muitos jargões na indústria de PCB, e “design para teste” geralmente é agrupado com o pacote DfX mais amplo. Muitos designers abordam o design para teste de uma placa que executa código embarcado da mesma maneira que abordariam o teste para qualquer outra placa.

Isso geralmente significa que os designers colocarão muitos pontos de teste em sinais importantes, mas talvez não muito mais. Muitos protótipos embarcados começarão a parecer com uma placa de desenvolvimento Arduino, onde tudo o que você pode pensar no processador principal é direcionado para pin headers e pontos de teste.

Não tenho nada contra pin headers em uma placa de sistemas embarcados, ou em qualquer outra placa, nesse caso. Mas, é difícil monitorar todos os sinais e pinos enquanto também tenta testar e depurar software ou firmware executando na placa. Em alguns casos, você tem que escrever um aplicativo apenas para testar seu aplicativo. Às vezes, se você vê um erro nas funções do seu design, pode não ser sempre óbvio se a causa raiz está no seu código ou na sua PCBA.

No lado do hardware, concentre-se em adotar esta abordagem simplificada para o design para teste:

Nem tudo precisa de um pin header. Leve um sinal para um header se você realmente planeja conectá-lo a algo ou se você realmente vai medi-lo.
Coloque conectores que você pode realmente usar. Dessa forma, você poderia conectar a um cartão de aquisição de dados, analisador lógico, osciloscópio, etc.
Deixe o software fazer o teste. Não esqueça que sua aplicação embarcada pode ler sinais de periféricos, o que permite construir casos de teste no seu código.
Você pode olhar os dados na tela, você só precisa de uma conexão com seu PC, como através de uma porta serial, cartão de aquisição de dados ou software proprietário.

Alguns desses conceitos foram bastante discutidos por Ari Mahpour em suas discussões sobre testes e integração contínua. Dê uma olhada neste artigo para aprender mais sobre essa abordagem. Se você quer enviar dados de volta para o seu computador, o método mais simples é adicionar uma interface USB-para-serial ao seu protótipo. Dê uma olhada neste projeto de Zach Peterson e pegue os arquivos de design do link.

testes de sistemas embarcados — *Uma porta serial acessível via USB é muito útil para visualizar dados da sua PCB embarcada.*

Casos de Teste em Software Embarcado

A seguir, se você está executando uma aplicação embarcada no seu sistema, então você pode incluir tratamento de erros ou casos de teste no código para ajudar a acelerar os testes. Adicionar as conexões a interfaces com cabeçalhos, almofadas de teste e uma interface serial básica são todos passos importantes que ajudam você a monitorar sua placa embarcada em tempo real. O objetivo é ver como a aplicação de software se comporta juntamente com o hardware.

Então, como você pode monitorar o progresso da sua aplicação e hardware simultaneamente? Siga a dica dos desenvolvedores de software: adicione tratamento de erros e mensagens para exibir o status de cada função na sua aplicação. Isso pode ser tão simples quanto exibir mensagens indicando se funções importantes foram aprovadas ou falharam na aplicação. Leva um tempo extra para escrever todas essas verificações de erro, ter uma mensagem na tela indicando o que seu sistema está fazendo durante a execução da aplicação pode eliminar uma tonelada de depuração.

Aqui está um exemplo que mostra como isso seria implementado em C/C++ usando uma função simples (chamada myFunction()) e uma biblioteca GPIO hipotética. Vamos supor que você esteja trabalhando com uma plataforma que fornece uma biblioteca GPIO simples com funções como gpio_init(), gpio_read(), etc.:

#include
#include // para std::runtime_error
// Biblioteca hipotética de GPIO

namespace GPIO {
void init(int pin) {
        // Inicializa o pino dado como entrada
        // Esta função é específica da plataforma
    }

bool read(int pin) {
// Lê o valor do pino dado (ALTO ou BAIXO)
// Retorna verdadeiro se ALTO, falso se BAIXO
        // Esta função é específica da plataforma
        return false; // Placeholder, dependerá do hardware real
    }
}

int main() {
    const int GPIO_PIN = 5; // Número do pino para leitura GPIO (escolha de acordo com sua configuração)
    GPIO::init(GPIO_PIN);
    double a = 10.0, b = 2.0;

    // Se o sinal GPIO for ALTO, define b como zero
    if(GPIO::read(GPIO_PIN)) {
        b = 0.0;
    }
    try {
        double result = myFunction(a, b);
        std::cout << "Resultado: " << result << std::endl;
    }
    catch(const std::exception& e) { // Captura exceções do tipo std::exception
        std::cerr << "Erro: " << e.what() << std::endl; // Exibe a mensagem de erro
    }
    catch(...) { // Manipulador para outras exceções
        std::cerr << "Ocorreu um erro desconhecido!" << std::endl;
    }
    return 0;
}

Se sua aplicação está monitorando sinais diretamente, ela pode imprimir esses resultados a cada etapa em suas funções principais. Imprimir isso na tela junto com seus sinais indicadores chave dirá exatamente o que está acontecendo à medida que sua aplicação progride, e você não precisará medir manualmente cada sinal em sua placa com uma unidade externa. Claro, isso requer a roteirização de alguns traços extras para os GPIOs ao projetar a placa, mas você pode descobrir que um aparente erro de lógica era realmente apenas um simples erro de conexão em seu PCB.

Não se esqueça, você ainda pode levar quaisquer outros sinais que precisem ir para uma sonda até um cabeçalho. Desta forma, esses sinais ainda podem ser medidos com um osciloscópio ou um cartão de aquisição de dados. Enquanto isso, a porta serial fará muito do trabalho de ajudá-lo a interagir com a lógica da sua aplicação.

Não importa o que você queira projetar, você pode implementar práticas inovadoras de design para teste usando o conjunto completo de recursos de design de PCB em Altium Designer®. Para implementar a colaboração no ambiente interdisciplinar de hoje, empresas inovadoras estão usando a plataforma Altium 365™ para compartilhar facilmente dados de design e colocar projetos em fabricação.

Apenas arranhamos a superfície do que é possível com Altium Designer no Altium 365. Comece sua avaliação gratuita do Altium Designer + Altium 365 hoje.

Sobre o autor

Alexsander joined Altium as a Technical Marketing Engineer and brings years of engineering expertise to the team. His passion for electronics design combined with his practical business experience provides a unique perspective to the marketing team at Altium. Alexsander graduated from one of the top 20 universities in the world at UCSD where he earned a Bachelor’s degree in Electrical Engineering.

Mais conteúdo por Alexsander Tamari