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
Tags:
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:
https://bitluni.net/esp32-i2s-camera-ov7670
https://randomnerdtutorials.com/esp32-cam-take-photo-save-microsd-c...
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.
Links importantes para estudos :
I2S bus specification
https://www.sparkfun.com/datasheets/BreakoutBoards/I2SBUS.pdf
https://github.com/espressif/esp32-camera
OV2640DS datasheet - camera 2 MegaPixels
https://www.uctronics.com/download/cam_module/OV2640DS.pdf
ESP32 API Reference - I2S
https://docs.espressif.com/projects/esp-idf/en/latest/api-reference...
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
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
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...
Bem-vindo a
Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)
© 2024 Criado por Marcelo Rodrigues. Ativado por