Placas

O ESP32-C3

Um núcleo RISC-V a 160 MHz no mapa de memória real, sem rádio e com uma rede simulada no lugar dele.

A visão geral, com exemplos rodando, está na página da placa e O modelo do ESP32-C3 (todos os registradores).

O que é

A ESP32-C3-DevKitM-1: um chip RISC-V de 32 bits rodando no nosso próprio core RV32IMC, que passa a suíte riscv-tests no navegador. O modelo usa o mapa de memória real do ESP32-C3 e os deslocamentos reais de registradores para tudo o que implementa, então o firmware compilado aqui roda em um DevKitM-1 de verdade.

A CPU roda em fatias de 10 microssegundos a 160 MHz, uma instrução por ciclo, e uma mudança de pino dentro de uma fatia é colocada na instrução exata que a causou.

Os pinos

Dois conectores de 15 pinos, na ordem que a placa real tem.

Conector esquerdo, de cima para baixo: GND, 3V3, 3V3b, 2, 3, RST, GNDb, 0, 1, 10, 4, 5, 6, 7, 8.

Conector direito: 5V, 5Vb, GNDc, GNDd, 9, 18, 19, 20, 21, depois seis pinos marcados NC, que são desenhados para completar o conector e nunca são lidos.

Os GPIO 0 a 10, 18, 19, 20 e 21 são utilizáveis. Esta é uma placa de 3,3 volts: uma saída fornece 3,3 V ou 0 V, o limiar de entrada é 1,65 V, e os pull-up e pull-down internos ficam ambos em torno de 45 k.

RST tem um pull-up de 10 k; puxá-lo para abaixo de 1,65 V mantém o chip em reset.

O GPIO 8 carrega o LED da placa, e é por isso que LED_BUILTIN é 8. Aqui ele é desenhado como um LED comum. Em uma ESP32-C3-DevKitM-1 real ele é um RGB endereçável (um componente tipo WS2812 com controlador próprio), que ignora um pino que só fica em nível alto ou baixo: o Blink enviado do Mokxi não acende nada na placa real. O core do Arduino da Espressif contorna isso dando a LED_BUILTIN um número próprio e transformando digitalWrite() nele em uma cor enviada ao LED, então o Blink da IDE do Arduino o acende, branco fraco. Para ver um blink da versão do Mokxi na placa real, ligue um LED e um resistor a outro pino.

Os pinos analógicos

GPIO 0 a GPIO 4 são os canais 0 a 4 do ADC1, e analogRead() em um deles é uma conversão real da tensão no pino: doze bits, de 0 a 4095, com uma escala cheia escolhida pela atenuação. O padrão é 11 dB, praticamente todo o trilho de 3,3 V, então um potenciômetro ou um joystick ligado à alimentação percorre toda a faixa; analogSetPinAttenuation() aceita ADC_0db (1,1 V), ADC_2_5db (1,5 V), ADC_6db (2,2 V) ou ADC_11db, e analogReadResolution() ajusta o resultado se você quiser de volta os dez bits de um Uno.

One read costs about five microseconds of simulated time, which is what the converter takes. A pin with nothing on it reads 0 rather than noise. Any other pin reads 0 too: there are five analog inputs and no more.

PWM

analogWrite(pin, 0..255) funciona em qualquer GPIO. A saída vem do LEDC, o controlador PWM de LED do chip, e chega ao pino pela matriz de GPIO, então não há um conjunto fixo de pinos ~ como existe em um Uno.

O padrão é oito bits a 1 kHz. Quando a frequência importa (um servo quer cinquenta quadros por segundo e uma largura de pulso, não um duty), use a grafia do ESP32:

ledcAttach(4, 50, 14);        // fifty frames a second, 16384 counts each
ledcWrite(4, 1229);           // 1.5 ms of a 20 ms frame: the middle

Há seis canais e quatro temporizadores. Canais que pedem a mesma frequência e resolução compartilham um temporizador, então seis pinos fazendo fade juntos custam um dos quatro; pedir um quinto par distinto faz ledcAttach retornar false em vez de reajustar um temporizador que outro pino está usando. pinMode() e digitalWrite() retomam um pino do LEDC.

Um duty de 0 é nível baixo contínuo e um duty de 255 é nível alto contínuo, direto do hardware, sem nenhuma transição, o que também significa que o simulador não tem nada para acordar a placa, e uma placa fazendo fade em um LED enquanto parada em wfi custa duas acordadas por milissegundo e nada mais.

Serial

Na placa real, os pinos 20 e 21 são a UART0 e os pinos 18 e 19 são USB. Aqui eles são GPIO comuns, e os bytes da UART0 vão para o monitor serial. Veja rodar e o monitor serial.

What is modeled

GPIO, IO_MUX, UART0, o SYSTIMER, o caminho one-shot do ADC1 e o grupo de baixa velocidade do LEDC, nos endereços reais com seus bits reais, mais a interrupção externa de máquina para GPIO e UART.

delay() estaciona o núcleo em um alarme do SYSTIMER em vez de girar, então um sketch ocioso custa ao simulador algumas centenas de instruções por segundo simulado em vez de cento e sessenta milhões.

Alguns endereços de registradores não são verificados

Dois dos blocos acima carregam endereços que este modelo não pode garantir. Os endereços base e os deslocamentos de GPIO, IO_MUX, UART0 e SYSTIMER são do manual de referência técnica. Dentro do SAR ADC, todo deslocamento de registrador one-shot, exceto os dois primeiros, foi escolhido por este modelo em vez de copiado de uma página do manual; o mesmo vale para os quatro registradores de interrupção do LEDC, seus registradores globais de configuração e de data, e os seis números de sinal da matriz de GPIO pelos quais os canais do LEDC chegam a um pad. O firmware compilado aqui concorda com o modelo, concorde ou não com o silício, e uma imagem levada a um DevKitM-1 real deveria conferir primeiro essa lista curta de #defines em firmware/include/esp32c3.h. A seção 7 do modelo do ESP32-C3 classifica cada endereço como tirado do manual, presumido mas não verificado, ou ausente.

WiFi, simulated

Não há rádio. Nunca haverá: um MAC 802.11 não é algo que este modelo pudesse reproduzir com honestidade. O Bluetooth LE é simulado do mesmo jeito que a rede, com um telefone no painel Bluetooth do editor (Bluetooth, simulado).

O que existe no lugar é uma rede simulada. Um bloco que é do próprio Mokxi em vez do chip (uma caixa de correio em 0x6FFF_E000, onde um C3 real não tem nada mapeado) dá suporte a WiFi.h, HTTPClient.h e WebServer.h, então o código Arduino que um tutorial te dá roda aqui: a placa entra em um ponto de acesso cujo nome e senha são propriedades da placa, WiFi.status() percorre os mesmos estados no mesmo intervalo de um a três segundos, o DHCP lhe dá o 192.168.4.2, e um sketch pode buscar uma página ou servir uma.

O que está por trás disso é software, e nada disso está escondido. Não há 802.11, nem canal, nem varredura, nem WPA2, nem TCP, nem TLS e não há internet de verdade: quatro nomes inventados sob .mokxi resolvem e nenhum outro, e nada que um sketch faça pode alcançar a rede do seu navegador. WiFiClientSecure compila e depois falha, dizendo que TLS não é simulado. Os painéis Web e Cloud na parte de baixo do editor abrem com essa frase e não a deixam sair da tela.

A única exceção é Internet de verdade, um interruptor no painel Cloud para quem está logado (mais dele com o Pro) que fica desligado toda vez que uma página carrega. Com ele ligado, uma requisição por um nome fora de .mokxi, https:// incluído, sai pelo gateway do Mokxi e a resposta volta para o sketch. Veja Internet de verdade.

WiFi, simulado é como usar; WiFi simulado é o contrato, limite por limite.

Watchdog e pilha

As on the board, ESP-IDF's task watchdog runs from before setup() with a 5 s timeout: a sketch that neither calls delay() nor returns from loop() for that long prints the "Task watchdog got triggered" lines and reboots, and esp_reset_reason() says ESP_RST_TASK_WDT (6) afterwards. disableCore0WDT() turns that off, and esp_task_wdt_add(NULL) watches the sketch's own resets. A stack that runs out (recursion that never ends) stops with a "stack overflow" crash line at the top of the heap, before it writes over the program.

O que não é

Ausentes: SPI e I2C como periféricos, os temporizadores dos grupos de temporizadores (seus watchdogs estão lá, para o watchdog de tarefas), RMT, USB Serial/JTAG, a matriz de interrupções completa e qualquer coisa do ESP-IDF. Do ADC SAR, apenas o caminho one-shot do ADC1 é modelado, não o ADC2 (que o rádio compartilha no silício real), a tabela de padrões DMA, o controlador digital, os filtros e monitores de limiar, nem a curva de calibração nos eFuses, então uma leitura aqui é a linha reta nominal, e não a leve curvatura de um componente real, sem nenhum ruído nem não linearidade. A flag de conclusão do ADC pode ser consultada por polling, mas não chega ao controlador de interrupções. Binários do fabricante estão fora do escopo; o que roda é firmware compilado com nosso próprio runtime, que é o que o editor compila para você.

Uma instrução é um ciclo a 160 MHz, sem cache, sem tempos de espera de flash e sem travamentos de pipeline, então um programa aqui roda de forma mais uniforme do que rodaria no silício. Os pinos 3V3 e 5V são fontes ideais que não sofrem queda de tensão, então nada no Mokxi sofre brown-out.

Registro por registro, o modelo do ESP32-C3 tem tudo isso.

Bibliotecas do Arduino

Um tutorial que inclui Servo.h, Wire.h, SPI.h, EEPROM.h, LiquidCrystal_I2C.h, Adafruit_GFX.h com Adafruit_SSD1306.h, Adafruit_NeoPixel.h, ESP32Servo.h e DHT.h compila aqui como está. Cada um é um header próprio do Mokxi sob o nome upstream, escrito sobre os drivers dos componentes da caixa, e nada disso é o código da biblioteca upstream.

  • Wire.begin() coloca o barramento I2C em GPIO 8 (SDA) e GPIO 9 (SCL), a escolha do core do Arduino para esta placa; Wire.begin(sda, scl) o move.
  • EEPROM.h funciona, mas o modelo desta placa não tem EEPROM nem flash gravável, então os bytes vivem em 4 KB de RAM: eles são lidos de volta dentro de uma execução e somem num reset.

O editor de código e a compilação lista o que cada uma cobre e como difere da biblioteca upstream.

Os exemplos

Blink, Button, Serial, Fade, PWM fade, Servo sweep, Counter, Interrupt, WiFi: entre na rede, WiFi: busque a previsão do tempo, WiFi: uma lâmpada em uma página web, Thumb stick, Rainbow strip, Plasma panel, OLED text and shapes, OLED dice, OLED pong, Pong console, Binary clock, Electronic dice, Knight Rider, Morse sender, Simon, Stacker e Talker.

PWM fade e Servo sweep são os dois que usam o LEDC. O primeiro é o mesmo LED pulsante de Fade, feito pelo hardware em vez de manualmente, que é a diferença entre um core acordado em cada microssegundo da forma de onda e um que dorme entre os passos; o segundo move um SG90 com um canal de 50 Hz, em que o que o servo lê é a largura do pulso e não o duty.

Thumb stick e OLED pong são os dois que leem o ADC. A demonstração do stick imprime os dois eixos e acende o LED do lado para o qual você empurra, forte ou fraco dependendo de quanto; OLED pong é o jogo do stick do Uno nesta placa, com a raquete seguindo o potenciômetro Y do stick em GPIO 0 e a pontuação na fonte 5x7 para a qual o Uno não tem espaço.

As demonstrações da fita e do painel foram escritas para esta placa. O mesmo driver de WS2812 também roda nas placas AVR, no resto da família ESP32, no Pico e no Uno R4.

Stacker é o da página inicial. Duas matrizes 8x8 de MAX7219 ficam uma sobre a outra, formando um campo de jogo com oito pixels de largura e dezesseis de altura, e um botão de fliperama de 30 mm no GPIO 3 derruba o bloco deslizante. Elas estão ligadas em cascata do jeito que o chip foi feito para funcionar: os dados no GPIO 7 chegam só ao módulo de cima, seu DOUT alimenta o DIN do módulo de baixo, e o clock no GPIO 5 e o único chip select no GPIO 6 vão para os dois. O sketch envia dois pacotes entre um par de bordas de CS, o do módulo de baixo primeiro, porque o pacote enviado primeiro é empurrado mais longe na cadeia. As matrizes são alimentadas pelo pino 5V da placa em vez do 3V3, porque um MAX7219 quer quatro volts ou mais. Se ninguém apertar o botão por quatro segundos, o sketch joga sozinho, e um aperto devolve o jogo.

MicroPython

Escolha MicroPython (main.py) no painel Firmware da placa, e Rodar inicia o firmware oficial do MicroPython v1.29.0 para o ESP32-C3 com o seu main.py, em um modelo do chip inteiro inicializado a partir da própria ROM da Espressif. machine.Pin, PWM, ADC, I2C, SPI, UART(1) e neopixel funciona, e network.WLAN entra na rede simulada. Veja MicroPython no ESP32.

Em outros lugares