A visão geral, com exemplos rodando, está na página da placa e O modelo do ESP32 DevKit (todos os registradores).
O que é
A DOIT ESP32 DevKit V1, um módulo ESP32-WROOM-32 numa placa de trinta pinos, rodando no nosso próprio core Xtensa, a primeira placa aqui cujo conjunto de instruções não é nem RISC-V, nem AVR nem Arm. O firmware é um ELF Xtensa que conversa com os endereços reais do ESP32.
A placa mede 51,5 por 28,3 mm e suas duas fileiras de quinze pinos ficam a 0,9 polegada de distância, então ela atravessa o canal central da protoboard deixando uma fileira de furos livre de cada lado.
This is the thirty-pin DOIT board, not the 38-pin Espressif DevKitC. The DevKitC is a full inch between rows, leaves no row free at all, and brings out more pins. If your board has 38 pins, use o ESP32-DevKitC V4, que é uma placa própria na caixa de componentes.
Os pinos
Quinze pinos em cada lateral longa, o conector micro-USB embaixo, o módulo e sua antena de PCB em cima.
Coluna esquerda, de cima a baixo: EN, VP, VN, D34, D35, D32, D33, D25, D26, D27, D14, D12, GND, D13, VIN.
Coluna direita, de cima a baixo: D23, D22, TX0, RX0, D21, D19, D18, D5, TX2, RX2, D4, D0, D2, D15, 3V3.
Dn é o GPIO n. VP é o GPIO 36 e VN é o GPIO 39, nomeados na serigrafia pela função e não pelo número. EN é o chip enable, que é o reset desta placa. VIN é o trilho de 5 V do USB.
Esta é uma placa de 3,3 volts e seus pinos não toleram 5 V.
Três coisas que o pinout faz com você
Isto é o hardware, não o modelo, e cada uma pega alguém:
- Os GPIO 34 a 39 não podem ser saídas. Nunca. Esses seis pinos têm um buffer de entrada e nada mais: sem driver de saída e sem pull-up ou pull-down internos.
pinMode(34, OUTPUT)escreve o registrador, o bit não fica e o pino continua em alta impedância. Quatro deles estão neste conector:D34,D35,VPeVN. O Mokxi recusa a escrita do mesmo jeito que o chip, conta a ocorrência e coloca uma pequena marca âmbar na placa em vez de deixar você acreditar que um pino está acionando algo. Se precisar de um pull-up em um deles, tem que ser um resistor. - Os GPIO 6 a 11 não estão no conector de forma alguma, porque eles são a flash SPI de onde o programa roda. Em placas que os expõem, acionar um deles para o chip.
- Os GPIO 0, 2, 5, 12 e 15 são pinos de strapping. Eles decidem como o chip dá o boot, então o que está ligado a eles na energização importa. O GPIO 2 também é o LED azul, então o estado dele antes de
pinModerodar varia de placa para placa.
O LED e o botão
LED_BUILTIN é o GPIO 2, um LED azul comum ligado da maneira comum: HIGH o acende. BOOT é o GPIO 0, ativo em nível baixo, e também está no conector como D0, então você pode ligar coisas a ele; clicar nele na placa aterra o pino.
analogRead: oito canais, e 4095 não é onde um trilho de 3,3 V chega
Os oito canais do ADC1 não são os GPIO 0 a 7. São, em ordem, os GPIO 36, 37, 38, 39, 32, 33, 34 e 35, e os 37 e 38 não são expostos num WROOM-32, então o que você realmente alcança é VP, VN, D32, D33, D34 e D35.
Doze bits, e com a atenuação padrão de 11 dB a leitura segue a curva de um ESP32 real em vez de uma linha reta: 0 nos primeiros 80 mV ou algo assim, quase linear no meio e 4095 a partir de cerca de 3,1 V. Um potenciômetro ligado ao trilho de 3,3 V da própria placa portanto chega a 4095 um pouco antes do fim do curso e lê cerca de 1890, e não 2048, no meio. Essa é a parte real, e o exemplo do botão giratório imprime o número bruto para que não haja mistério. analogReadMilliVolts() desfaz a curva e lê volts.
O ADC2 não é modelado. Num ESP32 real o ADC2 é compartilhado com o rádio WiFi e para de funcionar quando o WiFi liga, por isso ninguém o usa; aqui ele simplesmente não existe, então os oito canais acima são todos.
A conversão em linha reta daqui é uma aproximação de um conversor real que curva nas duas pontas e é corrigido a partir de uma curva de calibração gravada no chip. Espere que o modelo seja um pouco mais gentil que o silício perto de 0 V e perto do topo da faixa.
analogWrite é LEDC, e não custa nada ao core
analogWrite(pin, 0..255) conecta um dos oito canais de alta velocidade do LEDC ao pino na primeira vez que é chamado: oito bits a 1 kHz, em qualquer pino com driver de saída, porque o canal chega ao pad pela matriz de GPIO e não por um pino fixo. Quando a frequência importa, ledcAttach(pin, frequency, bits) e ledcWrite(pin, duty) estão lá, e canais que pedem a mesma frequência e resolução compartilham um dos quatro timers.
Como o LEDC é hardware de verdade, um LED com fade aqui não custa nada ao core: o sketch pode ficar em delay() e as bordas ainda chegam no horário. A ESP8266 NodeMCU é o contraste interessante: ela não tem hardware de PWM, então o core dela faz o trabalho. As duas placas são honestas quanto a isso.
Serial
Serial é a UART0, que é a porta onde está a ponte USB de um DevKit, e está ligada ao monitor serial. Os bytes saem na taxa de baud que você definir, então um sketch que imprime mais rápido do que 115200 baud consegue esperar aqui exatamente como espera numa mesa.
Serial1 e Serial2 são a UART1 e a UART2, portas reais nos pinos que você escolher, enviando e recebendo quadros bit a bit pelo fio, então um módulo GPS, um HC-05, um PZEM-004T, um transceptor RS-485 ou uma segunda placa nesses pinos os escuta:
Serial2.begin(9600, SERIAL_8N1, 16, 17); // RX, TX: the pins marked RX2 and TX2
O que eles fazem é o que o core arduino-esp32 3.x faz:
- Sem pinos,
Serial1.begin(9600)usa os GPIO 26 (RX) e 27 (TX) eSerial2.begin(9600)os GPIO 4 e 25. O core 2.x usava 16 e 17 paraSerial2, por isso tutoriais antigos deixam os pinos de fora; o Mokxi avisa isso uma vez no monitor quando um sketch faz isso.setPins(rx, tx)os move, antes ou depois debegin(). - O quadro pode ser qualquer um de
SERIAL_5N1aSERIAL_8O2, e o parâmetroinvertdebegin()inverte as duas linhas. - Os bytes recebidos chegam ao sketch em blocos, como no driver do ESP-IDF: a UART move sua FIFO para um buffer circular de 256 bytes (
setRxBufferSize()antes debegin()) quando 120 bytes tiverem chegado (setRxFIFOFull()) ou quando a linha estiver em silêncio pelo tempo de um caractere (setRxTimeout()).available()conta o buffer circular, então um byte ainda na FIFO ainda não está disponível. Um sketch que lê devagar demais perde bytes do mesmo jeito que perde na bancada. onReceive()é chamado depois de cada bloco, entreloop()s e enquanto o sketch espera emdelay(), e não a partir de uma task do FreeRTOS.write()espera enquanto a FIFO de 128 bytes está cheia, eflush()até o último bit de parada sair.setTxBufferSize()é respeitado, mas não há buffer circular de TX, entãowrite()ainda espera na FIFO.
Controle de fluxo por hardware, modo RS-485, IrDA e autobaud não são modelados. O pino de TX precisa de um driver de saída, então GPIO 34 a 39 só podem ser RX. SoftwareSerial.h também continua funcionando em quaisquer dois pinos.
Um núcleo, não dois
Um ESP32 real tem dois núcleos Xtensa LX6, e um sketch do Arduino aqui roda em um: sem APP CPU, sem interrupção entre núcleos e sem FreeRTOS para fazer o escalonamento entre eles. Um sketch escrito com base em setup() e loop() nunca percebe. Qualquer coisa que inicie uma tarefa no núcleo 1 não vai rodar.
Um firmware que você mesmo compilou é diferente: MicroPython e uma compilação do ESP-IDF rodam em um modelo do chip inteiro, onde os dois núcleos de fato rodam (abaixo).
What is modeled
O Xtensa LX6 em seu ABI com janela de registros (o único ABI que seu compilador gera), com a register window, os manipuladores de window overflow e underflow, e as interrupções de nível 1. Ao redor: a matriz de GPIO e o IO_MUX, a UART0, o timer 0 do grupo de timers 0 atrás de millis() e micros(), o ADC1 em modo one-shot através do bloco SENS, o grupo de alta velocidade do LEDC, e tanto da matriz de interrupções do DPORT quanto duas fontes precisam.
Esse é o conjunto de que pinMode, digitalWrite, digitalRead, analogRead, analogWrite, ledcAttach, ledcWrite, millis, micros, delay, attachInterrupt e Serial precisam, nos seus endereços reais.
WiFi, simulated
Não há rádio. Nunca vai haver: um MAC 802.11 não é algo que este modelo pudesse reproduzir com honestidade.
O que existe no lugar é uma rede simulada. Um bloco que é do próprio Mokxi, e não do chip (uma caixa de correio em 0x3FEF_E000, onde um ESP32 real não tem nada mapeado) dá suporte a WiFi.h, HTTPClient.h e WebServer.h, então o código Arduino de um tutorial funciona aqui: a placa entra num 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 dá a ela o IP 192.168.4.2, e um sketch pode baixar 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.
O endereço está no vão que o barramento de dados do chip deixa entre as janelas de memória externa e a janela de periféricos, então uma imagem que o use falha no silício em vez de ler o registrador de outro periférico. Bluetooth é simulado pelo mesmo bloco, Classic e LE, com um celular no painel Bluetooth do editor e sem rádio (Bluetooth, simulado).
Três exemplos acompanham esta placa: WiFi: conectar na rede, WiFi: buscar a previsão do tempo e WiFi: uma lâmpada numa página web.
WiFi, simulado é como usar; WiFi simulado é o contrato, limite por limite.
O que não é
Um rádio de qualquer tipo. Não há rádio 802.11 nem Bluetooth no modelo, nem a pretensão de haver; o WiFi e o Bluetooth acima são simulados e dizem isso. O segundo núcleo. A FPU: toda instrução de ponto flutuante gera uma falha aqui, em vez de retornar um número errado, e o runtime usa soft float, então float funciona e binários de fornecedor com hard float não. O cache, a flash e a PSRAM: o código roda da RAM interna. O RTC, o coprocessador ULP e o deep sleep. ADC2, o sensor de toque e o sensor de efeito Hall. Os controladores I2C e SPI, I2S e RMT. Wire e SPI no runtime são software em pinos comuns, como em toda placa aqui: Wire.begin() coloca SDA no 21 e SCL no 22, e SPI usa 18 (SCK), 19 (MISO), 23 (MOSI) e 5 (SS). Adafruit_NeoPixel.h controla uma fita WS2812 cronometrando cada bit no contador de ciclos do núcleo, já que o RMT que um ESP32 real usaria não está aqui. Os grupos de timer além do primeiro timer do grupo 0 e do seu watchdog (que roda o task watchdog, como o ESP-IDF faz).
Binários do ESP-IDF e do core Arduino de fornecedor não vão rodar aqui: o runtime é nosso.
Compilando o seu sketch
Edite o sketch e aperte Rodar: ele compila na aba, como em qualquer outra placa aqui, com um clang real compilado para WebAssembly. Para este chip é o próprio clang da Espressif, que tem o back end Xtensa, então a primeira compilação num ESP32 baixa uma toolchain separada (clang-v3, cerca de 80 MB, uma única vez) e as compilações seguintes a reaproveitam. Nada é enviado. Um exemplo intocado ainda roda o programa pré-compilado; mude uma linha e Rodar compila o seu.
A aritmética de ponto flutuante funciona: este modelo não tem FPU, então a compilação faz somas de float e double em software, como nas placas sem FPU algum. Compilando no navegador tem o relato completo.
The full list of what the model implements, and a plain account of which register addresses came out of the technical reference manual and which are this model's belief, is in o modelo do ESP32 DevKit. A seção 6 é a que se deve ler antes de levar uma compilação daqui para o silício de verdade.
As bibliotecas padrão do Arduino que as outras placas compilam (Servo.h, Wire.h, EEPROM.h, Adafruit_SSD1306.h e o resto) também estão no caminho de includes aqui. Wire.h, Adafruit_NeoPixel.h e Keypad.h foram verificadas nesta placa, com um scan de I2C nos pinos 21 e 22, uma fita acesa e um teclado 4x4; as outras ainda não foram verificadas aqui.
MicroPython
A placa pode rodar Python em vez de um sketch. Escolha MicroPython (main.py)
no painel Firmware e Rodar inicializa o firmware oficial MicroPython v1.29.0 para o ESP32 e roda o seu main.py. Isso roda num modelo do chip inteiro, inicializado pela mask ROM da Espressif, então os limites acima são os do runtime Arduino, não os do MicroPython: machine.I2C, machine.SPI, o RMT por trás de
neopixel e network.WLAN estão lá para ele. Veja
MicroPython no ESP32.
Os exemplos
Blink, Button, Serial, Fade, Knob e os três de WiFi: WiFi: conectar à rede, WiFi: buscar a previsão do tempo e WiFi: uma lâmpada em uma página web. Cada um roda seu programa pronto até você mudá-lo, e então Rodar compila a sua versão.
Um firmware que você mesmo compilou
Um sketch de Arduino é compilado aqui e roda em um core. Um programa compilado em outro lugar, com ESP-IDF ou em Rust (esp-hal, esp-idf-hal), também roda, em um modelo do chip inteiro com ambos os cores: faça upload do seu .bin ou .elf no painel de Firmware, e a placa inicializa com ele como após idf.py flash. Wi-Fi e Bluetooth são uma lacuna, já que seus drivers são as bibliotecas fechadas da Espressif: um firmware que inicia qualquer um dos dois para com uma linha avisando isso. Os passos e a lista completa estão em
Rodar um firmware pronto.
Em outros lugares
- A página da placa: /boards/esp32-devkit
- O documento de contrato: o modelo do ESP32 DevKit
- A outra placa Xtensa: o ESP8266 NodeMCU
- O mesmo chip em outras placas: o ESP32-DevKitC V4, o LOLIN32 Lite, a Wemos D1 R32, o Cheap Yellow Display e o TTGO T-Display
- Os ESP32s RISC-V: o ESP32-C3 e o ESP32-C6