Gravação de software incorporado sem hardware

8

Considere que a equipe de hardware levará 2 meses para desenvolver algum hardware, mas a essa altura eu precisarei ter o software pronto.

Minha pergunta é: como posso escrever o software e testá-lo sem o hardware?

Existe algum padrão a ser seguido? Como você faz isso?

anishkumar
fonte
Dependendo da complexidade do hardware, você pode tentar um simulador. Isso é possível se for apenas um microcontrolador com periféricos simples. Mais do que isso e você está sem sorte nessa rota.
mastro
6
Tente encontrar placas de desenvolvimento para o micro e quaisquer outros dispositivos periféricos que você estiver usando e tente conectá-los de uma maneira que mais se assemelhe ao design da sua equipe de hardware. Ele será grande e feio, mas você deve ser capaz de montar um sistema que está perto o suficiente para a coisa real - pelo menos tanto quanto o seu firmware pode dizer ...
brhans
Na pior das hipóteses, se você não conseguir simular adequadamente o hardware, tenha uma maneira de desativá-lo. Apenas algumas semanas atrás, eu queria testar a comunicação em rede com outro programa, apenas para descobrir que sim, exit()porque tentou mapear endereços codificados em / dev / mem.
Isanae
1
Na verdade, é preferível, em muitos casos, usar um simulador para desenvolvimento de software incorporado - muito mais fácil de depurar. O problema, é claro, é que você precisa de um simulador decente. Às vezes, há um genérico que pode ser adaptado; às vezes, um estagiário inteligente pode escrever um em um frenesi de código alimentado a cafeína.
Hot Licks

Respostas:

34

Não há hardware durante os estágios iniciais do desenvolvimento do firmware. Estratégias comuns para lidar com isso são:

  1. Passe um tempo planejando a arquitetura do sistema com cuidado antes de escrever qualquer código. É claro que você deve fazer isso de qualquer maneira, mas, neste caso, é ainda mais importante que o normal. É muito mais fácil depurar um software bem pensado do que uma bagunça baseada em massas.

  2. Modular adequadamente tudo, minimizando as interfaces entre os módulos. Isso ajudará a conter erros nos módulos individuais e permitirá testes mais fáceis dos módulos individuais.

  3. Escreva código de baixo para cima, os drivers que tocam no hardware são os primeiros, a lógica de aplicativos de alto nível, por último. Isso permite descobrir os inconvenientes impostos pela arquitetura desde o início. Não tenha medo de alterar a arquitetura à medida que as realidades do hardware aparecerem, mas verifique se toda a documentação está atualizada de acordo.

  4. Simular. A maioria das empresas de microcontroladores fornece simuladores de software de seus microcontroladores. Isso só pode ir tão longe, mas ainda pode ser muito útil. Simular as entradas e medir as saídas do hardware pode ser difícil, mas verificar a lógica de nível superior dessa maneira não deve ser muito difícil.

    É aqui que o design modular ajuda novamente. Se você não conseguir simular razoavelmente algumas interações de hardware de baixo nível, use uma versão diferente do módulo que toca esse hardware, mas que passa suas próprias ações simuladas para os níveis superiores. Os níveis superiores não saberão que isso está acontecendo. Você não estará verificando o módulo de baixo nível dessa maneira, mas quase todo o resto.

Em resumo, use boas práticas de criação de software, o que, é claro, você deveria fazer de qualquer maneira.

Olin Lathrop
fonte
Gostaria de acrescentar: obtenha placas de desenvolvimento (sim, múltiplas, porque você provavelmente matará pelo menos uma ...) no mais rápido possível e instale os drivers de baixo nível. Teste de unidade o máximo possível do seu código. Sim, você pode unir o código que toca no hardware. Não, você não pode simular completamente o hardware, mas pode corrigir 90% da funcionalidade antes mesmo de piscar pela primeira vez. Fiz tudo isso em um projeto recente e tínhamos 99% de funcionalidade e trabalhando quando o hardware real chegou. Era magnífico.
precisa saber é o seguinte
13

Sem nenhuma ideia do que você está desenvolvendo ou em qual família de microcontroladores seu hardware se baseará, a maioria das famílias de microcontroladores possui sistemas de desenvolvimento de baixo custo disponíveis que possuem um conjunto de periféricos comuns, o que pode permitir que você simule pelo menos parte do seu hardware de destino final.

Techydude
fonte
1
Acordado. Eu diria isso com mais força. Em uma situação como essa em que o software precisa ser finalizado ao mesmo tempo que o hardware, eu usaria apenas um microcontrolador que tivesse uma placa de desenvolvimento ou avaliação adequada.
585 Steve Steve G
Mesmo que você tenha entendido o que o OP está desenvolvendo, a maioria das famílias de microcontroladores ainda tem simuladores disponíveis.
Olin Lathrop
Eu uso os dois métodos. No entanto, também mantenho um olho no equipamento de teste da linha de produção necessário. Você pode se reunir com os engenheiros de produção e projetar o hardware para testar seus drivers, que podem fazer parte dos testes de produção. Se você tiver sorte, eles podem até criar hardware para uma placa / protótipo de desenvolvimento, para que eles também estejam à frente do processo. Tudo se resume a como você lança o pedido de ajuda ... #
713 Colher
Esta é a melhor resposta para essa pergunta, pois eu sempre tenho uma placa de desenvolvimento para programar as principais funcionalidades antes de tentar no PCB.
Lucas92
2

Dependendo da dependência do hardware do aplicativo, você pode começar a implementar o projeto em um PC padrão (Windows, Linux ...). A maioria dos acessos periféricos deve ser abstraída de qualquer maneira, portanto, não é muito importante implementar algumas funções fictícias, que serão substituídas mais tarde. Se não for possível simular algum comportamento, você pode pelo menos fazer uma maquete do sistema (API ...), para que a implementação real seja muito mais rápida e clara, assim que o hardware estiver pronto.

É claro que existem muitas coisas que não podem ser simuladas, como comportamento em tempo real ou drivers de hardware complexos. Por outro lado, um ADC controlado por interrupção pode ser facilmente simulado usando um encadeamento que lê valores de um arquivo ou de uma porta de rede.

Claro que tudo isso depende muito de vários fatores:

  • Você pode usar a mesma cadeia de ferramentas / similar no controlador e no PC (por exemplo, gcc)?
  • Quão dependente de hardware é o sistema?
  • Qual é a sua experiência com programação para PC?

Eu, por exemplo, estou projetando praticamente todos os módulos de firmware em um PC primeiro.

erebos
fonte
O mesmo aqui. Algumas diferenças entre compiladores (intrínsecos, palavras-chave especiais, SO de código fechado e pilha de rede não muito compatíveis com BSD) e bugs (com C ++) forçam o uso intenso de arquivos e pré-processadores pré-incluídos e específicos de arquivos, mas o próprio código pode ser quase idêntico entre o DSP e PC. Para a versão PC, posso usar a verificação de erros em tempo de execução forte e pesado (CodeGuard) e seus recursos de depuração não podem ser comparados em plataformas incorporadas. Bônus adicional é que eu posso ter alguns dispositivos virtuais extras para qualquer rede e teste de carga.
TMSZ
Com a disponibilidade do Raspberry Pi e do BeagleBone, seu ambiente de desenvolvimento pode ser facilmente o seu ambiente de tempo de execução - sem problemas com a cadeia de ferramentas, etc. Além disso, você pode usar valgrind / helgrind, gdb, etc.
jhfrontz
1

Tente obter um simulador para o seu chip. Você deve simular todas as entradas esperadas e algumas inesperadas também. Modularize / abstraia o máximo que puder e escreva testes de unidade. Se você puder, esses testes podem se tornar parte do seu código real e se transformarem em um recurso (autoteste da placa).

Se você não pode obter um simulador, abstraia o máximo possível através de um HAL (camada de abstração de hardware). Todos os motoristas ficam atrás. Tente abstrair todo o conjunto específico da plataforma por trás de alguma chamada de função C e pense neles também como drivers. Escreva o restante como código C / C ++ portátil, faça um HAL fino para x86 e execute-o em sua máquina com todos os casos de teste.

Dessa forma, quando você obtiver o hardware, precisará apenas depurar o HAL. Quanto mais fino, mais rápido você o depurará e terá tudo funcionando. Lembre-se que se você usar específico da plataforma de montagem para ops mais rápidos, você quer MUITO para obter testes bit-exato .

Ronan Paixão
fonte
A precisão dos bits é especialmente importante se você usar DSP de ponto fixo.
Ronan Paixão
Pode ou não se aplicar a um caso específico, mas, em geral, a exatidão dos bits tem seu preço. O QEMU recentemente (2 anos atrás) decidiu implementar a FPU com bit exato, e adivinha o que aconteceu com o desempenho ?
Dmitry Grigoryev
A precisão dos bits não é muito importante ao usar uma FPU. É extremamente importante se você usar ponto fixo, no entanto. Especialmente porque o ponto fixo do software precisa de verificações extras em qualquer lugar.
Ronan Paixão
O que é resultado de práticas inadequadas de codificação. As pessoas aprenderam a tomar precauções ao usar a == bcomparações com carros alegóricos, mas ainda as usam sem pensar com números de pontos fixos.
Dmitry Grigoryev
Embora práticas ruins de codificação sejam um problema, existem muitos outros problemas, especialmente em casos extremos. Os transbordamentos vêm à mente rapidamente, assim como perda de precisão , arredondamento , saturação e largura versus deslocamento de bits . Com tudo isso, é fácil ignorar algumas perdas de precisão em casos de teste comuns. O problema é quando seu aplicativo alcança casos menores e os erros passam dos bits fracionais para os inteiros, o que acontece se o intervalo for calculado incorretamente. Basta verificar a página de recursos do Fixed-Point Designer do MATLAB para ver o que mais poderia dar errado em um relance.
Ronan Paixão
1

Sua pergunta é um pouco ampla. Hardware (HW) pode significar desenvolvimento ASIC / FPGA personalizado completo, DSPs programados por montadores ou "apenas" um sistema embarcado típico baseado em microprocessadores / microcontroladores / SoC disponíveis no mercado, etc. (é claro que um SoC também pode conter um DSP que você pode querer programar ....). Para grandes quantidades de venda, torná-lo um ASIC não é incomum.

Mas para um projeto de 2 meses, espero que seja baseado em algum microcontrolador:

De qualquer forma, você deve enfatizar a equipe de hardware para fornecer um protótipo para começar a testar seu código antes do prazo absoluto - isso pode consistir em uma placa de desenvolvimento genérica, como algumas pessoas já mencionaram, mas, na minha opinião, é a sua trabalho para fornecer o caminho certo para você e, potencialmente, também alguns periféricos necessários / semelhantes para teste.

Os simuladores também são possíveis até certo ponto, mas você ainda pode precisar caracterizar alguns sensores / dados do mundo real que possa obter. Aqui, a equipe de hardware também precisa pelo menos ajudá-lo.

Fora isso, o design do software já pode ser feito e todos os módulos de alto nível podem ser (e devem ser) implementados e testados em unidade sem o hardware real. Idealmente, você também definirá uma API juntamente com a equipe de hardware, e elas fornecerão as funções de nível mais baixo; portanto, qualquer alteração que fizerem no lado do hardware (por exemplo, simplesmente redefinindo quais pinos de porta eles usam) nem sempre será seja crítico para você.

Em todos os casos, a comunicação é fundamental.

bluesceada
fonte
0

Sim, você pode desenvolver seu código para o seu quadro de destino antes que ele seja fabricado.

Como ?

Primeiro você precisa conhecer o objetivo principal desse sistema. Assim, você pode escolher o controlador de forma apropriada a partir de uma vasta fonte de disponibilidade, como digikey, mouser.

E escolha um simulador como o Proteus. Isso simulará o processador / controlador exato agora que você poderá iniciar sua codificação. Mas você não pode esperar a precisão como no hardware.

Photon001
fonte
Por que voto negativo? Posso saber o que há de errado com esta resposta?
Photon001