ESP32: Assembler, aBelle und WLAN über das USB-Kabel

Was Asmonite mit dem ESP32 kann

Anschließen und loslegen

1. Das Board anschließen. Ein Board mit ESP32 und USB-Seriell-Chip (CP2102 oder CP2104, CH340, CH9102, CH343, FTDI). Im Geräte-Manager erscheint es als COM-Port. Den Treiber der meisten dieser Chips bringt Windows mit, sonst kommt er vom Hersteller des Chips.
2. Die Verbindung prüfen. Debug > Debug targets > ESP32 > Test the connection zeigt den COM-Port, die MAC-Adresse und den Flash, zum Beispiel „flash 4 MB (Boya, JEDEC id 68 40 16)“. Die Größe sagt der Flash-Chip selbst, wie bei esptool flash_id.
3. Starten. examples\esp32\blink_ram.asm öffnen und F7 drücken: Asmonite setzt den Chip in den Download-Modus, lädt das Programm und hält bei _start. F7 und F8 gehen einen Schritt, F9 lässt laufen, F5 setzt einen Breakpoint, Debug > Pause hält an.

Der Download-Modus. Das Boot-ROM wartet auf Befehle über UART0, wenn GPIO 0 bei einem Reset low ist. Die Boards machen das über die Leitungen DTR und RTS des USB-Seriell-Chips; Asmonite macht es wie esptool und prüft nach jedem Reset die erste Zeile des Boot-ROMs. Auf manchen Boards braucht das viele Versuche, weil der Kondensator an EN zu klein ist. Kommt das Board nicht innerhalb von 10 Sekunden dorthin, bittet Asmonite, BOOT gedrückt zu halten. Ein Kondensator von etwa 10 µF zwischen EN und GND behebt es dauerhaft.

921600 Baud. Große Übertragungen laufen achtmal so schnell wie mit 115200: der Flash über das Boot-ROM, ein Programm ab 16 KB unter dem Debugger, Dateien ab 16 KB. Asmonite prüft die Rate mit einem kurzen Austausch und fällt auf 115200 zurück, wenn das Board sie nicht schafft. Ein Programm von 98 KB lädt in gut 6 Sekunden. Bevor das Programm läuft, gilt wieder 115200. Die Umgebungsvariable ASMONITE_ESP_BAUD setzt eine andere Rate.

Dasselbe Programm in Assembler und aBelle

Die LED an GPIO 2 blinkt: den Pin als GPIO einstellen, als Ausgang schalten, dann in einer Schleife an und aus. Dateien: examples\esp32\blink_ram.asm und examples\abelle\esp32\blink.abel (gekürzt).

.target esp32
.arch xtensa
.imagebase 0x40080000     ; IRAM

lit_gpio:  dd 0x3FF44000      ; the GPIO registers
lit_half:  dd 20000000        ; half a second at 40 MHz
    ...
_start:
    l32r  a2, lit_gpio
    ...                        ; IO_MUX, output select
    movi  a3, 4                ; 1 << 2: GPIO 2
    s32i  a3, a2, 0x24         ; an output
    l32r  a7, lit_half
loop:
    s32i  a3, a2, 0x08         ; on
    call0 wait
    s32i  a3, a2, 0x0C         ; off
    call0 wait
    j     loop
wait:
    rsr   a9, ccount
wait_more:
    rsr   a10, ccount
    sub   a10, a10, a9
    bltu  a10, a7, wait_more
    ret

target "esp32"

gpio:  u32[0x140] at 0x3FF44000
iomux: u32[64]    at 0x3FF49000
def ets_delay_us(us: u32) at 0x40008534  # ROM

def main():
    iomux[0x40 / 4] = 0x2800   # GPIO 2 as a GPIO
    gpio[0x538 / 4] = 0x100    # a simple output
    gpio[0x24 / 4] = 1 << 2    # an output
    while True:
        gpio[0x08 / 4] = 1 << 2  # on
        ets_delay_us(500000)
        gpio[0x0C / 4] = 1 << 2  # off
        ets_delay_us(500000)

Xtensa lädt eine 32-Bit-Konstante mit l32r aus einem Wort vor dem Code; ccount zählt die Takte des Kerns. In aBelle liegen die Register als Feld an ihrer Adresse, und eine Funktion des ROM wird mit at und ihrer Adresse bekannt gemacht. Beide Programme liegen im IRAM ab 0x40080000, und der Debugger geht durch beide Zeile für Zeile: im Assembler Befehl für Befehl, in aBelle Zeile für Zeile des Quelltexts, mit den Variablen unter der Maus und im Fenster Watch.

Debuggen ohne JTAG

F9 oder F7 setzt den Chip in den Download-Modus, das Boot-ROM lädt den Debug-Monitor von Asmonite (gut 2 KB bei 0x4009E000), und der Monitor lädt das Programm und startet es bei _start. Er setzt VECBASE auf seine eigene Vektortabelle: break 1,15 (ein Breakpoint), der Schritt von ICOUNT und jede Ausnahme landen bei ihm. Er sichert die Register und beantwortet die Befehle von Asmonite über UART0. Er hat die Handler der Registerfenster, so geht auch eine Aufrufkette mit call4, call8 und call12, die tiefer ist, als die 64 Register fassen.

Pause und Stop. Debug > Pause hält ein laufendes Programm an, wo es gerade ist, auch in einer Endlosschleife. Asmonite schickt dafür ein Byte über UART0; der Monitor leitet den Interrupt des UART auf das NMI des Kerns, über der Interrupt-Stufe 5, mit der das Programm läuft. Stop (Strg+F2) beendet die Sitzung sofort.

Ausnahmen. Ein ungültiger Befehl, ein Laden von einer Adresse ohne Speicher oder ein Byte-Speichern ins IRAM hält das Programm am Befehl an, mit dem Grund im Ausgabefenster. Das IRAM liest und schreibt der Kern nur in Wörtern zu 32 Bit: l32i und s32i gehen, l8ui und s8i nicht.

Daten im DRAM: .data

Texte, Tabellen und Puffer kommen hinter .data: Diese Zeilen landen im DRAM ab 0x3FFB0000, wo der Kern Bytes, Halbwörter und Wörter liest und schreibt. .code schaltet zurück zum Code.

lit_text: dd text           ; the address in the DRAM, for l32r

_start:
    l32r  a3, lit_text
    l8ui  a2, a3, 0           ; a byte of the text
    ...

.data
text:   db 'Hello, world!', 13, 10, 0
buffer: resb 64             ; room, filled with zeros when it is loaded

Der Debugger schreibt die Bytes von .data nach dem Code ins DRAM; ein Programm für den Flash hat sie als zweites Segment im Image, das das Boot-ROM bei jedem Start kopiert. Der Stack beginnt bei 0x3FFC0000 und wächst nach unten; Daten, die in ihn hineinreichen, sind ein Fehler.

RAM, Flash und die serielle Ausgabe

Ein Programm, das das Boot-ROM aus dem Flash startet, muss die Watchdogs selbst abschalten, sonst setzt sich der Chip nach ein paar Sekunden zurück; examples\esp32\blink_flash.asm zeigt es mit ein paar Zeilen bei _start.

Der Reiter Serial. Was das Programm in UART0 schreibt, kommt am COM-Port heraus, mit 115200 Baud. Unter dem Debugger teilt sich der Monitor den Port mit dem Programm, und die Ausgabe erscheint im Reiter Serial neben dem Ausgabefenster. Ohne Debugger ist der Reiter ein kleines Terminal: Connect, eine Eingabezeile und Reset, das den Chip über RTS zurücksetzt, ohne den Port zu schließen. Die Leitungen DTR und RTS lässt das Terminal sonst aus, damit ein Programm im RAM beim Öffnen des Ports nicht verschwindet.

Die Konsole und ihre Dateien

examples\esp32\console.asm macht aus dem Board einen kleinen Rechner mit einem Dateisystem im Flash, von 2 MB bis zum Ende des Flash: 2 MB bei 4 MB Flash, 6 MB bei 8 MB. Jedes Terminalprogramm arbeitet mit ihr (ls, cat, put, rm, df, format, run, load, boot, help), und Debug > ESP32 Board Files zeigt ihre Dateien in einem Fenster.

Ein Programm für F9 passt unverändert in die Konsole: Sein Code darf 0x40080000..0x40097FFF belegen, seine Daten 0x3FFB0000..0x3FFCFFFF. Unter dem Debugger läuft die Konsole nicht, denn der Debug-Monitor nimmt jedes Byte auf UART0 als Pause.

Das WLAN

Das WLAN des ESP32 steckt in Bibliotheken von Espressif ohne Quelltext. Asmonite bindet sie einmal mit seinem eigenen Linker zu einer festen Datei zusammen, wlan.rom, und bringt einen kleinen Dienst mit, wlansvc, der sie startet und Programmen einfache Funktionen anbietet. ESP-IDF braucht es dafür nicht.

1. Einmal pro Board einrichten. Debug > ESP32 Board Files (die Konsole im Flash, das Dateisystem formatiert), dann Install WiFi: Der Teil für den Flash (330 KB bei 0x100000) geht über das Boot-ROM in den Flash, wlan.rom und wlansvc in die Dateien. Das dauert etwa 25 Sekunden.
2. Das Netz eintragen. In examples\abelle\esp32\inc\network.abel den Namen und das Passwort deines WLAN eintragen (leer für ein offenes Netz, sonst WPA2, 2,4 GHz).
3. Starten. Zum Beispiel ntp.abel öffnen und F9 drücken. Das Programm lädt den Dienst beim ersten WLAN-Aufruf selbst aus den Dateien des Boards, mit F9 genauso wie mit run ntp in der Konsole oder als Autostart.

Debuggen, während das WLAN läuft. Der Dienst und das WLAN laufen auf dem zweiten Kern des ESP32, das Programm auf dem ersten. Der Debugger hält nur den ersten an: Steht das Programm an einem Breakpoint, bleibt die Station verbunden, und was ankommt, wartet in einem Puffer des Dienstes (6 Frames). So kannst du durch einen DHCP-Austausch oder eine TCP-Verbindung Zeile für Zeile gehen.

Die Funktionen stehen in inc\wifi.abel, inc\net.abel und inc\tcp.abel, in aBelle geschrieben: DHCP, DNS, ARP, ICMP, UDP, TCP und mDNS kannst du dort nachlesen und im Debugger verfolgen.

Die Beispiele

In examples\esp32 liegen die Beispiele in Assembler: blink, hello_uart (je für RAM und Flash), clock (der Kern mit 80, 160 und 240 MHz) und die Konsole. In examples\abelle\esp32 liegen die Beispiele in aBelle: blink, hello_uart, chipinfo, clock, timer, dice, reaction, sieve, temperature, und für das WLAN scan, dhcp, dns, ping, wol, arpscan, ntp, udpecho, httpget, webserver und telnetd. Die Register, die sie benutzen, stehen in ihren Kommentaren, mit der Quelle.

Alle Beispiele mit Beschreibung →

Wie der Speicher aufgeteilt ist

Wenn etwas nicht geht

Was es (noch) nicht gibt

• Der Debugger hält nur den ersten Kern an; den zweiten benutzt das WLAN.
• Das Programm darf VECBASE nicht ändern, UART0 nicht für Eingaben nutzen, keine Interrupts über Stufe 5 einschalten und den CPU-Interrupt 14 nicht abschalten: Der Monitor braucht sie.
• Das WLAN nur als Station (kein eigener Access Point), offene Netze und WPA2 (kein WPA3, kein Enterprise), eine TCP-Verbindung zur Zeit, kein HTTPS, kein Bluetooth.
• Während das WLAN läuft, nichts in den Flash schreiben (kein Upload): vorher Reset Board.
• Noch nicht: eigene Programme im externen Flash (über den Cache) oder im PSRAM.
• Das WLAN gibt es bisher nur für den ursprünglichen ESP32, nicht für den ESP32-S3 und den ESP32-C3.

Weiter