Abra seus olhos! Analisador Lógico: 21 Passos

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

O analisador lógico facilita a visualização do trem de pulsos, que são os bits que viajam em uma linha de comunicação. Assim, ele abre seus olhos para identificar um possível problema. Por que isso é importante? É uma ferramenta de desenvolvimento e detecção de falhas muito eficiente que pode economizar seu tempo. Neste vídeo de hoje, vamos avaliar a importância do analisador lógico, observar alguns protocolos de práticas comuns ao usar este dispositivo e exemplificar uma falha de detecção sem o auxílio de um analisador lógico.

Neste vídeo, usei um modelo relativamente barato (cerca de US $ 35) e eficiente, com interface gráfica e software livre.

Etapa 1: Montagem

Etapa 2: Recursos usados - servidor

• Jumpers para conexões

• 2 Arduinos (usamos 2 Mega Arduinos 2560)

• Analisador lógico (usamos Saleae)

• Cabos de conexão USB para Arduino e analisador.

• Osciloscópio (opcional)

• Protoboard

Etapa 3: Circuito usado

Aqui temos o esquema, que mostra o monitoramento de três pinos: TX0, SDA e SCL. Temos dois Arduinos: um mestre e um escravo.

Etapa 4: Código Fonte: Mestre

Na Configuração, incluiremos a biblioteca para comunicação i2c. Entramos na rede como Master e inicializamos a serial 0. No Loop, solicitamos bytes de dados do escravo para comunicação com nosso Arduino número 8, conforme definimos no exemplo. Imprimimos no serial, que será avaliado com o analisador lógico, os bytes recebidos.

#include // inclui uma biblioteca para comunicação I2C void setup () {Wire.begin (); // Entra na rede como Mestre (endereço é opcional para mestre) Serial.begin (115200); // inicia um serial 0} void loop () {Wire.requestFrom (8, 6); // requer 6 bytes de dados para escravo de endereço 8 while (Wire.available ()) {// quando houver bytes para receber… char c = Wire.read (); // recebe cada byte e armazena como caracter Serial.print (c); // envia o caracter pela serial (na verdade vai para o buffer)} delay (500); // aguarda meio segundo}

Etapa 5: Código Fonte: Slave

Neste código escravo, incluo novamente a biblioteca para comunicação i2c. Entro na rede como escravo com o endereço 8. Registramos o evento de solicitação e o associamos à função "solicitação". Você não precisa fazer nada no loop, apenas dê um atraso de 0,1 segundo.

Por fim, temos a função de solicitação que será executada quando ocorrer o evento de solicitação do Mestre, a qual foi cadastrada no Setup. Respondemos, finalmente, com uma mensagem de 6 bytes.

#include // inclui uma biblioteca para comunicação I2C void setup () {Wire.begin (8); // entra na rede como escravo com endereço 8 Wire.onRequest (requestEvent); // registro do evento de requisição // e associação à função requestEvent} void loop () {delay (100); // não faz nada no loop, apenas aguarda 0, 1 segundo} // função que será executada quando ocorrer o evento de requisição pelo mestre // foi registrado como evento no setup void requestEvent () {Wire.write ("teste"); // responde com uma mensagem de 6 bytes}

Etapa 6: Analisador: Hardware

Taxa de amostragem até: 24 MHz

Lógica: 5 V a 5,25 V

Limite de baixo nível 0,8 V

Limiar de alto nível 2,0 V

Impedância de entrada de cerca de 1 Mohm ou mais

Etapa 7: Instalação do software Saleae

O programa que recebe os dados capturados pelo analisador lógico e decodifica os bits pode ser baixado no seguinte link:

Etapa 8: Configurando o ambiente para nossos testes

Mostro a interface aqui, da qual gostei particularmente porque estava limpa.

Etapa 9: Configurando o ambiente para nossos testes

Aqui estão algumas opções de configuração:

• Ao clicar no nome do canal, podemos alterá-lo.

• Podemos determinar se um dos canais servirá como gatilho para a captura e a forma de detecção.

• Ao clicar e segurar o número do canal, você pode alterar sua posição na lista.

• Ao clicar na engrenagem, podemos configurar a visualização do canal, expandindo …

•… ou ocultando o canal. Esconderemos todos os canais que não usaremos.

Etapa 10: Configurando o ambiente para nossos testes

Clicando nas setas do botão “Iniciar”, encontram-se as opções de Taxa de Amostragem e duração da gravação.

Por algum motivo, se o software detectar que a taxa não pode ser mantida, uma mensagem será exibida e automaticamente a taxa será reduzida até que um valor funcional seja alcançado.

Etapa 11: Configurando o ambiente para nossos testes

Também incluiremos os analisadores de protocolo. Primeiro é o I2C, seguindo as definições da biblioteca WIRE e associando os canais corretamente. Por fim, apresentaremos o analisador ao serial assíncrono. Precisamos ter o cuidado de configurar corretamente os parâmetros de acordo com a montagem.

Etapa 12: Configurando o ambiente para nossos testes

Na guia "Protocolos decodificados", devemos verificar quais analisadores de protocolo estão habilitados. Lá, os dados aparecerão. Na aba "Anotações" podemos adicionar alguns dos resultados para melhor visualização. Basta clicar no ícone "adicionar medição".

Etapa 13: Captura: Visão geral

Na tela de captura, o programa exibe o trem de pulso de dados do SDA, SCL e TX0.

Etapa 14: Captura: Resultado da Análise do Protocolo

Aqui, vemos o resultado da captura. Na guia "Protocolos decodificados", temos:

• A solicitação do servidor para o escravo com id 8.

• A resposta do escravo, seis caracteres: "t", "e", "s", "t", "e" e um espaço.

• Cada um é seguido por um bit ACK (Reconhecer) indicando a recepção de byte correta, exceto para o caractere de espaço NACK (Não Reconhecer).

• A seguir, vemos o resultado da decodificação do serial TX0, indicando os caracteres recebidos e enviados para o terminal serial IDE do Arduino.

Etapa 15: Captura: Canal 0 e Dados (SDA)

Nesta imagem, temos o trem de pulsos da linha SDA. Observe que cada byte transmitido pode ser visualizado.

Etapa 16: Captura: Canal 1 e Relógio (SCL)

Agora, temos aqui o trem de pulsos da linha SCL. Você pode verificar mais detalhes simplesmente posicionando o mouse sobre o sinal, como você vê na imagem. Podemos ver que a frequência do clock estava em 100 kHz.

Etapa 17: Captura: Canal 2 e Serial (TX0)

Quanto ao trem de pulsos da linha TX0, podemos ver o bit Start e os pontos de enquadramento de cada bit. Temos um byte que representa o caractere "e".

Etapa 18: Configurando o ambiente para nossos testes

Aqui temos várias opções para ler os dados.

Etapa 19: Captura: Osciloscópio e Analisador

Olhe aqui para a tela que capturei com meu osciloscópio. O sinal do analisador lógico representa apenas as detecções de alta e baixa, mas não representa a qualidade do sinal. Isso pode ser melhor observado em um osciloscópio.

Etapa 20: Captura: Observando uma falha (exemplo de falha serial)

Agora, vou mostrar um exemplo de uma falha em série, que realmente aconteceu comigo. Eu estava com um modem GPRS, do tipo usado no celular, o cartão SIM, tentando conectar no ESP32. Mas simplesmente não conectou. Em seguida, verifiquei a fonte de alimentação, a fiação e troquei a placa. Fiz tudo, mas nada consertou. Decidi fazer uma análise lógica: descobri que o sinal ESP no UART 115200 começou a não combinar. Ou seja, o ESP32 estava jogando o que deveria ser 115, 200 em uma velocidade diferente desta.

Este erro, que foi identificado pelo analisador, foi exibido com um X em vermelho. No meu entendimento, o programa diz que o ponto que possui tal bit está meio deslocado no tempo. À medida que essa mudança aumenta, pode chegar um momento em que tudo é incompatível, de modo que as informações não cheguem ao outro lado. Geralmente chega, mas o SIM800 é sensível e se não for exato, a informação não chega ao outro lado.

Não sei se isso é algo que acontece com frequência ou não, mas aconteceu comigo, por isso resolvi tratar desse assunto aqui. Então o que eu fiz? Eu diminuí. Se você colocar 9, 600, 19, 200, até 38, 400, funciona, o que não ocorre com 115, 200.

Etapa 21: Baixe os arquivos

PDF

EU NÃO