Não seja cego! Analisador Lógico!

O analisador lógico facilita sua visualização do trem de pulso, dos bits trafegando em uma linha de comunicação, ou seja, ELE ABRE SEUS OLHOS para identificar um possível problema. E, por que isso é importante? Porque se trata de uma ferramenta de desenvolvimento e detecção de falhas bastante eficiente e que pode te ajudar a economizar tempo. Neste vídeo de hoje, então, vamos avaliar a importância do analisador lógico, observar alguns protocolos de uso comum utilizando este dispositivo, além de exemplificar uma falha de difícil detecção sem o auxílio de um analisador lógico.

Neste vídeo, usei um modelo relativamente barato, em torno de R$ 35, e bastante eficiente, com interface gráfica e um software gratuito.

Montagem

Recursos usados

·         Jumpers para conexões

·         2 Arduinos (usamos 2 arduinos mega 2560)

·         Analisador Lógico (usamos o Saleae)

·         Cabos de conexão USB para arduinos e analisador.

·         Osciloscópio (opcional)

·         Protoboard

Circuito utilizado

Aqui temos o esquemático, que mostra o monitoramento de três pinos: TX0, SDA e SCL. Temos dois arduinos: um mestre e um escravo.

Código-fonte: Mestre

No Setup, vamos incluir a biblioteca para comunicação i2c. Entramos na rede como Mestre e inicializamos a serial 0. Já no Loop, requisitamos bytes de dados escravos para comunicação com nosso arduino número 8, como definimos no exemplo. Imprimimos na serial, que será avaliada com o analisador lógico, os bytes recebidos.

#include <Wire.h> //inclui a biblioteca para comunicação I2C

void setup() {
  Wire.begin(); // Entra na rede como Mestre (endereço é opcional para o mestre)
  Serial.begin(115200); // inicia a serial 0
}

void loop() {
  Wire.requestFrom(8, 6);// requisita 6 bytes de dados do escravo de endereço 8

  while (Wire.available()) { // enquanto 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
}

Código-fonte: Escravo

Neste código do Escravo, novamente incluo a biblioteca para comunicação i2c. Entro na rede como Escravo com o endereço 8. Registramos o evento de requisição e associamos à função “request”. Não é necessário fazer nada no Loop, apenas dar um delay de 0,1 segundo.

Por fim, temos a função request que será executada quando ocorrer o evento de requisição pelo Mestre, o qual foi registrado no Setup. Respondemos, enfim, como uma mensagem de 6 bytes.

#include <Wire.h> //inclui a biblioteca para comunicação I2C

void setup() {
  Wire.begin(8); // entra na rede como escravo com endereço 8
  Wire.onRequest(requestEvent); // registra o evento de requisiçao
                                // e associa à 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 registrada como evento no setup
void requestEvent() {
  Wire.write("teste "); // responde com uma mensagem de 6 bytes
}

Analisador: Hardware

Taxa de amostragem de até: 24 MHz

Lógica: 5 V à 5,25 V

Limiar 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

Instalação do software da Saleae

O programa que recebe os dados capturados pelo analisador lógico e decodifica os bits pode ser baixado no seguinte link: https://www.saleae.com/pt/downloads/.

Configurando o ambiente para nossos testes

Mostro aqui a interface, que, particularmente, gostei bastante, por ser limpa.

Temos aqui algumas opções de configuração:

·         Clicando sobre o nome do canal podemos alterá-lo.

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

·         Clicando e segurando o número do canal podemos mudar sua posição na lista.

·         Clicando sobre a engrenagem podemos configurar a visualização do canal, ampliando...

·         ...ou ocultado o canal. Vamos ocultar todos os canais que não utilizaremos.

Clicando sobre as setas do botão “Start” temos as opções de Taxa de amostragem e duração da gravação.

Se por algum motivo o software detectar que não é possível manter a taxa, uma mensagem será exibida e, automaticamente, a taxa será reduzida até que um valor funcional seja alcançado.

Vamos incluir também os analisadores de protocolo. Primeiro o I2C, seguindo as definições da biblioteca WIRE, e associando os canais corretamente. Por fim, vamos introduzir o analisador para serial assíncrona, tomando o cuidado de configurar corretamente os parâmetros de acordo coma montagem.

Na guia “Decoded Protocols” devemos verificar quais analisadores de protocolos estão ativados. Será nela que os dados aparecerão. Na guia “Annotations” podemos adicionar alguns dos resultados pra melhor visualização. Basta clicar no ícone de “add Measurement”.

Captura: Visão geral

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

Captura: resultado da análise dos protocolos

Aqui vemos o resultado da captura. Na guia “Decoded Protocols” 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 de um bit de ACK (Acknowledge ) indicando o recebimento correto do byte, exceto pelo caractere de espaço NACK(Not Acknowledge).

·         Em seguida, vemos o resultado da decodificação da serial TX0, indicando os caracteres recebidos e enviados para o terminal serial da IDE do Arduino.

Captura: Canal 0 e dados (SDA)

Nesta imagem temos o trem de pulsos da linha SDA. Observe que é possível visualizar cada byte transmitido.

Captura: Canal 1 e Clock (SCL)

Já, aqui, temos o trem de pulsos da linha SCL. É possível verificar mais detalhes simplesmente posicionando o mouse sobre o sinal, como você vê na imagem. Podemos ver que a frequência do clock era de 100kHz.

Captura: Canal 2 e Serial (TX0)

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

Configurando o ambiente para nossos testes

Temos aqui diversas opções para leitura dos dados.

Captura: Osciloscópio e analisador

Observe aqui a tela que capturei do meu osciloscópio. O sinal do analisador lógico representa apenas as detecções de alto e baixo, mas não representa a qualidade do sinal, que pode ser observada melhor em um osciloscópio.

Captura: Observando uma falha (exemplo de falha na Serial)

Agora quero mostrar para você um exemplo de uma falha na serial, que aconteceu comigo mesmo. Estava eu com um modem GPRS, daquele tipo utilizado em celular, o cartão SIM, tentando conectar com o ESP32. Eis que, não conecta de jeito nenhum. Conferi, então, a alimentação, a fiação, troquei de protoboard, fiz de tudo. Mas, nada. Decidi por colocar um analisado lógico: descobri que o sinal do ESP, na Uart 115200, começou a desemparelhar. Ou seja, o ESP32 estava jogando o que deveria ser 115200 a uma velocidade diferente desta.

Esse erro, que foi identificado pelo analisador, foi exibido com um X em vermelho. No meu entendimento, o programa diz que o ponto que tem esse tal bit está meio deslocado no tempo. Conforme for aumentando este deslocamento, pode ser que chegue um momento que desemparelhe tudo, fazendo com que a informação não chegue ao outro lado. Posso até dizer que normalmente chega, mas o SIM800 é sensível e, se não estiver bastante preciso, a informação não chega até a outra ponta.

Pessoal, não sei se isso é uma coisa que acontece com frequência ou não, mas aconteceu comigo, e, por isso, resolvi tratar deste assunto aqui. O que eu fiz, então, neste caso? Baixei a velocidade. Se você colocar 9600, 19200, até 38400, ele funciona, o que não ocorre com o 115200.

Faça o download dos arquivos:

PDF

INO