Olá pessoal.

Existe um tutorial aqui no LdG, aberto pelo Gustavo, que ensina a usar um Arduino como um analisador lógico

http://labdegaragem.com/profiles/blogs/tutorial-analisador-l-gico-c...

O tutorial é muito bem feito, como aliás é tudo que o Gustavo publica aqui.

Daí outro dia eu tive um ideia meio maluca.

Usar o ESP32 como um analisador lógico baseando neste tutorial.

Mas aí veio outra ideia mais maluca.

Ler diretamente os ports do ESP32  na velocidade do clock dele (320 Mhz).

Dei uma estudada como funcionam os port do ESP32 e verifiquei que usando uma instrução do pacote ESP-IDF, mesmo rodando na IDE do Arduíno eu conseguiria ler os ports todos ao mesmo tempo.

Em principio funciona assim:     

    Crio uma matriz de "n" elementos;     

    faço um loop de "n"  vezes;     

       leio os ports do ESP32 e guardo o valor nesta matriz;     

       a instrução REG_READ(GPIO_IN_REG);  lê os 32 bits dos ports do ESP e      

       o valor é salvo na matriz endereçada pelo Índice do loop;     

   ao terminar o loop;     

      faço.outro loop de "n"  vezes;     

      e imprimo os bits de cada valor guardado na matriz.

Futuramente o valor ao invés de imprimir o valor ele será plotado em uma tela gráfica.

A velocidade de leitora deveria ser muito grande.

Para testarmos, o Gustavo usou um recurso que ele descobriu fazer parte do pacote do ESP32.

Voce define um valor de PWM  e define qual port será a saída.

E ao carregar o código o PWM roda na velocidade que você definir, e roda sem ocupar o processador.

No teste eu " jumpiei" o port 18 (saída PWM) com o port 4 (entrada).

Em principio deveria funcionar e a leitura deveria ser perto de 40 mHz.

Mas (que coisa, sempre tem um mas).

Mas ao testarmos (eu e o Gustavo), verificamos que não é bem assim.

Ficamos perguntando o porque.

Bom, acho que consegui entende.

Na minha teoria favorita (todo mundo tem uma teoria favorita),

funciona assim:

Uma instrução de maquina  (ou talvez mais de uma) le os posts             

160MHz/1 =  160 MHz;

Algumas instruções guardam o valor na matriz (chuto 4)       

4 + 1 = 5    160MHz/5 =  32 MHz;

Algumas instruções para "for" (chuto 20)             

5 + 20 = 25  160MHz/16 = 6,4 MHz.
e se tiver mais algumas, o valor de leitura será menor ainda.

Pensamos em usar DMA, pois assim os dados vão direto para a memoria sem latência

de processador, mas ainda está em estudos.

Agradecemos palpites.

Anexo segue o sketch que usamos para os testes iniciais.

RV  e Gustavo

ESP32_TwoCore6.ino

Exibições: 2179

Responder esta

Respostas a este tópico

Bom  dia Rui, 

Para usar 8 bits paralelo com I2S DMA, terá que usar o LCD mode.

https://docs.espressif.com/projects/esp-idf/en/latest/api-reference...

Os periféricos I2S também suportam o modo LCD para comunicação de dados através de um barramento paralelo, conforme usado por alguns monitores LCD e módulos de câmera. O modo LCD possui os seguintes modos operacionais:

  • Modo de transmissão principal do LCD
  • Modo de recepção do escravo da câmera
  • Modo ADC / DAC

https://bitluni.net/esp32-i2s-camera-ov7670

https://randomnerdtutorials.com/esp32-cam-take-photo-save-microsd-c...

Lendo a biblioteca esp32-camera-OV2640, SCCB, DMA, I2S edition

https://www.mgo-tec.com/blog-entry-sccb-dma-i2s-esp32-ov2640.html/6

(use o tradutor do navegador Chrome)

Esse japonês demorou 6 meses para desenvolver esse programa. O cara não é um especialista, mas é muito esforçado e conseguiu. Ele usou I2S DMA com frequência de 20 MHz, para capturar os 8 bits e mais alguns bits de controle da camera de video. Boa referência para o uso de I2S DMA usando Arduino IDE. 

Bom dia a todos, 

Tenho estudado muito sobre o ESP32. 

Estou estudando em partes, pois o ESP32 é muito complexo e o manual de referência técnica tem mais de 600 páginas!.

O que eu já descobri é que esse manual é incompleto e possui alguns erros. 

ESP32 Technical Reference Manual

https://www.espressif.com/sites/default/files/documentation/esp32_t...

Ainda bem, que muito mais informação complementar pode ser encontrada no Github do ESP32- Arduino:

https://github.com/espressif/arduino-esp32

Ou no Github ESP32-IDF:

https://github.com/espressif/esp-idf

Estou aprendendo como mostrar o conteúdo dos registradores, como setar ou resetar os bits dos registradores e como selecionar as pastas das bibliotecas correspondentes à essas funções! Muito legal. 

No momento estou estudando como configurar o Audio PLL Clock do ESP32. Os inúmeros clocks do ESP32 tem inúmeros recursos. São fantásticos! Teoricamente é possível gerar pulsos de clock de várias maneiras e com frequências de até 128 Mhz! Incrível. 

Esse APLL Clock é o clock master usado na interface I2S. 

Se quiser aprender mais sobre interface I2S:

https://en.wikipedia.org/wiki/I%C2%B2S

Esse manual  da Especificação o I2S BUS também é muito importante:

https://www.sparkfun.com/datasheets/BreakoutBoards/I2SBUS.pdf

PLL Sintetizador de frequências :

https://www.analog.com/en/analog-dialogue/articles/pll-synthesizers...

Vejam como é complexo o APLL Clock do ESP32 :

(Google Tradutor) 

3.2.2 Clock Source

PLL_CLK é um relógio interno da PLL com uma frequência de 320 MHz.

APLL_CLK é um relógio interno de áudio PLL com uma faixa de frequência de 16 a 128 MHz.

3.2.4.4 APLL_SCLK Source

O APLL_CLK é originário do PLL_CLK, com sua frequência de saída configurada usando a configuração dos registradores do  APLL. PLL Clock.

3.2.7 Audio PLL

A operação de áudio e outros aplicativos de transferência de dados críticos em termos de tempo, requer alta configurabilidade, baixa instabilidade, e fontes de relógio precisas. As fontes de relógio derivadas dos relógios do sistema que servem periféricos digitais podem ter jitter de transporte e, portanto, eles não suportam uma configuração de freqüência de relógio de alta precisão.
Fornecer uma fonte de relógio de precisão integrada pode minimizar o custo do sistema. Para este fim, o ESP32 integra um áudio PLL destinado a periféricos I2S. Mais detalhes sobre como cronometrar o módulo I2S, usando um relógio APLL, podem ser encontrado no capítulo I2S. A fórmula do Audio PLL é a seguinte:

apll_freq = xtal_freq * (4 + sdm2 + sdm1/256 + sdm0/65536)/((o_div + 2) * 2)


*
* The dividend in this expression should be in the range of 240 - 600 MHz.
*
* In rev. 0 of ESP32, sdm0 and sdm1 are unused and always set to 0.
*
* @param enable true to enable, false to disable
* @param sdm0 frequency adjustment parameter, 0..255
* @param sdm1 frequency adjustment parameter, 0..255
* @param sdm2 frequency adjustment parameter, 0..63
* @param o_div frequency divider, 0..31

xtal: a frequência do oscilador de cristal, geralmente 40 MHz;

Pasta da Biblioteca ESP32-Arduino que usei para configurar o APLL Clock: 

https://github.com/espressif/arduino-esp32/blob/a59eafbc9dfa3ce818c...

Exemplo 1) Para gerar um clock de 60 MHz no APLL:

sdm0= 0 sdm1= 0 sdm2= 2 o_div= 0

apll_freq = xtal_freq * (4 + sdm2 + sdm1/256 + sdm0/65536)/((o_div + 2) * 2)
apll_freq = 40 Mhz * (4 + 2 + 0 + 0) / (0+2)*2 = 40 * 6 / 4 = 60 MHz

Na verdade o clock master da Interface I2S é o i2Sn CLK que pode ser  derivado do PLL D2 Clock ou  do APLL Clock. 

12.3 The Clock of I²S Module

A relação entre a frequência I2Sn_CLK fi2s e a frequência da fonte divisória do relógio fpll pode ser vista no
equação abaixo:

// Configurar a configuração do Bit Clock - I2S_CLKM_CONF_Register


   I2S0.clkm_conf.clkm_div_a = 1; // valor do denominador do divisor de relógio fracionário
   I2S0.clkm_conf.clkm_div_b = 0; // valor do numerador do divisor de relógio fracionário
   I2S0.clkm_conf.clkm_div_num = 2; // Valor integral do divisor de relógio I2S

Boa tarde pessoal.

Continuando na saga do analisador logico.   (Chamarei de AL)

Resolvi entender como o Gillham (https://github.com/gillham/logic_analyzer) faz  para capturar os 

dados para o AL, e verifiquei que para não perder tempo dentro do "for" ele fez

1024 leitura consecutivas guardando cada uma em uma célula da matriz.

Resolvi então medir este tempo de leitura, e comparar com os tempos de leituras de outros processadores.

Escrevi um sketch bem básico e o mais limpo possível.

Os resultado foram surpreendentes.

A minha conclusâo: nem o ESP8266 e nem o ESP32 são mais rápidos do que o Atmega328 ao manusear ports.

Resultados encontrados:

ESP8266
1908 useg gastos pelo ESP8266 para ler um port 1000 vezes.
Media de 1908 nseg por leitura. 

Possibilidade de leitura de pulsos á  frequência de   524 KHz.

ESP32 GPIO
353 useg gastos pelo ESP32_GPIO para ler um port 1000 vezes.
Media de 353 nseg por leitura. 

Possibilidade de leitura de pulsos á  frequência de  2.833 KHz. 

ESP32 IOMUX
115 useg gastos pelo ESP32_IOMUX para ler um port 1000 vezes.
Media de 115 nseg por leitura.

Possibilidade de leitura de pulsos á  frequência de  8.696 KHz.

Atmega328
64 useg gastos pelo Arduino para ler um port 1000 vezes.
Media de 64 nseg por leitura.

Possibilidade de leitura de pulsos á  frequência de  15.625 KHz.

Para prosseguir com o projeto, só mesmo usando o DMA do ESP32, mas que tem se mostrado

muito complexo e até agora não obtive resultados conclusivos.

Abaixo sketch usado para os testes.

Qualquer critica é aceita de bom grado.

RV

TimeSample.ino

No caso do esp32 você poder usar um núcleo exclusivamente para ler as portas, acredito que dessa forma consiga uma taxa de amostragem melhor que a do teste que você fez.
Pra isso é necessário desabilitar todas tasks e interrupts daquele core.
vTaskSuspendAll(); // suspende as tasks
portDISABLE_INTERRUPTS(); // desabilita interrupts

O método acima não impede que o outro core acesse a memoria compartilhada, nesse caso tem de usar spinlock para proteger de acesso simultâneo :
portMUX_TYPE myMutex = portMUX_INITIALIZER_UNLOCKED;
taskENTER_CRITICAL(&myMutex);

// seção critica variaveis compatilhada
taskEXIT_CRITICAL(&myMutex);

quando taskENTER_CRITICAL é executado, bloqueia todas tasks e interrupt daquele core e caso outro core que tente executar taskENTER_CRITICAL  ele é bloqueado até o primeiro core  executar taskEXIT_CRITICAL
enfim, mutex para quem conhece.

Atualizando, após alguns dias de férias:

Consegui gerar clocks bem altos com o ESP32. Achei isso incrível! Esse clock será usado como base de tempo no Analisador Logico. 

Através de equações matemáticas, uma gama variada de frequências poderá ser gerada.

Consegui gerar um clock de 80 MHz usando o PLL_D2_clock e até 64 MHz usando o APLL_clock

Esse último permite variações mais precisas na frequência (mais flexível).

https://esp32.com/viewtopic.php?f=18&t=14185

Pesquisando no Forum do ESP32, encontrei esse projeto de um Analisador Lógico com o ESP32:

https://esp32.com/viewtopic.php?f=19&t=14135&start=20&s...4

(não testei ainda). 

Rui bom dia, 

Consegui configurar e usar o SUMP ESP32 Logic Analyzer

O projeto é bem promissor e esta funcionando! 

https://esp32.com/viewtopic.php?f=19&t=14135&p=56903#p56903

Para baixar os códigos :

https://github.com/EUA/ESP32_LogicAnalyzer

Resumindo meu ambiente e configurações:

ESP32 Dev Kit (38 pinos) - Arduino IDE 1.8.10
ESP32 Arduino FW versão 1.04
ESP32 Configurações da placa:

Carregue os 3 arquivos do código em uma mesma pasta, para a IDE poder acessá-los.

No código do arquivo ESP32_LogicAnalyzer.h , fiz essa alteração:
#define USE_SERIAL2_FOR_OLS 0                 // If 0, UART0 = OLS e UART2  (funcionou)


PulseView - versão 0.4.1 (64 bits)

https://sigrok.org/wiki/PulseView
Pulse View downloads:
https://sigrok.org/wiki/Downloads


Conectando ao ESP32:

Usei um oscilador de cristal de 1,3025 MHz para testar o Logic Analyzer - conectado ao pino GPIO4 (canal 4):
A leitura da frequência foi quase precisa. O buffer de 128K não foi encontrado.

Manual super importante:

ESP IDF Programming guide - para ESP32:

https://espressif-docs.readthedocs-hosted.com/_/downloads/esp-idf/e...

RSS

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço