Ini adalah referensi teknis untuk modelnya: apa yang diimplementasikan, register demi register, untuk orang yang menulis firmware menggunakannya. Untuk memakai board ini di editor, mulai dari ESP32 DevKit V1 dan halaman board.
ESP32 DevKit V1 adalah board DOIT tiga puluh pin di sekitar modul ESP32-WROOM-32: Xtensa LX6 pada 240 MHz, komponen pertama di sini yang bukan RISC-V, bukan AVR, dan bukan Arm. Satu komponen kernel (esp32 di crates/parts) membungkus model SoC ESP32 (crates/esp32) di atas interpreter Xtensa (crates/xtensa-core). Dokumen ini adalah kontraknya, dan dia menang atas komentar apa pun di dalam kode.
Tipe katalognya adalah esp32. String program katalognya adalah elf32 xtensa lx6 esp32.
Baca bagian 6 dulu jika kamu membawa build dari sini ke silikon sungguhan. Di sana dijelaskan, alamat demi alamat, angka mana yang berasal dari ESP32 Technical Reference Manual dan mana yang merupakan keyakinan model ini, plus daftar apa saja yang tidak ada di sini sama sekali: antara lain core kedua, cache, flash, PSRAM, dan kedua radio. Tidak ada yang dikira-kira diam-diam.
Sketch untuk board ini dikompilasi di browser dengan clang-v3, build wasm dari fork LLVM Espressif (-mcpu=esp32), diterbitkan 2026-09-28 dan diuji di simulator ini (docs/compile.md). Contoh yang belum diubah tetap menjalankan ELF bawaannya dari web/public/firmware/esp32/, yang dibangun oleh GCC milik Espressif. Bagian 7 memuat detailnya.
1. Pin board (urutan katalog)
Dilihat dari atas, soket micro-USB di bawah, modul WROOM-32 beserta antena PCB-nya di atas. Board-nya berukuran 51,5 x 28,3 mm dan dua header 15 pin-nya berjarak 22,86 mm (0,9 inci), itulah yang membuat DOIT DevKit V1 bisa mengangkangi breadboard dengan satu baris lubang tetap kosong di tiap sisi. Gambar visual menggambarnya dalam ukuran itu.
Espressif DevKitC 38 pin adalah board lain yang orang maksud dengan "ESP32 DevKit", dan header-nya berjarak satu inci penuh: di breadboard, tidak menyisakan satu baris pun yang kosong. Ini adalah board DOIT tiga puluh pin.
Header kiri, dari atas ke bawah (15 lubang): EN, VP, VN, D34, D35, D32, D33, D25, D26, D27, D14, D12, GND, D13, VIN.
Header kanan, dari atas ke bawah (15 lubang): D23, D22, TX0, RX0, D21, D19, D18, D5, TX2, RX2, D4, D0, D2, D15, 3V3.
30 pin. Dn adalah GPIO n. VP adalah GPIO 36 dan VN adalah GPIO 39: pin SENSOR_VP dan SENSOR_VN milik konverter, yang dinamai sesuai fungsinya pada silkscreen. TX0/RX0 adalah GPIO 1 dan 3, UART untuk konsol; TX2/RX2 adalah GPIO 17 dan 16. EN adalah chip enable, yang menjadi reset pada board ini. VIN adalah jalur 5 V dari USB. Nama yang terduplikasi akan diberi huruf tambahan, karena nama pin di katalog harus unik; board ini tidak punya duplikat.
GPIO 6 sampai 11 tidak ada di kedua header. Itu adalah flash SPI (SD_CLK, SD_DATA0..3, dan SD_CMD), dan program berjalan dari sana. Board yang mengizinkan sketch menggerakkan pin itu akan menjadi board yang merusak dirinya sendiri, jadi mereka bukan pin di sini. crates/parts/src/parts/esp32.rs punya test yang menolak membiarkannya muncul di header.
GPIO 34 sampai 39 tidak punya driver output. Di komponen ini mereka hanya input dan tidak lebih: tanpa push-pull, tanpa open drain, dan tanpa pull-up atau pull-down internal. pinMode(34, OUTPUT) menulis ke GPIO_ENABLE1_REG, bitnya tidak menempel, dan pin tetap high-Z. Empat dari enam pin itu ada di header (D34, D35, VP, VN). Model menghitung setiap percobaan dan komponen board melaporkan jumlahnya lewat probe (bagian 5), karena inilah kesalahan yang membuat pemilik ESP32 kehilangan satu sore, dan simulator yang membiarkannya lewat akan mengajarkan hal yang salah.
Dua pin membawa sesuatu di board:
- GPIO 2 punya LED biru, dan itu LED biasa di pad biasa: level pad-nya adalah lampunya, tidak ada yang mendekode apa pun. Pin ini juga pin strapping, jadi state LED DevKit sungguhan sebelum
pinModeberjalan berbeda-beda antar board. - GPIO 0 adalah tombol BOOT, aktif rendah. Pin ini ada di header kanan sebagai
D0, jadi juga bisa disambung kabel;pokemen-ground-kannya di board.
Listrik: setiap GPIO dengan driver output mendorong push-pull pada 3,3 V melalui R_STRONG, diam di high-Z, atau pull naik atau turun melalui 45 k. Input terbaca tinggi pada 1,65 V (setengah suplai I/O); net yang berkontestasi (Unknown) terbaca 0, dan yang mengambang terbaca noise, seperti pada Uno (docs/uno.md bagian 1). GPIO0 terbaca tinggi saat tidak ada yang menahannya, berkat pull-up bawaan DevKit di samping tombol BOOT. 3V3 mendorong 3,3 V pada R_SUPPLY, VIN mendorong 5 V, GND mendorong 0 V. EN membawa pull-up 10 k ke 3,3 V dan menariknya di bawah 1,65 V menahan core dalam reset. Kapasitor 100 nF di samping resistor itu pada DevKit sungguhan adalah power-on reset board dan tidak dimodelkan, jadi EN di sini hanya resistornya saja.
Urutan silkscreen yang persis dari dua header adalah pembacaan model ini terhadap pinout DOIT DevKit V1. Nomor GPIO adalah milik chip dan menjadi pegangan firmware; posisinya di header adalah pegangan sebuah diagram. Jika baris DevKit tertentu diurutkan secara berbeda (dan memang berbeda antara board 30 pin dan 36 pin), rangkaian yang digambar di sini perlu dirakit ulang di meja kerja, dan tidak ada hal lain yang berubah.
2. Peta memori
| IRAM (instruksi) | 128 KB di 0x4008_0000 sampai 0x4009_FFFF |
| IROM (flash code) | 0x400D_0000, read-only, up to 1,310,720 bytes, section 2.1 |
| DROM (flash constants) | 0x3F40_0000, read-only, up to 1,310,720 bytes, section 2.1 |
| DRAM (data) | 192 KB di 0x3FFB_0000 sampai 0x3FFD_FFFF |
| puncak stack | 0x3FFE_0000 |
| DPORT | 0x3FF0_0000, bagian 3.7 |
| UART0 | 0x3FF4_0000, bagian 3.3 |
| GPIO matrix | 0x3FF4_4000, bagian 3.1 |
| SENS | 0x3FF4_8800, bagian 3.5 |
| IO_MUX | 0x3FF4_9000, bagian 3.2 |
| LEDC | 0x3FF5_9000, bagian 3.6 |
| Timer group 0 | 0x3FF5_F000, bagian 3.4 |
Setiap blok peripheral berukuran 4 KB di sini.
Two windows, not one, and that is the shape of this chip. The ESP32 has three internal SRAMs, two of which are visible through both the instruction bus and the data bus at different addresses, and SRAM1's 32 KB blocks appear in the opposite order through the two. That alias is not modeled. What is modeled is the pair ESP-IDF itself uses and keeps apart: IRAM for code, DRAM for data. The vectors, the exception entry and the startup code go in the 128 KB at 0x4008_0000; the rest of the code and the constants run from flash (section 2.1); .data, .bss and the stack go in the 192 KB at 0x3FFB_0000. A program that tries to read its own .text through the data bus is refused rather than served, because on the real part that read would have come back through the other window with the blocks in a different order.
Every PT_LOAD segment must land inside one of those two ranges or one of the two flash windows; anything else is refused with the offending address in the message, and the chip is left with no program.
2.1 Flash: code and constants
A real ESP32 runs almost all of a sketch from flash through the cache: code is read at IROM (0x400D_0000) and const data at DROM (0x3F40_0000), and the Arduino IDE's default partition table ("Default 4MB with spiffs") gives the sketch 1,310,720 bytes (0x14_0000) of it. That is the room a sketch has here, and the number the editor prints after a build ("Sketch uses N bytes ... Maximum is 1,310,720 bytes"). It counts what the IDE counts: code, literals, constants, the startup code and the initial values of the variables.
What is modeled: two read-only windows over the loaded image. A fetch or a read from either costs what a fetch from IRAM costs, which is the speed of a warm cache; there is no cache to miss and no MMU, and docs/esp32.md section 6 still says so. A store to a flash window faults, as it does on the chip. The code window shares one buffer with the instruction RAM (so a fetch is one range check whichever it is in), which means the unmapped 192 KB between them reads as zeros here, where the chip would fault; a jump into it still stops the core, since an all-zero word is an illegal instruction.
The link script (firmware/esp32/link.ld) puts .text.vectors, .text.exception, .text.start and anything marked .iram in the instruction RAM and every other function in the code window. Its literal pools sit in front of their own functions, because L32R only reaches 256 KB backwards, and every call out of the startup code goes through a register, because CALL4 and CALL8 reach 128 KB. Global variables are still limited by the data RAM (192 KB here); a program over it is refused with "no room for the stack".
Core melakukan reset dengan pc di titik masuk ELF dan setiap register alamat bernilai nol. Tidak ada boot ROM di sini: puluhan milidetik yang dihabiskan ESP32 asli di loader tahap pertamanya, pembacaan flash, pohon clock dan penyiapan cache semuanya tidak ada, dan firmware/esp32/crt0.S membuat state yang diinginkannya eksplisit alih-alih mengasumsikan apa yang ditinggalkan ROM.
3. Register peripheral
Hanya subset di bawah ini yang diimplementasikan. Apa pun di dalam blok 4 KB yang dipetakan selain itu terbaca 0 dan dihitung sebagai akses liar; apa pun di luar setiap blok adalah access fault.
3.1 GPIO matrix (0x3FF4_4000)
Empat puluh pin, jadi setiap register dengan satu bit per pin datang dalam dua bagian: yang polos mencakup GPIO 0 sampai 31 dan yang 1 mencakup GPIO 32 sampai 39 dalam delapan bit rendahnya.
| offset | register |
|---|---|
0x00 |
GPIO_BT_SELECT_REG |
0x04 |
GPIO_OUT_REG |
0x08 |
GPIO_OUT_W1TS_REG |
0x0C |
GPIO_OUT_W1TC_REG |
0x10 |
GPIO_OUT1_REG |
0x14 |
GPIO_OUT1_W1TS_REG |
0x18 |
GPIO_OUT1_W1TC_REG |
0x20 |
GPIO_ENABLE_REG |
0x24 |
GPIO_ENABLE_W1TS_REG |
0x28 |
GPIO_ENABLE_W1TC_REG |
0x2C |
GPIO_ENABLE1_REG |
0x30 |
GPIO_ENABLE1_W1TS_REG |
0x34 |
GPIO_ENABLE1_W1TC_REG |
0x38 |
GPIO_STRAP_REG |
0x3C |
GPIO_IN_REG |
0x40 |
GPIO_IN1_REG |
0x44 |
GPIO_STATUS_REG |
0x48 |
GPIO_STATUS_W1TS_REG |
0x4C |
GPIO_STATUS_W1TC_REG |
0x50 |
GPIO_STATUS1_REG |
0x54 |
GPIO_STATUS1_W1TS_REG |
0x58 |
GPIO_STATUS1_W1TC_REG |
0x88 + 4n |
GPIO_PINn_REG |
0x530 + 4n |
GPIO_FUNCn_OUT_SEL_CFG_REG |
Diverifikasi terhadap manual referensi teknis: alamat dasar blok dan setiap offset dalam tabel ini.
GPIO_PINn_REG bit 2 PAD_DRIVER membuat pad open drain; bit 7..9 INT_TYPE memilih apa yang menaikkan interrupt pin (0 mati, 1 rising, 2 falling, 3 any edge, 4 low level, 5 high level); bit 13 PIN_INT_ENA untuk core PRO membuat pin bisa mencapai matrix sama sekali.
GPIO_FUNCn_OUT_SEL_CFG_REG di 256 membuat pad mengikuti GPIO_OUT. Nilai 71 sampai 78 menyerahkannya ke kanal kecepatan tinggi LEDC 0 sampai 7. Nilai lain memilih peripheral yang tidak dimodelkan, dan model memperlakukannya sebagai 256 alih-alih mengarang suatu level. Pad yang sedang digerakkan kanal LEDC tetap perlu output driver-nya menyala di GPIO_ENABLE.
Belum terverifikasi: indeks sinyal GPIO matrix 71 sampai 78 untuk ledc_hs_sig_out0 sampai ledc_hs_sig_out7. Tabel sinyal matrix bukan sesuatu yang bisa dikutip balik oleh model ini, dan angkanya hanya ada di dua tempat (OUT_SEL_LEDC_HS_SIG di crates/esp32/src/map.rs dan GPIO_FUNC_OUT_SEL_LEDC_HS di firmware/esp32/include/esp32.h), jadi model dan runtime cocok karena keduanya membaca konstanta yang sama, bukan karena salah satunya memeriksa. GPIO_FUNC_OUT_SEL_GPIO = 256 berasal dari manual.
GPIO_STRAP_REG terbaca kembali sebagai 0b1101: GPIO 0, 2 dan 5 tinggi, sisanya rendah, yang merupakan kondisi pabrik sebuah WROOM-32. Di sini nilainya konstan, bukan latch dari kondisi pin saat reset.
Enam pin tanpa output driver (GPIO 34 sampai 39) menerima penulisan ke bit ENABLE1-nya dan tetap membiarkannya nol, dan model menghitung upaya itu (bagian 1, bagian 5).
3.2 IO_MUX (0x3FF4_9000)
IO_MUX_PIN_CTRL_REG di 0x00, lalu satu register per pad. Bit 7 FUN_WPD, bit 8 FUN_WPU, bit 9 FUN_IE, bit 12..14 MCU_SEL yang mana 2 adalah GPIO biasa pada komponen ini. Pad hanya mencapai GPIO_IN_REG jika input buffer-nya aktif, dan itulah yang dilakukan perangkat keras.
IO_MUX ESP32 tidak diindeks berdasarkan nomor GPIO. Register-register itu dalam urutan pad paket dan pemetaan dari GPIO ke pad adalah tabel di manual. Tabel model ini adalah:
| GPIO | offset | GPIO | offset | GPIO | offset | GPIO | offset |
|---|---|---|---|---|---|---|---|
| 0 | 0x44 |
10 | 0x58 |
20 | 0x78 |
32 | 0x1C |
| 1 | 0x88 |
11 | 0x5C |
21 | 0x7C |
33 | 0x20 |
| 2 | 0x40 |
12 | 0x38 |
22 | 0x80 |
34 | 0x14 |
| 3 | 0x84 |
13 | 0x3C |
23 | 0x8C |
35 | 0x18 |
| 4 | 0x48 |
14 | 0x30 |
24 | 0x90 |
36 | 0x04 |
| 5 | 0x6C |
15 | 0x34 |
25 | 0x24 |
37 | 0x08 |
| 6 | 0x60 |
16 | 0x4C |
26 | 0x28 |
38 | 0x0C |
| 7 | 0x64 |
17 | 0x50 |
27 | 0x2C |
39 | 0x10 |
| 8 | 0x68 |
18 | 0x70 |
28..31 | tidak ada | ||
| 9 | 0x54 |
19 | 0x74 |
Dipercaya, bukan diverifikasi. Tabel ini adalah pembacaan model ini terhadap urutan pad dan bukan halaman yang dikutip balik. Tabel ini ada di dua tempat, IOMUX_INDEX di crates/esp32/src/map.rs dan mokxi_iomux_index[] di firmware/esp32/src/gpio.c, jadi model dan runtime saling cocok entah sepakat dengan silikon atau tidak. GPIO 28 sampai 31 tidak ada pada komponen ini dan tidak punya register.
Setiap pad menyala di FUN_IE | (2 << 12) di sini: GPIO biasa dengan input buffer aktif. Nilai reset per pad di manual berbeda (pin strapping dan pin flash muncul dengan pull), dan model ini memberi setiap pin state netral yang sama supaya program yang hanya menulis GPIO_ENABLE dan GPIO_OUT berperilaku sama di setiap pin. Bagian 6 mengulang hal ini sebagai pendekatan, bukan sebagai alamat.
3.3 UART0 (0x3FF4_0000)
| offset | register |
|---|---|
0x00 |
UART_FIFO_REG |
0x04 |
UART_INT_RAW_REG |
0x08 |
UART_INT_ST_REG |
0x0C |
UART_INT_ENA_REG |
0x10 |
UART_INT_CLR_REG |
0x14 |
UART_CLKDIV_REG |
0x1C |
UART_STATUS_REG |
0x20 |
UART_CONF0_REG |
0x24 |
UART_CONF1_REG |
Terverifikasi: basis dan setiap offset, dua bit reset FIFO dan lebar dari dua hitungan FIFO di bawah. Ini adalah IP UART yang sama dengan milik ESP32-C3 dan ESP8266, register demi register, itulah sebabnya crates/esp32/src/uart.rs dan crates/esp8266/src/uart.rs adalah file yang sama dua kali.
Dua FIFO 128 byte. Bit 17 RXFIFO_RST dan bit 18 TXFIFO_RST pada UART_CONF0_REG mengosongkannya: ESP32 Technical Reference Manual (v5.8), register 19.9 UART_CONF0_REG, menempatkan TXFIFO_RST di bit 18 dan RXFIFO_RST di bit 17. Versi lebih awal dari model ini dan dari firmware/esp32/include/esp32.h menempatkan keduanya tertukar. Serial.begin pada runtime menyetel lalu menghapus kedua bit bersamaan, jadi nilai yang ditulisnya sama apa pun urutannya dan image-nya tidak terpengaruh.
UART_CONF1_REG bit 0..6 adalah RXFIFO_FULL_THRHD dan bit 8..14 TXFIFO_EMPTY_THRHD, keduanya 96 saat reset (register 19.10); versi model ini yang lebih awal punya field sembilan bit di 0 dan 9, dan runtime tidak pernah menulis register ini. UART_CLKDIV_REG bit 0..19 adalah bagian integral dari pembagi (register 19.6; bagian pecahan di bit 20..23 tidak dimodelkan). Pembagi membagi clock APB 80 MHz dan di-reset ke 694, yaitu 115 274 baud: cukup dekat dengan 115200 sehingga monitor tidak peduli, dan persis seperti yang diberikan angka itu. Dulu pengaturan tempo pengiriman hanya membaca dua belas bitnya, jadi Serial.begin(9600), yang pembaginya 8333, mengirim byte sekitar 59 kali terlalu cepat; sekarang dibaca seluruh dua puluh bitnya.
UART_STATUS_REG bit 0..7 adalah RXFIFO_CNT dan bit 16..23 TXFIFO_CNT (register 19.8). Bit 8..11 dan 24..27 di atasnya adalah mesin status penerima dan pengirim (ST_URX_OUT, ST_UTX_OUT). Model ini mengembalikan kedua hitungan pada posisi tersebut dan 0 pada bit mesin status, karena model tidak menjalankan mesin status tersebut. Runtime membaca delapan bit, sesuai field yang diberikan manual. Runtime versi sebelumnya membaca sepuluh bit, yang di sini memberikan angka yang sama karena bit di atasnya terbaca 0, tetapi pada silikon akan mengambil dua bit ST_UTX_OUT: hitungan kirim akan terbaca 256 atau lebih saat satu byte sedang dikirim lewat kabel, dan Serial.write, yang menunggu ruang di FIFO, akan menunggu selamanya. Image dibangun ulang saat itu diperbaiki, dan crates/esp32/tests/contract.rs menjaga mask header agar sesuai dengan milik model.
Byte keluar dari FIFO kirim dengan laju baud, tidak seketika. Tanpa itu program yang mencetak dalam loop mengosongkan FIFO-nya secepat mengisinya, TXFIFO_CNT tidak pernah naik, dan firmware yang memeriksanya sebelum menulis tidak pernah harus menunggu. Dengan itu port 115 200 baud membawa 11 520 byte per detik di sini persis seperti di meja kerja, dan crates/esp32/tests/runtime.rs mengukur jeda antara dua byte dari contoh serial terhadap 86.8 us yang dibutuhkan satu byte.
3.3a UART1 (0x3FF5_0000) dan UART2 (0x3FF6_E000)
Blok register UART0 dua kali lagi, di REG_UART_BASE(1) dan REG_UART_BASE(2) milik ESP-IDF, dengan offset yang sama. Diverifikasi terhadap soc/esp32/register/soc/uart_reg.h milik ESP-IDF: basisnya, offsetnya, dan field di bawah. Berbeda dengan UART0, keduanya tidak tersambung ke channel host mana pun: keduanya mencapai rangkaian hanya lewat matriks GPIO (bagian 3.1), satu bit demi satu bit.
- Pengaturan matriks. Sinyal 17 di
GPIO_FUNCn_OUT_SEL_CFG_REGadalahU1TXD, 198 adalahU2TXD;GPIO_FUNCm_IN_SEL_CFG_REG(di0x130 + 4m, ada 256) untuk sinyal 17 adalahU1RXDdan untuk 198U2RXD, denganSIG_IN_SEL(bit 7) mengambil GPIO diIN_SEL(bit 0..5) danIN_INV_SEL(bit 6) membaliknya. Angka-angkanya darigpio_sig_map.hmilik ESP-IDF.INV_SELpadaOUT_SEL(bit 9) membalik keluaran. Sinyal denganSIG_IN_SELyang kosong datang dari pad IO_MUX-nya di chip; jalur itu tidak dimodelkan (garisnya terbaca idle), dan runtime merutekan setiap pin lewat matriks, yang di silikon juga berfungsi di semua pin. - Frame-nya.
UART_CONF0_REGPARITY/PARITY_EN(bit 0 dan 1),BIT_NUM(2..3, lima sampai delapan bit) danSTOP_BIT_NUM(4..5: satu, satu setengah, dua). Di chip, dua stop bit memerlukan workaroundRS485_CONF.DL1_ENmilik ESP-IDF; di siniSTOP_BIT_NUM3 berarti dua saja.RXD_INV(19) danTXD_INV(22) membalik garisnya,ERR_WR_MASK(26) menjaga byte dengan error framing atau paritas agar tidak masuk FIFO. - Clock-nya.
TICK_REF_ALWAYS_ON(bit 27, terpasang saat reset) membagi clock APB 80 MHz; jika kosong,REF_TICK1 MHz, yang diambil ESP-IDF hingga 250 000 baud.UART_CLKDIV_REGberisi bagian integral di bit 0..19 dan per enam belas diCLKDIV_FRAG, bit 20..23, keduanya dimodelkan: 9600 baud dariREF_TICKadalah 104 dan 2/16, satu bit 104.125 us, 9603.8 baud, seperti di chip. - FIFO dan ambang batas. 128 byte tiap arah. Sebuah byte dimulai begitu shift register kosong dan byte berikutnya mengikuti stop bit terakhirnya tanpa jeda (
tx_idle_num0, seperti yang dipasang ESP-IDF).TXFIFO_CNTmenghitung byte yang masih menunggu, bukan yang sedang keluar, danST_UTX_OUT(24..27) sertaST_URX_OUT(8..11) melaporkan slot tempat tiap state machine berada, 0 saat idle. Bit 15STATUSadalah garis terima dan bit 31 garis kirim. - Terima. Tepi turun pada garis idle memulai sebuah frame; start bit diperiksa di tengahnya (glitch diabaikan), setiap bit lain disampling di tengah slotnya dan byte mendarat di tengah stop bit. Inti berjalan hingga satu irisan di depan rangkaian, jadi penerima hanya men-sampling waktu yang sudah dilaporkan rangkaian.
- Interupsi.
RXFIFO_FULL(bit 0) danTXFIFO_EMPTY(1) terhadap ambangCONF1,PARITY_ERR(2),FRM_ERR(3),RXFIFO_OVF(4),RXFIFO_TOUT(8) danTX_DONE(14), pada sumber matriks interupsi 35 dan 36.RX_TOUT_ENdanRX_TOUT_THRHD(bit 31 dan 24..30 padaCONF1) mengatur timeout dalam satuan yang ditulisuart_ll_set_rx_toutmilik ESP-IDF: delapan waktu bit per satuan dari APB, seperdelapan dariREF_TICK. - Tidak dimodelkan: flow control perangkat keras dan perangkat lunak, RS-485, IrDA, autobaud, break, bit loopback, detektor perintah AT dan bit pengaktif clock serta reset
DPORT(kedua UART selalu mendapat clock). Register-register mereka menyimpang.
UART yang tidak pernah ditulis program tidak membebani simulator sama sekali: tidak ada yang diperiksa di jalur mana pun sampai salah satu registernya ditulis, dan crates/esp32/src/bus.rs punya tes yang menyatakannya.
Serial1 dan Serial2 milik runtime (firmware/esp32/src/uartn.c) menggerakkan keduanya seperti yang dilakukan core arduino-esp32 3.x dan driver ESP-IDF; docs/help/boards/esp32-devkit.md menjelaskan apa yang dilihat sebuah sketch.
3.4 Grup timer 0, timer 0 (0x3FF5_F000)
Penghitung 64 bit di balik micros() dan millis().
| offset | register |
|---|---|
0x00 |
TIMG_T0CONFIG_REG |
0x04 |
TIMG_T0LO_REG |
0x08 |
TIMG_T0HI_REG |
0x0C |
TIMG_T0UPDATE_REG |
0x10 |
TIMG_T0ALARMLO_REG |
0x14 |
TIMG_T0ALARMHI_REG |
0x18 |
TIMG_T0LOADLO_REG |
0x1C |
TIMG_T0LOADHI_REG |
0x20 |
TIMG_T0LOAD_REG |
0x98 |
TIMG_INT_ENA_TIMERS_REG |
0x9C |
TIMG_INT_RAW_TIMERS_REG |
0xA0 |
TIMG_INT_ST_TIMERS_REG |
0xA4 |
TIMG_INT_CLR_TIMERS_REG |
Terverifikasi: alamat basis blok ini. Diyakini alih-alih diverifikasi: setiap offset di tabel ini. Basisnya milik manual; tata letak di dalamnya milik model ini, dan sama di crates/esp32/src/map.rs dan firmware/esp32/include/esp32.h.
Bit 31 T0CONFIG EN, bit 30 INCREASE, bit 29 AUTORELOAD, bit 13..28 DIVIDER, bit 10 ALARM_EN. Runtime memasang DIVIDER ke 80, yaitu satu tick per mikrodetik dari clock APB 80 MHz.
Pembacaan dilakukan latch lalu baca, seperti yang disyaratkan perangkat keras: tulis T0UPDATE, lalu baca T0HI dan T0LO. Penghitungnya tidak dihitung. Ia adalah waktu simulasi dibagi pembagi, seperti SYSTIMER milik C3, jadi tidak ada yang bisa bergeser padanya dan firmware yang busy-wait pada micros() mengukur tepat waktu yang dilihat berlalu oleh bagian rangkaian lainnya.
Alarm sudah diimplementasikan dan TIMG_INT_RAW naik saat counter melewatinya, tetapi tidak ada jalur interrupt yang keluar dari blok ini. Tidak ada yang meroutenya ke interrupt matrix. Tick milidetik model ini berasal dari CCOMPARE0 milik core itu sendiri (bagian 4), yaitu register core yang tersambung ke CPU interrupt tetap sehingga tidak berada di belakang alamat mana pun yang harus ditebak model ini. TIMG_INT_ST tetap bisa di-poll dan dihapus.
Timer 1 dari timer group 0 dan seluruh timer group 1 tidak ada; watchdog timer group 0 adalah milik bagian 3.9.
3.5 SENS: ADC1, one shot (0x3FF4_8800)
ADC1 dalam mode one-shot: jalur adc1_get_raw dan analogRead milik Arduino core berlaku pada bagian ini, dan tidak ada yang lain.
| offset | register | bit |
|---|---|---|
0x00 |
SENS_SAR_READ_CTRL_REG |
tersimpan, bisa dibaca kembali; waktu konversi di sini tetap |
0x34 |
SENS_SAR_ATTEN1_REG |
dua bit atenuasi per kanal, kanal n di bit 2n..2n+1 |
0x54 |
SENS_SAR_MEAS_START1_REG |
bit 0..15 MEAS1_DATA_SAR (hasilnya, hanya baca), bit 16 MEAS1_DONE_SAR, bit 17 MEAS1_START_SAR, bit 18 MEAS1_START_FORCE, bit 19..26 SAR1_EN_PAD (satu bit per kanal), bit 31 SAR1_EN_PAD_FORCE |
Terverifikasi: alamat basisnya. Diyakini alih-alih diverifikasi: tiga offset dan setiap posisi bit di dalamnya. Itu adalah pembacaan model ini atas blok SENS, dalam artian yang sama seperti bagian 3.5 di docs/esp32c3.md menandai offset SAR milik C3 sendiri. Firmware yang dibangun di sini cocok dengan model ini, entah cocok dengan silikon atau tidak.
Satu konversi: taruh atenuasinya di ATTEN1, set START_FORCE dan EN_PAD_FORCE, taruh bit kanalnya di SAR1_EN_PAD, naikkan MEAS1_START_SAR, tunggu MEAS1_DONE_SAR, lalu baca datanya. Satu konversi memakan waktu simulasi tetap 5 us, dan firmware sungguhan memang menunggunya.
Delapan kanal, dan di ESP32 ini bukan GPIO n:
| kanal | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|---|
| GPIO | 36 | 37 | 38 | 39 | 32 | 33 | 34 | 35 |
Kanal 0 adalah SENSOR_VP dan kanal 3 adalah SENSOR_VN; 37 dan 38 tidak di-bond out pada WROOM-32, jadi empat kanal yang DevKit keluarkan sebagai angka biasa adalah kanal 4 sampai 7. Tabel itu milik manual.
Hasilnya adalah dua belas bit dari tegangan net pada saat konversi dimulai. Pada 0, 2.5 dan 6 dB hasilnya adalah garis lurus nominal dari datasheet, round(4095 x Vin / Vfull) yang di-clamp, dengan skala penuh 1.1 V, 1.5 V dan 2.2 V. Pada 11 dB, default dari Arduino core, hasilnya adalah kurva mentah komponen aslinya (CURVE_11DB di crates/esp32/src/adc.rs): 0 sampai sekitar 80 mV, hampir linear di bagian tengah, melengkung ke atas di dekat puncak dan jenuh di 4095 mulai sekitar 3.15 V. Skala penuh nominal 3.9 V bukanlah perilaku pembacaan mentah; datasheet hanya menjanjikan akurasi dari 150 sampai 2450 mV pada 11 dB, dan hitungan mentah komponen tipikal mencapai batas jauh sebelum 3.9 V. Jadi potensiometer yang dipasang melintasi rail 3.3 V terbaca 0 sampai 4095, mencapai 4095 sedikit sebelum ujung jalannya, setengah rail (1.65 V) terbaca sekitar 1890, dan map(analogRead(pin), 0, 4095, 0, 180) memutar servo sampai satu putaran penuh. Titik-titiknya adalah pendekatan orde keempat yang banyak dipakai dari hasil pengukuran ESP32s, dibalik; kalibrasi eFuse sebuah unit menggesernya beberapa persen, dan hal itu tidak dimodelkan. analogReadMilliVolts membalik kurva yang sama, seperti yang dilakukan kalibrasi core, jadi terbaca sekitar 1650 pada 1.65 V. Kanal dengan pin kosong bergerak tidak menentu, seperti input yang mengambang (docs/uno.md bagian 1).
Fungsi transfer konverter aslinya melengkung di kedua ujung dan dikoreksi keluar dari kurva kalibrasi eFuse. Semua itu tidak dimodelkan: yang ini garis lurus. Bagian 6 mencatatnya sebagai aproksimasi.
ADC2 (yang di ESP32 asli dipakai bersama WiFi), jalur DMA dan tabel pola, pengendali digital, eFuse kalibrasi, referensi internal, sensor sentuh dan sensor hall semuanya tidak ada.
3.6 LEDC, grup kecepatan tinggi (0x3FF5_9000)
Pengendali LED PWM. Grup kecepatan tinggi adalah yang dijangkau ledcSetup, ledcAttachPin dan ledcWrite dengan kanal 0 sampai 7, dan itulah yang dipakai analogWrite di sini: empat timer dan delapan kanal.
| offset | register | bit |
|---|---|---|
0x00 + 0x14n |
LEDC_HSCHn_CONF0_REG |
bit 0..1 TIMER_SEL, bit 2 SIG_OUT_EN, bit 3 IDLE_LV, bit 4 PARA_UP (tersimpan; duty yang ditulis di sini langsung berlaku) |
0x04 + 0x14n |
LEDC_HSCHn_HPOINT_REG |
bit 0..19 HPOINT: hitungan saat pulsa dimulai |
0x08 + 0x14n |
LEDC_HSCHn_DUTY_REG |
bit 0..24 DUTY: lebar pulsa dalam seperenam belas hitungan |
0x0C + 0x14n |
LEDC_HSCHn_CONF1_REG |
perangkat keras duty-fade: tersimpan, bisa dibaca kembali, dan tidak mem-fade apa pun |
0x10 + 0x14n |
LEDC_HSCHn_DUTY_R_REG |
duty seperti adanya, hanya baca |
0x140 + 8n |
LEDC_HSTIMERn_CONF_REG |
bit 0..4 DUTY_RES, 1 sampai 20 bit (0 adalah timer yang tak dikonfigurasi siapa pun dan tidak menghitung apa pun), bit 5..22 CLK_DIV, bit 23 PAUSE, bit 24 RST |
0x144 + 8n |
LEDC_HSTIMERn_VALUE_REG |
counter, hanya baca |
0x180 |
LEDC_INT_RAW_REG |
bit n = timer n meluap |
0x184 |
LEDC_INT_ST_REG |
raw dan diaktifkan |
0x188 |
LEDC_INT_ENA_REG |
tersimpan; tidak ada jalur yang sampai ke core |
0x18C |
LEDC_INT_CLR_REG |
tulis 1 untuk menghapus |
0x190 |
LEDC_CONF_REG |
bit 0..1 APB_CLK_SEL, 1 = jam APB 80 MHz, satu-satunya sumber yang dimodelkan |
0x1FC |
LEDC_DATE_REG |
terbaca 0x1605_3100 |
Terverifikasi: alamat basis bloknya. Diyakini bukan diverifikasi: seluruh layout di dalamnya: stride kanal, blok timer di 0x140, dan register interrupt dan config di 0x180 ke atas.
Sebuah timer menghitung 2^DUTY_RES hitungan pada 80 MHz dibagi CLK_DIV, bilangan Q10.8 jam APB per hitungan:
f = 80e6 / ((CLK_DIV / 256) * 2^DUTY_RES)
jadi 5 kHz pada delapan bit adalah DUTY_RES 8 dengan CLK_DIV 16000, tepat. Sebuah kanal memilih timer, hitungan awal HPOINT dan sebuah duty, dan outputnya tinggi mulai dari HPOINT selama DUTY >> 4 hitungan, membungkus di puncak periode. Duty 0 adalah rendah terus-menerus dan duty 2^DUTY_RES << 4 tinggi terus-menerus tanpa tepi sama sekali, itulah sebabnya Arduino core mengubah ledcWrite(pin, 255) pada delapan bit menjadi duty 256 dan bukan 255, yang akan meninggalkan takik satu hitungan setiap periode.
Sebuah kanal mencapai pad melalui GPIO matrix: set bit GPIO_ENABLE pad dan arahkan GPIO_FUNCn_OUT_SEL_CFG_REG-nya ke 71 + channel (bagian 3.1, dan indeks itulah yang belum terverifikasi).
Counter tidak ditambah langkah demi langkah: ia fungsi bentuk-tertutup dari waktu simulasi, begitu juga waktu tepi berikutnya. Core yang parkir di waiti jadi tidak memakan biaya apa pun selama PWM berjalan, dan board dibangunkan hanya untuk tepi-tepi itu dan tidak untuk yang lain. crates/esp32/tests/runtime.rs mengukur periode contoh fade terhadap 1 ms dari 1 kHz dalam toleransi 5 us.
Tidak dimodelkan: grup kecepatan rendah (ESP32 punya satu, dengan empat timer, delapan kanal dan jam lambatnya sendiri; tidak ada di runtime yang memakainya), perangkat keras duty-fade, counter overflow milik kanal itu sendiri, sumber jam selain APB, dan jalur LEDC ke interrupt matrix: LEDC_INT_RAW_REG bisa di-poll dan dihapus tetapi tidak pernah mencapai core.
3.7 DPORT dan interrupt matrix (0x3FF0_0000)
Di ESP32 sebuah periferal tidak punya CPU interrupt tetap. Ia punya nomor sumber, dan register peta matrix untuk sumber itu menyatakan interrupt mana dari 32 interrupt core yang ia naikkan. Itulah sebabnya attachInterrupt di sini adalah tiga penulisan, bukan satu: konfigurasikan pin, rutekan sumbernya, buka mask CPU interrupt-nya.
| offset | register |
|---|---|
0x104 + 4n |
DPORT_PRO_..._INTR_MAP_REG untuk sumber n |
96 sumber. Sebuah register map menyimpan nomor interrupt CPU di lima bit rendahnya; sumber yang dipetakan ke 0 menaikkan interrupt 0, yang tidak diaktifkan oleh apa pun, jadi tidak terjadi apa-apa, sama seperti yang dilakukan perangkat keras aslinya, dan begitulah cara sebuah sumber dimatikan.
Terverifikasi: DPORT_BASE = 0x3FF0_0000. Dipercaya, bukan terverifikasi: offset array map 0x104, dan dua nomor sumber yang dirutekan model ini:
| sumber | nomor |
|---|---|
| GPIO | 22 |
| UART0 | 34 |
| UART1 | 35 |
| UART2 | 36 |
milik UART1 dan milik UART2 terverifikasi terhadap urutan di soc/esp32/include/soc/interrupts.h milik ESP-IDF, yang juga menempatkan GPIO di 22 dan UART0 di 34. Hanya sumber-sumber ini, dan watchdog timer group 0 (bagian 3.9), yang mencapai sesuatu. Setiap register map lainnya disimpan dan dapat dibaca kembali tetapi tidak merutekan apa pun, karena tidak ada hal lain dalam model ini yang menaikkan interrupt. Sisa DPORT (kontrol cache dan MMU, register kontrol APP-CPU, gerbang clock dan reset peripheral, arbitrase DMA) tidak ada.
3.8 Kotak surat jaringan Mokxi (0x3FEF_E000)
Blok ini bukan milik ESP32. Setiap alamat lain dalam dokumen ini adalah alamat chip, dikutip dari manual referensi teknis, dan image yang dibangun dengannya adalah image untuk WROOM-32 sungguhan. Yang ini milik Mokxi sendiri: jaringan simulasi dari crates/net, di celah yang ditinggalkan bus data antara jendela memori eksternal (yang berakhir di 0x3FBF_FFFF) dan jendela peripheral (yang dimulai di DPORT, 0x3FF0_0000), rentang yang dicadangkan chip dan tidak menjawab apa pun di dalamnya, sehingga image yang menggunakannya fault di silicon alih-alih membaca register peripheral lain. Fault itu adalah jawaban yang jujur, karena hal di balik blok ini tidak ada di chip.
Blok ini sama sekali tidak menaikkan interrupt. Setiap sumber lain di sini mencapai core melalui matriks interrupt di bagian 3.7, dan nomor sumber matriks adalah milik chip; tidak ada nomor jujur untuk diberikan kepada peripheral yang tidak dimiliki chip, jadi kotak surat ini tidak diberi nomor. NET_INT_RAW_REG tetap bisa dibaca, firmware melakukan polling, dan core yang parkir di waiti tetap dibangunkan saat jaringan punya sesuatu untuk disampaikan, dengan cara yang sama seperti dibangunkan untuk tepi PWM.
Di sini tidak ada radio, tidak ada 802.11 dan tidak ada internet sungguhan. Tidak ada apa pun dalam model ini yang mengirim, memindai, berasosiasi, mengenkripsi atau membuka socket: password dibandingkan sebagai string, nama yang tidak berada di bawah .mokxi tidak di-resolve, dan tiga origin yang dilayani jaringan adalah fungsi-fungsi di crates/net/src/http.rs. Kotak surat ini adalah bentuk sejatinya sambungan itu, bukan fiksi tentang MAC: pada ESP32 sungguhan perangkat keras WiFi adalah blob biner tertutup dengan antarmuka perintah, dan WiFi.h milik Arduino berakhir di sisi lain dari salah satunya. docs/wifi.md adalah kontrak untuk apa yang ada di baliknya; bagian ini hanya registernya.
Sebuah register perintah, register status, ring 4096-byte untuk tiap arah dan satu bit interrupt. Menulis ke NET_CMD_REG menjalankan perintah; perintah yang memakan waktu simulasi menaikkan BUSY dan menghapusnya, dengan DONE di NET_INT_RAW_REG, saat selesai.
| offset | nama | bit |
|---|---|---|
0x00 |
NET_ID_REG |
membaca 0x494B4F4D, dan tidak ada hal lain yang melakukannya. Sketch yang ingin tahu apakah ia berjalan di Mokxi membaca ini; di silicon akses ini gagal |
0x04 |
NET_CMD_REG |
tulis kode perintah (tabel di bawah); penulisan menjalankannya |
0x08 |
NET_ARG_REG |
satu word argumen, bisa dibaca kembali: port untuk LISTEN, status untuk REPLY |
0x0C |
NET_STATUS_REG |
bit 0 BUSY, bit 1 ERR, bit 2 RX_READY, bit 3 LINK, bit 4 SERVE, bit 8..11 STATE |
0x10 |
NET_RESULT_REG |
apa yang dijawab perintah terakhir |
0x14 |
NET_INT_RAW_REG |
bit 0 DONE, bit 1 EVENT |
0x18 |
NET_INT_ENA_REG |
dua bit yang sama |
0x1C |
NET_INT_CLR_REG |
tulis 1 untuk menghapus, dua bit yang sama |
0x20 |
NET_TX_LEN_REG |
byte yang siap di ring keluar |
0x24 |
NET_TX_DATA_REG |
tulis: dorong satu byte (bit 0..7) ke ring keluar |
0x28 |
NET_RX_LEN_REG |
byte yang menunggu di ring masuk |
0x2C |
NET_RX_DATA_REG |
baca: ambil satu byte dari ring masuk, 0 saat kosong |
0x30 |
NET_RING_LEN_REG |
kapasitas tiap ring dalam byte, agar firmware tidak perlu hard-code 4096 |
0x40 |
NET_BT_CMD_REG |
Bluetooth: tulis kode perintah Bluetooth (docs/bluetooth.md); penulisan menjalankannya |
0x44 |
NET_BT_ARG_REG |
Bluetooth: satu word argumen, bisa dibaca kembali; sebuah event meninggalkan nomornya di sini |
0x48 |
NET_BT_RESULT_REG |
Bluetooth: apa yang dijawab perintah Bluetooth terakhir |
0x4C |
NET_BT_STATUS_REG |
bit 0 CLASSIC_ON, bit 1 CLASSIC_LINK, bit 2 EVENT, bit 3 BLE_ADV, bit 4 BLE_LINK, bit 5 BT_ERR, bit 8 HAS_CLASSIC, bit 9 HAS_BLE |
0x50 |
NET_BT_TX_LEN_REG |
Bluetooth: byte yang siap di ring keluarnya sendiri |
0x54 |
NET_BT_TX_DATA_REG |
Bluetooth: tulis: dorong satu byte ke ring tersebut |
0x58 |
NET_BT_RX_LEN_REG |
Bluetooth: byte yang menunggu di ring masuknya sendiri |
0x5C |
NET_BT_RX_DATA_REG |
Bluetooth: baca: ambil satu byte, 0 saat kosong |
Delapan register NET_BT_ adalah paruh Bluetooth dari blok ini, dengan ring tersendiri agar callback Bluetooth tidak pernah menyentuh body HTTP: Bluetooth Classic dan LE, keduanya dimiliki ESP32 klasik. Tidak ada radio di baliknya juga; docs/bluetooth.md adalah kontraknya.
STATE adalah posisi station: 0 idle, 1 mulai, 2 menghubungkan, 3 terhubung, 4 gagal, 5 jaringan tidak ada. NET_CMD_STATUS mengubah hal yang sama menjadi kode wl_status_t Arduino yang dibaca sketch dari WiFi.status().
NET_CMD_REG |
nama | fungsinya |
|---|---|---|
| 0 | NOP |
tidak melakukan apa pun |
| 1 | RESET |
putuskan koneksi, buang kedua ring, buang semua request |
| 2 | CONNECT |
ring keluar berisi ssid\0password; menaikkan BUSY selama satu sampai tiga detik |
| 3 | DISCONNECT |
hapus asosiasi dan alamatnya |
| 4 | STATUS |
NET_RESULT_REG = kode wl_status_t |
| 5 | IP |
NET_RESULT_REG = alamat yang didapat, oktet pertama di byte rendah |
| 6 | RSSI |
NET_RESULT_REG = sinyal dalam dBm, dengan tanda diperluas |
| 7 | SSID |
ring masuk menerima nama access point |
| 8 | MAC |
ring masuk menerima enam byte MAC board |
| 9 | REQUEST |
ring keluar berisi method\0url\0headers\0body; menaikkan BUSY |
| 10 | POLL |
NET_RESULT_REG = 0 saat berjalan, lalu status HTTP, atau error negatif dengan ERR naik; body mendarat di ring masuk |
| 11 | LISTEN |
mendengarkan di port yang ada di NET_ARG_REG |
| 12 | ACCEPT |
NET_RESULT_REG = 1 dan ring masuk berisi method\0path\0query\0body, atau 0 saat tidak ada yang menunggu |
| 13 | REPLY |
jawab request yang diterima dengan status di NET_ARG_REG; ring keluar berisi content-type\0body |
| 14 | STOP |
berhenti mendengarkan |
| 15 | WL_GPIO_SET |
drive GPIO milik komponen nirkabel sendiri dari NET_ARG_REG. Bukan board ini: radio komponen ini tidak punya pin seperti itu, jadi ia menyetel ERR dan tidak menggerakkan apa pun. Inilah jalur yang diambil LED bawaan Pico W (docs/picow.md bagian 3.8) |
| 16 | WL_GPIO_GET |
baca kembali nilainya, dan ERR yang sama di sini |
| 17 | BLYNK |
satu operasi pada server Blynk yang disimulasikan, operasinya di NET_ARG_REG dan field-nya di ring keluar; dijawab seketika di NET_RESULT_REG, dengan ERR dimatikan dari jaringan (docs/wifi.md, "Blynk") |
| 19 | ETH |
Ethernet kabel (firmware/include/ETH.h), operasinya di NET_ARG_REG: 1 mengaktifkan link lewat kabel tersimulasi, tanpa SSID dan tanpa kata sandi, bergabung 1,5 s kemudian dengan lease yang sama; 2 menaruh 1 di NET_RESULT_REG saat link sedang (atau terakhir) merupakan yang berkabel. Linknya hanya satu: STATUS, IP dan setiap permintaan membacanya dari cara aktifnya apa pun |
| 20 | SOFTAP |
soft AP (crates/net/src/softap.rs, docs/wifi.md), operasinya di NET_ARG_REG: 1 mengaktifkannya (ring keluar ssid\0password\0 dan byte channel; NET_RESULT_REG 1, atau 0 dengan ERR untuk nama kosong atau kata sandi satu sampai tujuh karakter), 2 mematikannya, 3 mengonfigurasinya (alamat, gateway dan netmask, masing-masing empat byte), 4 alamatnya (0 saat mati), 5 station yang bergabung, 6 join, leave dan bit aktif yang diubah runtime menjadi event, 7 dan 8 DNS server captive portal yang menyala (namanya, satu byte nol, alamatnya) dan berhenti, 9 namanya ke ring masuk, 10 alamat HP, 11 Host dari permintaan yang sedang dilayani ke ring masuk. Station satu-satunya adalah HP panel Web |
Kode POLL negatif: -1 nama tidak ter-resolve, -2 station tidak terasosiasi, -3 https:// dan TLS tidak disimulasikan, -4 body lebih panjang dari ring, -5 URL yang tidak bisa di-parse jaringan ini, -6 sudah ada permintaan yang berjalan. firmware/include/HTTPClient.h mengubahnya menjadi kode bergaya Arduino yang dibandingkan oleh sketch, dan docs/wifi.md memuat daftar pemetaannya.
Timing, semuanya milik model ini sendiri dan semuanya dinyatakan di docs/wifi.md: asosiasi memakan waktu satu sampai tiga detik, ditentukan dari SSID supaya sebuah pelajaran memakan waktu yang sama dua kali; kata sandi yang salah menjadi WL_CONNECT_FAILED setelah lima detik; permintaan ke origin tersimulasi kembali 60 ms kemudian; permintaan ke server milik sketch sendiri yang tidak pernah dijawab sketch ditutup oleh jaringan dengan 504 setelah sepuluh detik.
3.9 Watchdog grup timer 0 dan reset RTC_CNTL (0x3FF5_F048, 0x3FF4_8000)
Watchdog utama grup timer 0, seperti milik C3 (docs/esp32c3.md bagian 3.9) dengan layout ESP32: penulisan langsung berlaku seketika, bit interrupt adalah bit 2 dari TIMG_INT_* (0x98..0xA4), dan sampai ke core lewat interrupt matrix sebagai sumber 16 (runtime memetakannya ke interrupt CPU 17). RTC_CNTL (0x3FF4_8000, dua kilobyte di bawah SENS): RTC_CNTL_RESET_STATE_REG di 0x34, register penyimpan di 0x4C..0x58 dan 0xB0..0xBC, serta dua reset perangkat lunak. Grup timer 1 tidak dimodelkan.
Runtime menjalankan task watchdog milik ESP-IDF di atas watchdog grup timer 0, seperti yang dilakukan ESP-IDF (firmware/src/main.cpp): tick 500 µs, stage 0 berupa interrupt saat timeout dan stage 1 berupa reset sistem saat dua kali timeoutnya, dimulai sebelum setup() pada 5 s dengan panic, mengawasi idle task core 0. Sketch berjalan di core 1, yang idle task-nya tidak diawasi kecuali ia memintanya sendiri (enableCore1WDT()), jadi loop yang tidak pernah yield tetap berjalan, seperti di board. Interrupt itu mencetak baris-baris ESP-IDF ("E (…) task_wdt: Task watchdog got triggered. …", daftar task, "Aborting.", baris abort dan "Rebooting..."), meninggalkan petunjuk ESP_RST_TASK_WDT milik ESP-IDF di register penyimpan RTC dan mereset CPU lewat reset perangkat lunak, sehingga esp_reset_reason() mengatakan 6 setelahnya. esp_task_wdt_*, enableLoopWDT() dan enable/disableCore0WDT() bekerja padanya. Watchdog grup timer 1 dimodelkan dengan cara yang sama dan tidak ada apa pun di runtime yang mempersenjatainya: interrupt watchdog tidak disimulasikan.
4. Core-nya: ABI mana, dan bagaimana sebuah interrupt datang
crates/xtensa-core adalah interpreter Xtensa LX yang ditulis dari referensi Xtensa Instruction Set Architecture dan dari encoding yang dihasilkan toolchain Espressif. Tidak ada bagian darinya yang diturunkan dari QEMU, dari ESP-IDF, dari core Arduino atau dari emulator lain mana pun. xtensa-esp32-elf-as dipakai seperti cara instrumen di meja kerja dipakai (rakit sebuah instruksi, baca kembali encoding-nya, tulis decoder berdasarkan hasilnya), dan crates/xtensa-core/tests/encoding.rs menyimpan pengukuran itu, sehingga decoder dapat diperiksa terhadap bukti daripada terhadap tabel yang diketik seseorang.
ABI windowed, dan tidak ada pilihan lain. xtensa-esp32-elf-gcc menghasilkan entry, call8 dan retw.n, dan tidak punya opsi -mabi=call0 sama sekali. Jadi konfigurasi LX6 di sini punya enam puluh empat register alamat fisik dan register window, dengan ENTRY, RETW, ROTW, MOVSP, L32E/S32E serta exception window overflow dan underflow lewat vektor masing-masing. (LX106 milik ESP8266 punya enam belas register dan tanpa window, jadi compiler-nya menghasilkan call0; docs/esp8266.md bagian 4 adalah separuh lain dari ini.)
What the LX6 configuration has that the LX106 does not: hardware divide (QUOS, QUOU, REMS, REMU), the 32-bit high multiply, MIN/MAX, SEXT, CLAMPS, the zero-overhead loop (LOOP, LOOPNEZ, LOOPGTZ) and the two atomic loads. Each of those differences was put to the assembler of the toolchain that builds for that chip; the encodings that came back are in tests/encoding.rs.
Dimodelkan: load dan store pada setiap lebar dengan exception alignment, seluruh set branch dan conditional-branch, CALL0/CALL4/CALL8/CALL12 beserta bentuk tak langsungnya, L32R, MOVI, instruksi density (.n), ALU integer, MUL16/MULL/MULUH/MULSH, register spesial, dan WAITI.
Vektor. VECBASE adalah register spesial dan tabelnya adalah milik ISA:
offset dari VECBASE |
vektor |
|---|---|
0x000 |
WindowOverflow4 |
0x040 |
WindowUnderflow4 |
0x080 |
WindowOverflow8 |
0x0C0 |
WindowUnderflow8 |
0x100 |
WindowOverflow12 |
0x140 |
WindowUnderflow12 |
0x300 |
KernelException (PS.UM nol) |
0x340 |
UserException (PS.UM satu), dan setiap interrupt level-1, dengan EXCCAUSE 4 |
0x3C0 |
DoubleException (PS.EXCM sudah satu) |
Handler overflow mana dari ketiganya yang diambil ditentukan oleh seberapa lebar frame yang di-spill, bukan oleh seberapa jauh window berputar untuk mencapainya: WindowOverflow4 spill melalui a5, 8 melalui a9 dan 12 melalui a13, dan itulah stack pointer satu, dua dan tiga window lebih jauh. Sebuah CALL8 menulis a8 sebelum ENTRY milik callee sempat berjalan, jadi aturan overflow ada pada akses register dan bukan hanya pada ENTRY. Keduanya adalah bug yang ditemukan firmware board ini sendiri, dan keduanya sudah diperbaiki di core.
Interrupt. INTENABLE mem-mask; PS.INTLEVEL menyaring. Hanya level 1 yang dimodelkan: level interrupt di atas satu, NMI dan interrupt debug tidak. Interrupt level-1 adalah 0 sampai 10, 12, 13, 17 dan 18, dengan mask 0x0006_37FF. Diverifikasi terhadap ESP32 Technical Reference Manual (v5.8), tabel 8.3-2 "CPU Interrupts": 19, 20 dan 21 level-triggered di level 2, jadi tidak ada dalam mask. Versi model ini sebelumnya memasukkannya (0x003E_37FF), yang akan mendispatch line level-2 di level 1; crates/xtensa-core/tests/interrupts.rs sekarang menahan mask agar sesuai tabel. Runtime hanya pernah mengaktifkan 6 dan 13 (bagian 7), keduanya level 1 di tabel yang sama, jadi tidak ada firmware yang bergantung pada mask lama.
CCOUNT dan CCOMPARE. LX6 punya tiga comparator. Interrupt CPU mana yang dinaikkan masing-masing dianggap:
| comparator | interrupt CPU |
|---|---|
CCOMPARE0 |
6 |
CCOMPARE1 |
15 |
CCOMPARE2 |
16 |
Diverifikasi terhadap tabel 8.3-2 yang sama, yang interrupt internalnya 6, 15 dan 16 adalah "Timer.0", "Timer.1" dan "Timer.2". Tabel itu juga menempatkan 15 di level 3 dan 16 di level 5, jadi hanya CCOMPARE0 yang pernah dipakai di sini. Runtime memakai CCOMPARE0 dan interrupt CPU 6 untuk tick-nya, yang itu juga yang dipakai semua port Xtensa.
WSR ke sebuah CCOMPARE adalah yang mengaktifkan comparator, dan menulisnya juga menghapus interrupt yang pending. Itu aturan hardware dan itu pula aturannya di sini. Dua detail model ini, keduanya disengaja dan keduanya karena waktu simulasi bukan clock bertingkat:
- Hardware sungguhan menaikkan interrupt pada satu siklus saat
CCOUNTsama dengan comparator dan menahannya sampai comparator ditulis lagi. Di sini pembandingnya adalah "sudah mencapai atau melewati", karena core yang parkir diWAITIberhenti mengeksekusi instruksi sementara waktu terus berjalan dan tanpa ini akan melompat tepat melewati satu siklus yang penting itu. Untuk handler yang menetapkan deadline berikutnya (yang itu setiap penggunaan register ini), keduanya berperilaku sama. - Deadline yang sudah lewat tidak diaktifkan. Sebuah handler memakan beberapa ratus siklus, jadi comparator yang diset ke "sekarang" sudah di masa lalu sebelum handler kembali, langsung menyala lagi, dan program yang di-interrupt hanya mendapat satu instruksi dalam satu waktu. Tiga detik
blinkmemakan 200 juta instruksi sebelum aturan itu dan kurang dari setengah juta sesudahnya.
MOVSP tidak menaikkan exception Alloca di sini; ia melakukan apa yang exception dan handler-nya lakukan bersama. Di hardware MOVSP trap saat window pemanggil sudah di-spill (WINDOWSTART clear untuk WINDOWBASE - 1 ke - 3), dan handler menyalin milik pemanggil a0..a3, area simpan dasar di 16 byte di bawah stack pointer lama, ke bawah yang baru sebelum dipindah. Model ini melakukan salinan itu langsung di tempat lalu memindah (crates/xtensa-core/src/cpu.rs, movsp). Kode memang bergantung padanya: clang-v3 mengapit setiap call yang meneruskan argumen di stack dengan movsp a1, a8, dan sebelum salinan itu dibuat, sebuah sketch yang memanggil WiFi.scanNetworks() (delapan argumen dengan this) crash pada window underflow di jalan pulang. Begitu juga setiap long setup() yang memanggil sprintf dengan lebih dari enam argumen setelah cukup banyak print untuk spill pemanggilnya: semuanya tercetak, lalu exccause=9 di WindowUnderflow8 saat setup() kembali (di ESP32 dan S3; C3 dan Pico tidak punya window). crates/xtensa-core/tests/alloca.rs menjalankan CALL8 dan CALL12 frame yang masing-masing menggerakkan stack pointer-nya turun dan naik dengan MOVSP mengelilingi sebuah call, di setiap kedalaman dari 0 sampai 40, dan web/src/compile/xtensa-movsp.test.ts menjalankan sketch di kedua board.
The FPU is modeled. The ESP32's single-precision coprocessor runs on this model (crates/xtensa-core/tests/fpu.rs): the loads and stores (LSI, SSI, LSX, SSX and their post-incrementing forms), ADD.S, SUB.S, MUL.S, the fused MADD.S, MSUB.S and MADDN.S, the conversions (FLOAT.S, UFLOAT.S, TRUNC.S, UTRUNC.S, ROUND.S, FLOOR.S, CEIL.S), the compares into the boolean registers with BT, BF, MOVT and MOVF, the conditional moves, WFR, RFR, FCR and FSR, and the division and square-root steps libgcc's __divsf3 and newlib's sqrtf are built from, which return the correctly rounded IEEE answer. Arithmetic rounds to nearest whatever FCR says and sets no FSR flags. On this bare-metal model the coprocessor is on from reset, as there is no OS to turn it on at first use; the system model (docs/micropython-esp32.md) still waits for CPENABLE. So a float in an example built by Espressif's GCC through firmware/esp32/build.sh runs and prints the right number, and the browser's soft-float builds (-Xclang -target-feature -Xclang -fp, calls into mokxi_float.c) are unchanged.
5. Model waktu, probe, poke dan channel host
CPU berjalan di 240 MHz, satu instruksi per siklus, dan bus peripheral di 80 MHz. 240 MHz bukan bilangan bulat pikodetik per siklus, jadi waktu instruksi k dihitung ulang sebagai ps_for(k) = k * 12500 / 3 bukan diakumulasi (seperti milik Blue Pill dan XIAO), dan satu slice 2400 instruksi tepat 10 us.
Di dalam sebuah slice, jumlah instruksi adalah clock-nya: pembacaan timer, satu byte UART dan perubahan pin semuanya jatuh pada instruksi yang menyebabkannya, bukan di akhir slice. Komponen board mengubah itu menjadi panggilan drive_after pada offset yang sama, jadi dua write yang berjarak empat instruksi memang terpisah 16.7 ns di net. RSR.CCOUNT membaca clock yang sama.
Core yang parkir di WAITI tidak memakan biaya apa pun: board meminta untuk dibangunkan pada yang paling awal antara deadline CCOMPARE berikutnya dan tepi LEDC berikutnya, dan perubahan pin atau byte host juga membangunkannya.
Pembacaan input setelah write ke output menunggu rangkaian. Core berjalan satu slice lebih awal dari rangkaian, dan GPIO_IN_REG menyimpan level yang disampel saat slice dimulai. Jadi begitu sebuah write GPIO atau IO_MUX telah menggerakkan sebuah pad dalam sebuah slice, load dari GPIO_IN_REG atau GPIO_IN1_REG tidak dijawab: bus mengembalikan BusError::Retry, xtensa-core menghentikan core sebelum instruksi itu tanpa ada yang dilakukan, slice berakhir di situ, board menaruh pergerakan itu di net, dan slice berikutnya menyampel input dan menjalankan pembacaan itu. Pemindaian keypad (drive sebuah kolom, baca barisnya) dan kabel dari satu pin ke pin lain sama-sama membaca apa yang rangkaian hasilkan dari write itu. Board AVR berhenti sebelum pembacaan seperti itu dengan cara yang sama.
probe adalah bitmask, bukan level, karena board ini punya empat hal yang layak disebut:
| bit | arti |
|---|---|
| 1 | berjalan |
| 2 | parkir di waiti |
| 4 | LED biru di GPIO 2 menyala |
| 8 | firmware telah mencoba menjadikan salah satu GPIO 34 sampai 39 sebagai output dan ditolak |
0 berarti tidak ada program, ditahan dalam reset, atau crash. Bit 8 tidak digerbangkan pada berjalan: program yang output-nya sudah ditolak tetap ditolak, dan board terus menyatakannya.
poke: 1 menahan BOOT (GPIO 0 rendah), 0 melepaskannya; 2 menahan EN, 3 melepaskannya.
Kanal host. host_write menaruh byte ke FIFO terima UART0 (yang tidak muat dalam 128 byte-nya ditahan dan masuk satu per satu dengan jeda satu byte saat sketch membacanya, sama seperti byte di board sungguhan yang menetes masuk sesuai baud rate ke buffer cincin Arduino core, bukan dibuang); host_read mengambil byte yang telah keluar dari FIFO kirimnya. Itulah Serial dalam sebuah sketch dan serial monitor di UI. Byte adalah UTF-8 sejauh menyangkut UI dan tidak dapat dibaca oleh model. Soket micro-USB DevKit menuju bridge CP2102 atau CH340 di port ini; bridge itu sendiri tidak dimodelkan, begitu pula auto-reset lewat DTR/RTS.
Crash. 1000 trap berturut-turut tanpa kemajuan dan core dinyatakan crash lalu dihentikan, dengan lokasi kematiannya dicatat.
6. Apa yang diyakini dan tidak diyakini oleh model ini
Tiga kelompok, lalu kelompok keempat untuk pendekatan yang sama sekali bukan soal alamat. Bagian ini ada karena model board yang diam-diam menebak sebuah alamat lebih buruk daripada yang mengatakan tidak tahu.
Diambil dari manual referensi teknis
DPORT_BASE 0x3FF0_0000, UART0_BASE 0x3FF4_0000, GPIO_BASE 0x3FF4_4000, SENS_BASE 0x3FF4_8800, IOMUX_BASE 0x3FF4_9000, LEDC_BASE 0x3FF5_9000 dan TIMG0_BASE 0x3FF5_F000. Setiap offset register di dalam matriks GPIO dan di dalam UART0, serta RXFIFO_RST (bit 17) dan TXFIFO_RST (bit 18) pada UART_CONF0_REG dari register 19.9, delapan bit RXFIFO_CNT dan TXFIFO_CNT pada UART_STATUS_REG (register 19.8), threshold pada UART_CONF1_REG (register 19.10) dan pembagi dua puluh bit pada UART_CLKDIV_REG (register 19.6). Mask interrupt CPU level-1 0x0006_37FF (0 sampai 10, 12, 13, 17 dan 18) serta interrupt CCOMPARE 6, 15 dan 16, keduanya dari tabel 8.3-2 (bagian 4). Jendela IRAM di 0x4008_0000 dan jendela DRAM di 0x3FFB_0000. GPIO_FUNC_OUT_SEL = 256 untuk "ikuti GPIO_OUT". Nilai MCU_SEL 2 untuk GPIO biasa. Peta kanal ADC1: kanal 0 sampai 7 adalah GPIO 36, 37, 38, 39, 32, 33, 34, 35. Empat puluh GPIO, bahwa 6 sampai 11 adalah flash dan bahwa 34 sampai 39 tidak punya driver output. LED biru di GPIO 2 dan tombol BOOT di GPIO 0. Offset vektor Xtensa dan nomor EXCCAUSE, yang berasal dari ISA, bukan chip.
Diyakini, tidak diverifikasi
- Tabel urutan pad IO_MUX (bagian 3.2). Register-registernya dalam urutan pad dan ini adalah pembacaan model ini tentang pad tiap GPIO.
- Offset register grup timer 0 (bagian 3.4). Base-nya milik manual; susunan di dalamnya bukan.
- Susunan blok LEDC (bagian 3.6): stride kanal, blok timer di
0x140, dan register interrupt dan config. Base-nya milik manual. - Offset SENS dan posisi bit (bagian 3.5).
DPORT_INTR_MAP= 0x104, dan dua nomor sumbernya, GPIO 22 dan UART0 34 (bagian 3.7).- Indeks sinyal matriks GPIO 71 sampai 78 untuk kanal kecepatan tinggi LEDC 0 sampai 7 (bagian 3.1). Ini klaim paling lemah dalam dokumen ini.
Semuanya dinamai di satu tempat yang dibaca firmware (firmware/esp32/include/esp32.h), jadi image yang dibawa ke silikon sungguhan punya daftar pendek #define untuk diperiksa. crates/esp32/tests/contract.rs mengikat header itu dan crates/esp32/src/map.rs pada angka yang sama, jadi dua bagian itu tidak bisa saling menjauh; itu tidak membuat salah satunya benar.
Dimodelkan, tapi bukan dengan angka manual
Ini pendekatan, bukan alamat, dan sebuah sketch bisa melihat semuanya:
- Field state machine
UART_STATUS_REGterbaca 0 (bagian 3.3). Di silikonST_URX_OUTdanST_UTX_OUTbergerak selama sebuah byte ada di kabel; runtime hanya membaca hitungan delapan bit itu, jadi ia tidak melihat bedanya. - ADC pada 11 dB adalah kurva tipikal dari komponen, bukan dari unit ini. Pembacaan mentah mengikuti hasil fit terhadap pengukuran ESP32s (bagian 3.5): zona mati di bagian bawah, lengkungan di bagian atas, dan saturasi di sekitar 3.15 V semuanya ada, tetapi sebaran antar-unit yang dikoreksi oleh kalibrasi eFuse tidak. Atenuasi lainnya berupa garis lurus nominal.
- Setiap pad menyala dengan kondisi sama (bagian 3.2): GPIO biasa, buffer input aktif, tanpa pull. Manual memberi pin strapping dan flash nilai reset yang berbeda.
GPIO_STRAP_REGadalah konstanta,0b1101, bukan latch dari apa yang sedang dilakukan pin saat reset.- Konversi memakan tepat 5 us dan tepi LEDC mendarat tepat di pikodetiknya. Komponen asli punya jitter dan tidak ada satu pun angka ini yang berasal dari datasheet.
ENhanyalah pull-up 10 k. Kapasitor power-on reset 100 nF di sebelahnya tidak dimodelkan, jadi sebuahENyang sekadar dilepaskan langsung hidup kembali di sini.- Tidak ada boot ROM, dan tidak ada clock tree. ESP32 asli menghabiskan puluhan milidetik di loader tahap pertama sebelum instruksi pertama sketch; di sini
POWER_ONadalah 1 us, core berada di 240 MHz dan clock APB di 80 MHz sejak instruksi pertama, dan tidak ada yang bisa dikonfigurasi untuk keduanya. CCOMPAREmembandingkan "tercapai atau terlampaui", dan deadline yang sudah lewat tidak diaktifkan (bagian 4).MOVSPtidak pernah memunculkan Alloca; ia membuat salinan base save area milik handler itu sendiri (bagian 4).- Dua jendela RAM tidak di-alias. Di komponen asli SRAM yang sama terlihat lewat kedua bus pada alamat berbeda, dengan blok SRAM1 dalam urutan sebaliknya (bagian 2).
Sengaja tidak disertakan
Masing-masing ini ditinggalkan daripada diciptakan:
- Core kedua. ESP32 punya dua core Xtensa LX6, PRO dan APP, dan hanya core PRO yang berjalan di sini. Tidak ada
DPORT_APPCPU_CTRL, tidak ada interrupt antar-core dan tidak ada FreeRTOS untuk menjadwalkan keduanya. Sketch yang ditulis untukloop()tunggal Arduino core tidak pernah menyadarinya; apa pun yang memulai task di core 1 tidak akan berjalan. - The cache, the MMU and flash. Code and constants are read from two fixed, read-only windows (section 2.1); there is no flash device, no MMU and no cache to miss, so a fetch from flash is as fast as one from IRAM.
PSRAMlikewise. - WiFi dan Bluetooth, dalam segala bentuk: tanpa radio, tanpa stack, tanpa
WiFi.h, bahkan tanpa stub yang gagal dengan sopan. - RTC, memori lambatnya, koprosesor ULP, deep sleep dan unit manajemen daya.
- ADC2, DMA dan pengendali digital SAR, eFuse kalibrasi, referensi internal, sensor sentuh dan sensor hall.
- Grup kecepatan rendah LEDC dan perangkat keras duty-fade-nya.
- Grup timer 1, timer 1 dari grup timer 0, watchdog RTC dan watchdog interrupt.
- I2C, SPI, I2S, RMT, pulse counter, PWM motor, SDIO, Ethernet, kontroler CAN dan akselerator AES, SHA, RSA dan RNG.
- Matriks interrupt di luar sumber dari bagian 3.7, dan setiap level interrupt CPU di atas satu.
Itulah sebabnya binary vendor ESP-IDF dan Arduino-core tidak bisa berjalan di sini, sedangkan firmware yang dibuat untuk dokumen ini bisa.
Image dua board Xtensa juga tidak bisa dipertukarkan. String program pada katalog adalah elf32 xtensa lx6 esp32 di sini dan elf32 xtensa lx106 esp8266 di NodeMCU, dan perbedaannya nyata, bukan sekadar administratif: core ini menjalankan ABI windowed sedangkan yang satunya tidak punya window untuk menjalankannya, jadi image yang dibuat untuk yang satu akan fault di yang lain alih-alih sekadar salah tingkah.
7. Runtime firmware (firmware/esp32/)
An Arduino-shaped runtime: setup() and loop(), pinMode, digitalWrite, digitalRead, shiftOut, analogRead (with analogReadResolution, analogSetAttenuation and analogSetPinAttenuation), analogWrite and the ledcAttach/ledcWrite/ledcRead family, millis, micros, micros64, delay, delayMicroseconds, attachInterrupt, Serial, Serial1 and Serial2, map, random. No Arduino core, no ESP-IDF, no libc.
Konstruktor statis keluar dari .ctors di sini, bukan dari .init_array. GCC 8.4 milik Espressif dikonfigurasi tanpa --enable-initfini-array dan tidak punya -fuse-init-array, jadi konstruktor objek global berada di .ctors sedangkan setiap toolchain lain di repositori ini menghasilkan .init_array. link.ld mengumpulkan keduanya ke dalam satu rentang yang crt0.S menjelajahi. Tanpa itu, sketch dengan objek global (WebServer server(80) di dalam wifilamp) akan tersambung, dijalankan, dan menemukan anggotanya nol. Keduanya dilalui dalam satu pass dan .ctors tidak dibalik, karena urutan constructor yang berjalan antar translation unit tidak ditentukan dalam C++ dan sebuah sketch tidak boleh bergantung padanya.
LED_BUILTIN is 2. The core has no BOOT_BUTTON: the BOOT button is GPIO 0, so sketches use 0. A0 is 36, and A3 to A7 are 39, 32, 33, 34 and 35, which is what the DevKit's own analog pins are called.
analogRead adalah one-shot ADC1 (bagian 3.5), dua belas bit pada 11 dB secara bawaan. analogWrite(pin, 0..255) adalah delapan bit pada 1 kHz di GPIO mana pun dengan output driver, dan memakai satu channel LEDC high-speed yang bebas saat pertama kali dipanggil; ledcAttach(pin, frequency, bits) adalah yang dibutuhkan sebuah sketch bila frekuensinya penting, dan channel yang meminta frekuensi dan resolusi yang sama berbagi satu dari empat timer. mokxi_pin_is_input_only(pin) ada supaya sebuah sketch bisa bertanya sebelum ditolak.
millis() dan micros() berasal dari timer 0 milik timer group 0 dengan satu tick per mikrodetik (bagian 3.4). delayMicroseconds() di bawah 50 us menghitung CCOUNT, 240 siklus per mikrodetik, jadi tidak pernah lebih singkat dari yang diminta (menghitung timer mikrodetik bisa membuat delayMicroseconds(10) menjadi 9.01 us, yang diabaikan HC-SR04 sebagai trigger); 50 us ke atas berhenti menunggu seperti delay(). delay() memarkir core pada CCOMPARE0 alih-alih spinning, jadi satu detik blink hanya menghabiskan kurang dari setengah juta instruksi dari 240 juta siklus yang dihitung clock. attachInterrupt adalah tiga penulisan alih-alih satu, karena peripheral sampai ke core melalui interrupt matrix (bagian 3.7).
Serial1 dan Serial2 ada di src/uartn.c pada UART1 dan UART2 (bagian 3.3a), diarahkan melalui GPIO matrix ke pin yang disebutkan begin(baud, config, rx, tx) atau setPins(), dengan bawaan arduino-esp32 3.x bila tidak diberikan (GPIO 26 dan 27 untuk Serial1, 4 dan 25 untuk Serial2). Perilakunya sama seperti driver ESP-IDF di bawah core: REF_TICK sampai 250 000 baud dan APB di atasnya, interrupt pada RXFIFO_FULL (120 byte) atau timeout penerimaan satu simbol yang memindahkan FIFO ke ring sebesar setRxBufferSize() byte (256), seluruh chunk atau tidak sama sekali, dengan chunk ditahan dan interrupt penerimaan dimatikan selama ring penuh sementara interrupt overflow mengosongkan FIFO; available() hanya menghitung ring. write() menunggu FIFO 128 byte dan flush() sampai transmitter idle. Kedua UART berbagi interrupt CPU 18. onReceive() berjalan dari mokxi_uartn_events(), yang dipanggil oleh delay(), yield() dan loop di main.cpp (antara loop()), karena tidak ada task FreeRTOS. Tidak ada di sini: flow control, RS-485, IrDA, autobaud dan TX ring buffer.
Contoh bawaan dibangun oleh GCC milik Espressif; sketch pengguna dibangun oleh clang. ld.lld milik LLVM upstream tidak bisa menautkan Xtensa sama sekali, jadi browser memakai clang-v3, build wasm dari fork LLVM milik Espressif, yang membangun semua contoh di sini dengan daftar perintah milik browser (docs/compile.md). ELF yang sudah dibangun tetap milik GCC: ukurannya lebih kecil (docs/compile.md, "Code size") dan tidak ada yang mengharuskannya berubah. deploy/fetch-xtensa.sh meletakkan xtensa-esp32-elf-gcc 8.4.0 di tools/xtensa/, yang di-gitignore: GCC berlisensi GPL, dan tidak ada yang dibangunnya di sini menautkan libgcc atau bagian toolchain lainnya, jadi tidak ada kode GPL yang sampai ke ELF yang dikirim. docs/compile.md memuat penjelasan lengkap dan langkah selanjutnya.
crt0.S membawa enam handler window overflow dan underflow di VECBASE, ditulis dari referensi ISA alih-alih diambil dari sumber vendor mana pun, dan memberi root frame base save area tersendiri: window overflow pada root frame menjalankan l32e a0, a1, -12 untuk menemukan stack pointer milik pemanggilnya lalu menulis melaluinya, sedangkan root frame tidak punya pemanggil, jadi satu dibangun enam puluh empat byte di bawah puncak stack. Tanpanya, rantai panggilan dalam pertama akan menumpah melalui pointer null.
Masuknya exception tidak menyentuh a1, dan itu soal kebenaran, bukan kerapian: handler berjalan di window milik fungsi yang diinterupsi, dan window overflow pada frame yang lebih tua menemukan tempat menumpah dengan membaca stack pointer dari window itu. Pindahkan a1 dan setiap frame yang lebih tua menumpah ke tempat yang salah dan kembali dengan salah. Register yang diinterupsi masuk ke blok tetap di .bss sebagai gantinya, yang aman tanpa lock karena handler berjalan di INTLEVEL 1.
Linked against firmware/esp32/link.ld: the vectors and startup code in the 128 KB of IRAM, code in the flash code window, constants in the flash constants window, .data, .bss and the stack in the 192 KB of DRAM. A WROOM-32 has 4 MB of flash and an example should be a small part of it, so the build refuses an image with more than 64 KB loadable; the real ceiling the linker script enforces is the 1,310,720 bytes of the default app partition.
Lima contoh, masing-masing dengan sketch yang ditampilkan UI: blink (LED board di GPIO 2 dan satu LED berkabel di GPIO 4), button (saklar ke ground di GPIO 15 dengan pull-up bawaan pad), serial (tick setiap detik, dan gema dari apa yang kamu ketik), fade (LED di GPIO 4 pada LEDC, delapan bit di 1 kHz) dan knob (potensiometer di GPIO 32, yaitu kanal 4 ADC1, meredupkan LED di GPIO 4 dengan pembacaan mentah yang dicetak). pzemmonitor, meteran energi PZEM-004T di Serial2 (GPIO 16 dan 17) lewat library PZEM004Tv30, dibangun oleh compiler browser alih-alih GCC (bagian 4) dan merupakan proyek ESP32 PZEM-004T energy monitor.
crates/esp32/tests/runtime.rs menjalankan kelima ELF itu dan mengukur alih-alih sekadar mengamati: setengah periode blink dalam 5 ms dari 500, periode LEDC dalam 5 us dari 1 ms pada 1 kHz, millis() dalam 60 ms dari jam kernel sendiri selama lima detik, dan tidak ada dua byte UART0 yang lebih dekat dari 86.8 us pada 115200 baud. Tiap test melewati dirinya sendiri saat image belum dibangun, jadi test crate tidak pernah bergantung pada cross compiler.