Artikelen

esp-vim: Echte Vim op de ESP32-P4 en ESP32-S3

01-10-2026 16:10 • Makers • https://github.com/omwah/esp-vim

esp-vim is een implementatie van echte Vim die draait als de firmware van een ESP32-microcontroller. Er is geen Linux en geen computer op de achtergrond: de chip start direct in Vim 9.2, waarbij Vim het volledige systeem vormt. Op een board met een scherm en een toetsenbord fungeert het als een pocketcomputer voor schrijven, scripting en het experimenteren met hardware; op een kale board draait het via een seriële terminal.

esp-vim: Echte Vim op de ESP32-P4 en ESP32-S3

Functionaliteiten

Echte Vim 9.2: Ondersteuning voor vensters, buffers, registers, macro's, Vim script, :vimgrep, diff, syntax-highlighting en inspringen voor 30 bestandstypen, en spellingscontrole.
Eigen scherm en toetsenbord: Draait op het display van het board met een ingebouwd, USB- of Bluetooth (BLE) toetsenbord en touch, of op elke seriële terminal.
Bestanden overal: Toegang tot flashgeheugen, SD-kaarten en externe machines via SCP en SFTP via :EspFiles, een bestandsbeheerder met twee panelen in de stijl van Midnight Commander.
Bestandsoverdracht: Ondersteuning voor SCP, SFTP, HTTP(S)-downloads en USB-massageheugen.
Webinterface: Een wachtwoordbeveiligde browserpagina voor bestanden en instellingen, inclusief een live-weergave van wat er wordt bewerkt.
MicroPython: Voer scripts uit vanuit de editor en script Vim zelf in Python.
Git: Voer init, commit, diff, log, clone, fetch en push uit direct vanuit Vim.
Hardwarebediening vanuit de editor: Beheer WiFi, Bluetooth, GPIO, ADC, I²C, sensoren, seriële poorten, persistente instellingen, geheugen en taken via :Esp-commando's en functies.
Ontworpen als volledig systeem: :q start Vim ter plekke opnieuw op, een spinner geeft aan wanneer het systeem bezig is, en :help bevat specifieke informatie over het apparaat.

Gebruik van het systeem

Weergave

Op een board met een display tekent Vim direct op het scherm via een terminalemulator die op de chip draait. Op elk board kan het ook tekenen op een seriële terminal: de console-UART van de chip verzendt het scherm van Vim, en een terminalprogramma op uw computer geeft dit weer, vergelijkbaar met het inloggen op een remote machine.

Typen

Gebruik het eigen toetsenbord van het board (indien aanwezig), een USB-toetsenbord, een Bluetooth-toetsenbord gekoppeld via :EspBtKeyboard (alleen BLE-toetsenborden: geen van beide chips ondersteunt Bluetooth Classic), of touch (tikken om de cursor te verplaatsen, slepen om te scrollen). Op een touchscreen zonder aangesloten toetsenbord verschijnt automatisch een koppelingsscherm, zodat een Bluetooth-toetsenbord alleen met tikken kan worden gekoppeld. Elke functietoets-opdracht heeft ook een lettertoets voor toetsenborden zonder F-toetsen. Via seriële verbindingen gaan toetsaanslagen vanuit uw terminal direct naar Vim, inclusief muisondersteuning. Alles werkt zoals in de desktopversie van Vim, inclusief pijltjestoetsen, Backspace en CTRL-C.

Bestanden

Uw bestanden staan in het flashgeheugen op /fat en op de SD-kaart op /sd, en blijven bewaard na herstarts. :e, :w en <Tab>-aanvulling werken zoals gebruikelijk. Paden die beginnen met scp:// en sftp:// bereiken andere machines. :EspFiles plaatst twee mappen (lokaal of extern) naast elkaar voor het kopiëren, verplaatsen en verwijderen van bestanden.

Om bestanden buiten de editor te verplaatsen, kunt u het board via USB aan een computer koppelen (het verschijnt als een schijf) of de webinterface starten met :EspWebStart en een browser gebruiken.

Programmeren

Er zijn twee talen beschikbaar. Vim script, waarbij de hardware bereikbaar is via esp_*() functies:

:EspWifiScan                   " nabijgelegen netwerken, in een venster
:EspGpio 21 on                 " zet GPIO 21 hoog
:EspNvs app greeting hello     " sla een instelling op die herstarts overleeft
:echo esp_info().chip          " ESP32-P4

" knipper GPIO 21 vijf keer
for i in range(10)
  call esp_gpio_write(21, i % 2)
  sleep 500m
endfor

En MicroPython, waarmee scripts kunnen worden uitgevoerd (:EspPyRun voert de huidige buffer uit) en die de editor kan aansturen via een vim-module en de hardware via een esp-module:

# Licht een LED aan zolang de huidige buffer TODO's bevat
import esp, vim
todos = [n for n, line in enumerate(vim.current.buffer, 1) if "TODO" in line]
esp.gpio_write(21, 1 if todos else 0)
vim.command(f"echo '{len(todos)} TODOs'")

Er is geen operating-system shell, dus :!cmd en :terminal bestaan niet. De :Esp-commando's en MicroPython nemen hun plaats in.

Versiebeheer

:EspGitInit, :EspGitCommit, :EspGitDiff, :EspGitPush, :EspGitClone en aanverwante commando's beheren een echt git-repository in /fat of /sd. Dit is compatibel met git op uw computer en pushes/fetches verlopen via HTTPS of SSH.

Help

:help opent een gids voor het apparaat: wat er anders is ten opzichte van desktop Vim, de :Esp-commando's, toetsen, opslag en instellingen. :q laat u niet achter met een dood apparaat; Vim start ter plekke opnieuw op.

Systeemvereisten

Benodigdheden

Component	Vereiste
Chip	ESP32-P4 of ESP32-S3
Flash	16 MB
PSRAM	Minimaal 8 MB; meer ruimte laat plek over voor MicroPython en grotere bestanden

Flash-indeling (voor 16 MB): 7 MB voor de firmware (momenteel 2.2 MB, met ruimte voor netwerken, MicroPython en git), 3 MB voor Vim's runtime-bestanden (2.2 MB gebruikt: syntax, help, plugins), ongeveer 5.5 MB voor uw bestanden op /fat, en 64 KB voor instellingen. Een SD-kaart voegt extra opslag toe op /sd.

PSRAM is verplicht. Het geheugen van Vim bevindt zich hier, omdat het interne RAM van de chip (maximaal een paar honderd KB) onvoldoende is. Vim gebruikt ongeveer 0.5 MB bij het bewerken van een typisch bestand en piekte nabij 2.7 MB in de testsuite met help en syntax-highlighting geladen. Er is tot maximaal de helft van de vrije PSRAM toegestaan (maximaal 16 MB).

Ondersteunde Hardware

Board	Chip	Flash / PSRAM	Scherm en invoer
M5Stack Tab5	ESP32-P4	16 MB / 32 MB	1280×720 touchscreen; clip-on keyboard (Sym layer geeft F1–F12), USB-toetsenborden, BLE-toetsenborden via ESP32-C6 radio
ESP32-S3 "Cheap Yellow Display" (CYD) (bijv. Hosyond ES3C28P)	ESP32-S3	16 MB / 8 MB (vereist)	Ingebouwd touch LCD; BLE-toetsenborden (gekoppeld via touch); console over eigen USB van de S3
Freenove ESP32-S3 Display FNK0115Q	ESP32-S3	16 MB / 8 MB	Touch LCD, 80×24 cellen (72×21 of 100×30 met `:EspFont`); BLE-toetsenborden; console over USB-serial bridge
Waveshare ESP32-S3-RLCD-4.2	ESP32-S3	16 MB / 8 MB	Zwart-wit reflectief LCD, geen backlight, 66×25 cellen (variabel met `:EspFont`); BLE-toetsenborden; console over eigen USB
ESP32-S3 development boards	ESP32-S3	16 MB / 8 MB (vereist)	Geen: een seriële terminal

Opmerking voor CYD-boards: Alleen de ESP32-S3 varianten met 16 MB flash en 8 MB PSRAM (module N16R8) kunnen dit draaien. De originele CYD (ESP32-2432S028) met 4 MB flash en geen PSRAM is onvoldoende.

Installatie en Emulator

Proberen in de emulator

Vereisten: Linux x86-64, pixi en Git LFS.

git clone https://github.com/omwah/esp-vim.git && cd esp-vim
git lfs pull              # haal Vim source en emulator archives op
pixi install              # host tools installeren
pixi run deps             # extraheer en patch upstream naar build-deps/

Installeer vervolgens ESP-IDF v5.5.5 buiten de repo, binnen de pixi-omgeving:

git clone -b v5.5.5 --depth 1 --recurse-submodules --shallow-submodules \
https://github.com/espressif/esp-idf.git ~/esp/esp-idf
pixi run -- bash -c 'cd ~/esp/esp-idf && ./install.sh esp32p4'
pixi run -- bash -c 'cd ~/esp/esp-idf && \
python tools/idf_tools.py install cmake ninja'
pixi run env-check        # moet ESP-IDF v5.5.5 en riscv32-esp-elf 14.2.0 rapporteren

Bouw de firmware, start de emulator en koppel een terminal:

pixi run vim-build
pixi run emu esp-vim -- --uart-tcp 127.0.0.1:5555   # Terminal 1: het "apparaat"
pixi run emu-tty                                    # Terminal 2: uw scherm en toetsenbord

Koppel met Ctrl-]. Gebruik pixi run vim-test voor de volledige regressietestsuite.

Installeren op een board

Bouw de firmware en flash deze via ESP-IDF:

pixi run vim-build-tab5       # Voor M5Stack Tab5; gebruik vim-build-s3 voor ESP32-S3
pixi run -- bash -c '. scripts/env.sh && idf.py -C esp-vim -B esp-vim/build-tab5 -p /dev/ttyACM0 flash'

Voor specifieke boards:

ESP32-S3: gebruik build-esp32s3.
Hosyond ES3C28P: gebruik pixi run vim-build-es3c28p (console op eigen USB).
Freenove FNK0115Q: gebruik pixi run vim-build-fnk0115 (console via USB-serial bridge).

Koppel een terminal aan de seriële poort met bijvoorbeeld: pixi run -- socat -,raw,echo=0,escape=0x1d /dev/ttyACM0,raw,echo=0

Informatie voor Ontwikkelaars

Taken (Pixi)

Alle acties verlopen via pixi. Gebruik pixi task list voor het volledige overzicht.

Taak	Beschrijving
`pixi run deps`	Verifieert, extraheert en patcht upstream bronnen in `build-deps/`
`pixi run add-dep`	Voegt een nieuw third-party archief toe aan LFS
`pixi run env-check`	Print actieve python / ESP-IDF / cross-compiler versies
`pixi run spike`	Bouwt en draait de Phase 1 capability spike in de emulator
`pixi run configure-vim`	Voert Vim's configure uit op de host voor een baseline `auto/config.h`
`pixi run runtime`	Curateert `$VIMRUNTIME` en genereert `filetype.vim`
`pixi run vim-build`	Bouwt de Vim firmware voor ESP32-P4
`pixi run vim-build-s3`	Bouwt de ESP32-S3 variant
`pixi run vim-build-tab5`	Bouwt de M5Stack Tab5 variant (P4, WiFi via C6)
`pixi run c6-build`	Bouwt de firmware voor de ESP32-C6 co-processor van de Tab5
`pixi run vim-test`	Regressietest op ESP32-P4 (reboots, console, webinterface)
`pixi run vim-size`	Rapporteert de text/data/bss grootte van de Vim component
`pixi run emu <dir>`	Draait een gebouwd project in de `esp-emu`
`pixi run emu-tty`	Koppelt een raw terminal aan de emulator

Help op het apparaat

:help op het apparaat opent een specifieke gids (een aangepaste versie van help.txt) over opslag, bestandstypen, toetsen en instellingen. Dit kan worden bewerkt in esp-vim/runtime-image/doc/help.txt.in.

Ondersteunde bestandstypen

Bewerk esp-vim/filetypes.conf om te bepalen welke bestandstypen worden ondersteund. Elke regel bevat een bestandstype gevolgd door de bijbehorende patronen. Dit bepaalt welke syntax-, ftplugin- en indent-bestanden worden meegeleverd.

Host Tools

De volgende tools zijn vastgepind in pixi.toml voor reproduceerbaarheid:

ncurses: Nodig om ./configure te voltooien, ook al gebruikt de ESP-build builtin termcaps.
socat: Voor raw-mode terminal sessies over de emulated UART.
openssh: Voor het testen van SCP/SFTP en git push.
python 3.13: Nodig voor de bootstrap van ESP-IDF.

Third-party broncode

Upstream broncode wordt niet direct gecommit. Elke afhankelijkheid is een Git LFS-archief in third_party/ met een patch-serie in patches/<dep>/. Dit maakt wijzigingen aan upstream expliciet en vereenvoudigt het updaten naar nieuwere Vim-versies.

Projectstructuur

Pad	Beschrijving
`docs/`	Plannen, fase-resultaten, besluiten en afbeeldingen
`third_party/`	LFS-archieven en manifest (geen bronbestanden)
`patches/<dep>/`	Wijzigingen aan upstream, toegepast in lexicale volgorde
`scripts/`	Dependency prep, environment, emulator harness
`esp-vim/`	Het ESP-IDF project
`build-deps/`	Geëxtraheerde en gepatchte upstream (git-ignored)

Licentie

De eigen code, scripts en documentatie van dit project zijn gelicentieerd onder de Apache License 2.0.

Third-party componenten behouden hun eigen licenties:

Vim (en patches): Vim-licentie.
esp-emu: Apache-2.0.
ESP-IDF: Apache-2.0.

article_shortcut	Samenvatting laten zien
receipt_long	Volledige tekst laten zien
favorite	Artikel opslaan als favoriet
keep	Artikel vastzetten in linker kantlijn
settings	Categorie-instellingen beheren