Arduino UNO Logic Sniffer: 8 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Este projeto começou como um experimento simples. Durante minha pesquisa sobre a folha de dados do ATMEGA328P para outro projeto, encontrei algo bastante interessante. A unidade de captura de entrada Timer1. Ele permite que o microcontrolador do nosso Arduino UNO detecte uma borda de sinal, armazene um carimbo de data / hora e acione uma interrupção, tudo no hardware.

Então me perguntei em que aplicativo isso poderia ser útil e como testá-lo. Como quero obter um analisador lógico há algum tempo, decidi tentar implementar um na minha placa Arduino UNO, apenas para testar o recurso e ver se podemos obter bons resultados com ele.

Não sou o único que teve essa ideia, e você vai encontrar muitas delas simplesmente pesquisando "Arduino Logic Analyzer" no Google. No início do projeto, como começou apenas como uma experiência, nem sabia que as pessoas já o haviam feito, e fiquei impressionado com os bons resultados que alcançaram com este pequeno hardware. No entanto, não consegui encontrar outro projeto usando a unidade de captura de entrada, então se você já viu isso, me avise!

Para resumir, meu analisador lógico irá:

• Tenha um canal,
• Tenha uma interface gráfica,
• Comunique-se com a interface por USB,
• Execute em uma placa Arduino UNO.

Ele finalmente terá uma profundidade de memória de 800 samples e foi capaz de capturar com sucesso uma mensagem UART de 115200 bauds (eu realmente não testei em velocidades mais altas).

Este instrutível contém as partes "como funciona" e "como usar" deste projeto, portanto, para aqueles que não estão interessados no lado técnico, você pode pular diretamente para a etapa 4.

Suprimentos

Eu queria manter o analisador o mais simples possível, exigindo muito pouco hardware.

Você vai precisar de:

• Uma placa Arduino UNO (ou equivalente, desde que dependa do MCU ATMEGA328P),
• Um computador,
• Algo para depurar (uma outra placa Arduino UNO funciona bem para fazer alguns testes).

O código para o Arduino UNO e a interface da web podem ser encontrados aqui. Você também precisará do p5.serialcontrol e do software PulseView.

Etapa 1: Princípio de funcionamento

A ideia é simples. Você escolhe as configurações de captura e clica em "adquirir". A interface web irá enviá-los para o software p5.serialcontrol, que nos permite usar a interface serial de um navegador, já que não pode acessá-la diretamente. O software p5.serialcontrol então retransmite as informações para a placa Arduino UNO, que captura os dados e os envia de volta para a interface pelo mesmo caminho.

Fácil! Bem… Como eu não sou muito bom em programação de interface Homem / Máquina ou tecnologias web, o meu é certamente um pouco feio e cheio de erros. Mas me permite iniciar uma captura e recuperar meus dados, que é para o que foi projetado, então acho que está tudo bem. Para um trabalho de análise mais sério, eu importo meus registros para o PulseView, que é fácil de usar e oferece um bom conjunto de recursos e decodificadores de protocolo, como veremos mais tarde.

A unidade de captura de entrada do Arduino UNO pode ser configurada para usar diferentes divisões de clock, reduzindo assim a resolução, mas aumentando o atraso antes do estouro. Ele também pode disparar ao subir, descer ou ambas as bordas para começar a capturar os dados.

Etapa 2: Arduino UNO Sketch

Eu escrevi e compilei o esboço com o IDE do Arduino. Comecei configurando o Timer1 no modo de operação "Normal", escrevendo em seus registros TCCR1A e TCCR1B na configuração (). Em seguida, fiz algumas funções para facilitar um pouco seu uso no futuro, como a que define a divisão do relógio chamada "setTim1PSC ()". Também escrevi funções para ativar e desativar a unidade de captura de entrada Timer1 e interrupções de estouro.

Eu adicionei o array "samples", que conterá os dados adquiridos. É um array global que defini como "volátil" para evitar que o compilador faça otimizações e coloque-o em flash, como fazia durante minhas primeiras compilações. Eu o defini como um array "uint16_t", já que o Timer1 também é de 16 bits, com um comprimento de 810. Paramos de capturar em 800 valores, mas como o teste é feito fora das interrupções por razões óbvias de velocidade, optei por manter 10 mais valores para evitar estouro. Com algumas variáveis extras para o resto do código, o esboço está usando 1313 bytes (88%) de memória, deixando-nos com 235 bytes de RAM livre. Já estamos com um alto uso de memória e eu não queria adicionar mais capacidade de amostra, pois isso poderia causar comportamentos estranhos devido a pouco espaço de memória.

Em minha busca para sempre aumentar a velocidade de execução, usei ponteiros de função em vez de instruções if dentro das interrupções, para reduzir o tempo de execução ao mínimo. O pino de captura será sempre o Arduino UNO número 8, pois é o único conectado à unidade de captura de entrada do Timer1.

O processo de captura é mostrado na imagem acima. Ele começa quando o Arduino UNO recebe um quadro de dados UART válido, contendo as configurações de captura desejadas. Em seguida, processamos essas configurações configurando os registradores certos para capturar na borda escolhida e usamos a divisão de clock certa. Em seguida, habilitamos a interrupção PCINT0 (mudança de pino) para detectar a primeira borda do sinal. Quando o obtemos, redefinimos o valor do Timer1, desabilitamos a interrupção PCINT0 e habilitamos a interrupção ICU (Input Capture Unit). A partir desse momento, qualquer borda de descida / subida no sinal (dependendo da configuração escolhida), acionará a unidade de captura de entrada, salvando assim um carimbo de data / hora deste evento no registro ICR1 e executando uma interrupção. Nessa interrupção, colocamos o valor do registro ICR1 em nosso array "samples" e incrementamos o índice para a próxima captura. Quando o Timer1 ou o array estouram, desabilitamos a interrupção de captura e enviamos os dados de volta para a interface da web por meio do UART.

Decidi usar uma interrupção de mudança de pino para acionar a captura, já que a unidade de captura de entrada só permite capturar em uma ou outra borda, não em ambas. Também causa um problema quando você deseja capturar as duas bordas. Minha solução então é inverter o bit que controla a seleção de arestas no registro de controle de captura de entrada em cada amostra recuperada. Dessa forma perdemos a velocidade de execução, mas ainda podemos usar as funcionalidades da unidade de captura de entrada.

Portanto, como você deve ter notado, não capturamos realmente cada amostra em intervalos de tempo fixos, mas capturamos o momento em que ocorre uma transição de sinal. Se tivéssemos capturado uma amostra em cada ciclo de clock, mesmo com a maior divisão de clock, teríamos preenchido o buffer em aproximadamente 0,1s, supondo que estávamos usando o tipo uint8_t, que é o menor na memória sem usar structs.

Etapa 3: Interface da Web e P5.js

Como o título indica, a interface da web foi feita com a ajuda de p5.js. Para quem ainda não conhece, recomendo veementemente que dê uma olhada no site, pois é uma biblioteca muito boa. É baseado em Processing, é fácil de usar, permite obter bons resultados muito rapidamente e está bem documentado. É por todos esses motivos que escolhi esta biblioteca. Também usei a biblioteca quicksettings.js para os menus, a grafica.js para plotar meus dados e a biblioteca p5.serialport para me comunicar com o Arduino UNO.

Não vou gastar muito tempo na interface, já que acabei de projetá-la para visualização de dados e controle de configurações, e também porque não era o assunto do meu experimento. No entanto, irei explicar nas partes seguintes as diferentes etapas para usar todo o sistema, explicando assim os vários controles disponíveis.

Etapa 4: configuração do sistema

A primeira coisa é baixar o Arduino UNO e o código da interface aqui, se ainda não tiver feito. Você pode então reprogramar sua placa Arduino UNO com o esboço "UNO_LS.ino" por meio do IDE do Arduino.

Você deve ter baixado o software p5.serialcontrol de seu repositório github. Você tem que obter o arquivo zip correspondente ao seu sistema operacional (eu só testei no Windows). Extraia o zip em uma pasta, inicie o executável encontrado nela e deixe-o assim. Não tente se conectar a nenhuma porta serial, apenas deixe-a rodando em segundo plano, ela será usada como relé.

Abra a pasta "Interface". Você deve encontrar um arquivo chamado "index.html". Abra-o em seu navegador, é a interface da web.

E é isso! Você não precisa baixar bibliotecas extras, tudo deve estar incluído no pacote que forneci.

Etapa 5: Conexão, Configuração e Aquisição

Para conectar a interface à placa Arduino UNO, basta selecionar a porta correspondente na lista e clicar no botão "Abrir". Se a operação for bem-sucedida, a mensagem "estado" deve exibir algo como "COMX aberto".

Agora você pode escolher suas opções de captura. O primeiro é a seleção de arestas. Recomendo que você use sempre "Ambos", pois isso lhe dará a melhor representação do sinal real. Se a configuração "Ambos" falhar em capturar o sinal (se a frequência do sinal for muito alta, por exemplo), você pode tentar com a configuração de borda "Ascendente" ou "Descendente", dependendo do sinal que você tenta ver.

A segunda configuração é a divisão do relógio. Ele lhe dará a resolução na qual você poderá capturar o sinal. Você pode escolher definir o fator de divisão por "8", "64", "256" e "1024". A placa Arduino UNO usa um quartzo de 16 MHz para sincronizar o microcontrolador, de modo que a frequência de amostragem será "16 MHz / fator de divisão". Tenha cuidado com esta configuração, pois ela também determinará por quanto tempo você poderá capturar um sinal. Como o Timer1 é um temporizador de 16 bits, o tempo de captura permitido antes do estouro será "(2 ^ 16) * (fator de divisão) / 16MHz". Dependendo da configuração escolhida, ela variará entre ~ 33ms e 4,2s. Mantenha sua escolha em mente, você precisará dela mais tarde.

A última configuração é o cancelador de ruído. Não realizei muitos testes nele e você não precisará dele em 99% dos casos, então deixe-o desmarcado. Para quem ainda tem curiosidade, pode procurar o cancelador de ruído na seção Timer / Counter1 da ficha do ATMEGA328P.

Não se esqueça de conectar o pino 8 da placa Arduino UNO ao seu sinal e conectar os aterramentos para ter a mesma referência de tensão para o circuito de teste e o analisador lógico. Se você precisa de isolamento de aterramento ou precisa medir sinais com níveis diferentes de 5 V, provavelmente precisará adicionar um opto-isolador ao circuito.

Depois que tudo estiver configurado corretamente, você pode pressionar o botão "Adquirir".

Etapa 6: captura de resultados e exportação de dados CSV

Assim que o Arduino UNO terminar a captura, ele enviará automaticamente os dados para a interface da web, que os representará. Você pode aumentar ou diminuir o zoom com o controle deslizante direito e percorrer as amostras com o inferior.

O gráfico fornece apenas uma visualização e não possui ferramentas de análise de dados. Portanto, a fim de conduzir análises adicionais em seus dados, você terá que importá-los para o PulseView.

A primeira etapa é exportar um arquivo csv contendo todos os seus dados. Para isso, basta clicar no botão "Exportar" da interface da web. Salve seu arquivo em um local conhecido quando solicitado.

Agora abra o PulseView. Na barra de menu superior, clique em "Abrir" (ícone da pasta) e selecione "Importar valores separados por vírgula …". Selecione o arquivo csv gerado anteriormente contendo seus dados.

Uma pequena janela aparecerá. Deixar tudo como está, basta modificar a configuração "Samplerate" de acordo com o fator de divisão do clock escolhido para a captura. Sua freqüência de amostragem será "16 MHz / (fator de divisão)". Em seguida, clique em "Ok", seu sinal deverá aparecer na tela.

Etapa 7: Análise de sinal PulseView

O PulseView oferece muitos decodificadores de protocolo. Para acessá-los, clique em "Adicionar decodificador de protocolo" na barra de menu superior (ferramenta mais à direita). Para minha experiência, acabei de enviar uma mensagem UART simples a 9600 bauds, então procurei por "UART".

Ele adicionará um canal com uma tag à sua esquerda (como a dos seus dados). Ao clicar na tag, você pode alterar as configurações do decodificador. Depois de escolher os corretos, consegui recuperar a mesma mensagem enviada pelo meu dispositivo de teste. Isso mostra que todo o sistema funciona conforme o esperado.

Etapa 8: Conclusão

Mesmo que o projeto tenha sido, no início, uma experiência, estou feliz com os resultados que obtive. Consegui amostrar sinais UART em até 115200 bauds no modo de borda "Ambos" sem nenhum problema, e até consegui ir até 230400 bauds no modo de borda "Em queda". Você pode ver minha configuração de teste na imagem acima.

Minha implementação tem várias desvantagens, começando pelo fato de que ela pode capturar apenas um sinal por vez, já que apenas o pino 8 do Arduino UNO é "capaz de captura de entrada". Se você estiver procurando por um analisador lógico Arduino com mais canais, verifique o do Catoblepas.

Você não pode esperar que um Arduino UNO seja capaz de capturar sinais com altas frequências (alguns MHz), já que ele só tem clock de 16 MHz (se alguém fez isso, eu estaria interessado em ver seu método). No entanto, ainda estou impressionado com os resultados que podemos obter com este microcontrolador ATMEGA328P.

Não acho que farei muito trabalho no código. Conduzi meus experimentos e obtive os resultados que estava procurando. Mas se alguém quiser contribuir, sinta-se à vontade para modificar e redistribuir todo ou parte do meu código.

Esse foi meu primeiro Instructable, e um longo, eu acho. Espero que tenha sido uma leitura interessante para você.

Avise-me se encontrar erros ou se tiver alguma dúvida!