- Objetivo: Portar el mayor número de emuladores a la placa TTGO VGA32 con ESP32 (debe funcionar si o si en dicha placa) con salida VGA. El nivel de emulación no tiene que ser precisa, tan sólo conseguir emular algo, con un precio muy bajo de la placa. Además se consigue quitar el mono de cuando se arrancaban los microordenadores de 8 bits, que eran inmediatos al darles al interruptor.
- Licencias: Evitar todas las licencias extrañas, que no son ni libres ni similares.
- Comunidad: Lograr una unidad en donde cualquiera pueda acceder a la información y desarrollar fácilmente sin trabas ni perder el tiempo. Tanto el usuario final como el desarrollador sólo tendría que acceder aquí (recopilación de información).
- Problemas: Se requiere teclado adaptado de usb a PS/2. Los ratones PS/2 originales dan problemas al leer coordenadas. Los teclados AT convertidos a PS/2 también dan problemas de mapeo (igual que en un PC).
Se dispone de 520 KB de RAM, pero al ser compartida con todos los módulos, se dispone sólo de 300 KB y de manera especial.
La placa oficialmente no dispone de psram.Determinados emuladores requieren de PSRAM.
Lista de tiendas que parece que tienen los chips con PSRAM (testeado por usuarios):
Información reportada por usuarios.
- https://es.aliexpress.com/item/33014937190.html Placa v1.4 reportado por fireb0y.
- https://es.aliexpress.com/item/4001229710648.html Placa v1.4 reportado por ackerman (yo mismo)
Se quedan fuera muchos emuladores (mientras no tengan licencias libres), y a fecha 2021/02/15 nos quedan:
- Funcionando:
- ESP32 Basic vga: Fork de Robert Melzi / Rob Cai para la placa TTGO VGA32 v1.4 realizado por Fernando García. Requiere SD. https://github.com/fg1998/ESP32-Basic-vga
- Emulador Chip 8: He terminado de portar el emulador de Chip8 para PC de Spittie. https://github.com/rpsubc8/ESP32TinyChip8
- Emulador AMSTRAD CPC: He terminado una versión de test para el CPC 464 y 664. El 6128 funciona, pero aún me queda por testear.https://github.com/rpsubc8/ESP32TinyCPC
- Emulador VIC20: https://github.com/fdivitto/FabGL Permite cargar los PRG desde Flash o copiar de una URL con conexión WIFI a la Flash.
- Emulador ALTAIR 8800: https://github.com/fdivitto/FabGL
- ZX-ESPectrum: En el ZX-ESPectrum.ino figura un comentario de licencia, pero no tiene importancia (se olvidaron de quitar), es 100% libre (confirmado por rampa). https://github.com/rampa069/ZX-ESPectrum Funciona Spectrum 16/48 sin PSRAM, y Spectrum 128/+2/+3 con PSRAM. Permite snapshots SNA, ROMS, leer y grabar tapes, y tiene un OSD. Se necesita activar particion Huge App 4 MB , quitar la opción de PSRAM a la hora de compilar, así como usar la macro FABGL y un sólo núcleo. Se usan los pines 1,26 y 27 para sonido y conexión serie, en lugar de usar el pin 25 para sonido. Por tanto se esta usando los pines del conector de ratón, es decir, se tiene que hacer un adaptador, para luego conectar un arduino.
- ZX-ESPectrum Wiimote:Fork de David Crespo basado en el ZX-ESPectrum de rampa. En el hardware.h ya estan definidos el pinout correcto para la placa TTGO-VGA32 (sonido 25). Tiene soporte para el mando de la WII y permite cargar SNA desde el OSD.https://github.com/dcrespo3d/ZX-ESPectrum-Wiimote/tree/lilygo-ttgo-vga32
- Tiny ZX-ESPectrum sin PSRAM: He terminado una versión de test https://github.com/rpsubc8/ESP32TinyZXSpectrum Soporta .SCR, carga de BASIC y screens desde .TAP, soporte de ratón kempston, emulación sonido AY8912, salida de pulsos de cinta por altavoz, y se ejecuta en ESP32 sin PSRAM, permitiendo los modos de 48K y 128K.
- Emulador ROM Jupiter ACE: Mediante una ROM modificada de Paul Farrow, se convierte el ZX 48K en un Jupiter Ace. No es un emulador exacto, pero sirve para lo principal. Funciona en el ZX-ESPectrum de rampa069, el wiimote y la versión que modifiqué. Sólo hay que cambiar el nombre del archivo rom a 0.rom o convertir el archivo a .h y meterlo en la sección de 128K, porque hace uso de la conmutación de bancos. https://k1.spdns.de/Vintage/Sinclair/Software/ZX%20Spectrum%20Software/Interface%202%20Cartridges/Jupiter%20Ace%20Emulator%20(Paul%20Farrow)/
- Emulador ROM ZX80: Mismo concepto que el Jupiter ACE.https://k1.spdns.de/Vintage/Sinclair/Software/ZX%20Spectrum%20Software/Interface%202%20Cartridges/ZX80%20Emulator%20(Paul%20Farrow)/
- Emulador ROM ZX81: Mismo concepto que el Jupiter ACE.https://k1.spdns.de/Vintage/Sinclair/Software/ZX%20Spectrum%20Software/Interface%202%20Cartridges/ZX81%20Emulator%20(Paul%20Farrow)/
- Gameboy clásica: He dejado una versión funcional con fabgl y vga32, con sonido.https://github.com/rpsubc8/esp32gameboy. Las roms se tienen que colocar en código, compilar y subir. He dejado 2 roms homebrew Retroid y Last Crown. Si se es usuario, y se quiere sólo subir los .hex sin falta de compilar ni usar librerias https://github.com/rpsubc8/esp32gameboy/raw/master/arduino/hex/hex.zip Creada la tool para meter hasta 10 roms en el proyecto. https://github.com/rpsubc8/esp32gameboy/tree/master/arduino/tools
- ESP32 Basic vga: Fork de Robert Melzi / Rob Cai para la placa TTGO VGA32 v1.4 realizado por Fernando García. Requiere SD. https://github.com/fg1998/ESP32-Basic-vga
- En Proceso de port:
- UZEBOX Ya he portado el emulador uzem a TTGO VGA32 a 4 fps. Para 12 fps, estoy simulando el kernel.
- IBM XT Ya he portado el Tiny8086 y el fake86 a TTGO VGA32. Estoy con un core básico de 8086, en donde simulo la BIOS y el DOS.
- IBM PC XT Fabrizio Di Vittorio está portando el 8086tinyplus con fabglhttps://github.com/fdivitto/FabGL/tree/master/examples/VGA/PCEmulator Hay que descargar la versión del repositorio y disponer de 4 MB de PSRAM, es decir, mínimo una TTGO VGA32 v1.4
- C64 Ya he portado el emulador básico de Toy de Rink Springer a TTGO VGA32. He añadido el color al modo de texto, y me faltan 3 modos de video más.
- PaleESP32VGA: Womble está desarrollando el emulador de Camputers Lynx 96K con soporte de disco. Se requiere psram para los discos, pero es fácil cambiarlo. Funciona perfecto en la TTGO VGA32 v1.4. https://github.com/retrogubbins/PaleESP32VGA
- Amstrad CPC 464: Funciona el modo 464,664 y 6128, con sonido y ratón AMX mouse.
- Tiny ZX-ESPectrum sin PSRAM: Para usar todo el modo 128K sin psram, sólo con SRAM. Versión reducida para consumir lo mínimo y poder ser usada con micros ESP32 que no tienen psram.
- Atari 2600: Ya tengo la CPU operativa.
- Tetris SpaceX: En realidad no es un emulador, es un port. https://github.com/bitluni/TetrisSpaceX Usa salida CVBS y mando NES. Hay que convertir a VGA y teclado. Ya he conseguido que salga a VGA en escala grises (falta convertir de 54 supuestos grises a RGB222 paleta 64 colores), y ya funciona el teclado. Ya se puede jugar, falta ajustar un par de cosas y convertir todos los gráficos a 64 colores. Hice un port intermedio para corregir fallos más rápidamente en Windows con SDL y devcpp.https://www.youtube.com/watch?v=BNp6kGHfFJE&ab_channel=ackerman
- Arcade Games:Es también un port. El autor Rob Cai, creó un Tetris, Snake, Breakout y Bomber para un ESP32 genérico con FABGL (8 colores), mando de ATARI y sin sonido.https://www.instructables.com/ESP32-VGA-Arcade-Games-and-Joystick/ Lo he convertido al pinout de la salida VGA (8 colores) de TTGO VGA32, sustituido el joystick por el teclado y he añadido sonido (no lo tenía). He modificado varias cosas, pero el diseño original del autor está mal implementado, dado que hace uso del propio buffer interno de la VGA para leer estados de juego. Al ser asíncrono, da problemas al realizar varios cálculos como rebotes en el breakout y en la eliminación de una línea en el Tetris. Así que aunque lo tengo al 100% portado y funcionando, voy a realizar una reimplementación para que funcione bien.
- Digger: Es también un port. Es un clásico, que jugabamos en el PC1512. https://github.com/sobomax/digger Estoy simplificando la versión de Andrew Jenner (SDL+OpenGL) a una SDL simple, para luego convertirlo al TTGO VGA32.
- UZEBOX Ya he portado el emulador uzem a TTGO VGA32 a 4 fps. Para 12 fps, estoy simulando el kernel.
- No funcionan (Hay que portar):
- Emulador NES, ATARI y SMS: https://github.com/rossumur/esp_8_bit/tree/master/src Usa salida PAL y NTSC, y está pensado para micros superiores y doble núcleo. Se requiere bypass de VGA, teclado y optimización de memoria.
- NES: Al igual que el anterior, está basado en Nofrendo https://github.com/espressif/esp32-nesemu Como casi todos los emuladores de NES para ESP32, sólo deja roms de 32 KB.Pensada para pantalla portátil LCD.
- NES: Usa ST7796S SPI LCD, TTGO T8 v1.7 ESP32, amplificador MAX98357 I2S y módulo de joystick de PSP.Basado en el nofrendo pero con la modificación para soportar cartuchos con mapper 10 https://github.com/moononournation/arduino-nofrendo Hay que convertir a VGA, teclado, reducir memoria y adaptarlo a no usar psram. https://www.instructables.com/Arduino-NES
- CornN64: Fork del de rossum pero con soporte de mandos de N64,NEs y SNES. https://github.com/CornN64/esp_8_bit
- Gameboy: https://github.com/lualiliu/esp32-gameboy Emulador bastante lento de la gameboy clásica pero muy funcional pensado para pantalla portátil LCD.
- Gameboy: https://github.com/Ryuzaki-MrL/Espeon Emulador optimizado de la gameboy clásica pensado para pantalla portátil LCD.
- C64: https://github.com/Jean-MarcHarvengt/MCUME/tree/master/MCUME_esp32/esp64 Emulador del C64. Está pensado para ESP32 con varios núcleos y pantalla LCD ILI9341, así que hay que portar a ESP32 un sólo núcleo y salida VGA. Creo que no necesita PSRAM.
- Atari 2600: Basado en Stella. Requiere bypass a VGA. Altas posibilidades que pueda directamente cargar en RAM las ROMS desde WIFI. https://github.com/stella-emu/stella Estoy realizando un port con una mezcla entre el stella, multiarcade y otros emuladores de atari 2600.
- Vectrex: Hay que portar de Teensy 4.0 y LCD ili9341a ESP32 de un sólo núcleo y salida VGA. https://github.com/Jean-MarcHarvengt/MCUME/tree/master/MCUME_esp32/espvectrex/main
- Atari 5200: El MCUME hace uso de lcd ILI9341, que hay que convertir a VGA. Hay que quitar el codigo de la SD para usar la FLASH. Soporta roms de 16 KB y 32 KB. Mirando el código, la memoria más grande usada sería de 49152 bytes.https://github.com/Jean-MarcHarvengt/MCUME/tree/master/MCUME_esp32/esp5200
- Atari 520 ST Está realizado en Teensy 4.0 y requiere PSRAM externa, así que las posibilidades de portarlo a ESP32 un sólo núcleo y SRAM, son casi nulas, a no ser que se haga un rediseño desde 0.https://github.com/Jean-MarcHarvengt/MCUME/tree/master/MCUME_teensy/teensy5200
- PC XT Está realizado en Teensy 4.0 y 4.1 con PSRAM externa. Parecido al anterior, salvo que emulásemos un XT original de 256 KB de RAM, la portabilidad sería una auténtica locura, salvo que se haga un rediseño desde 0.https://github.com/Jean-MarcHarvengt/MCUME/tree/master/MCUME_teensy/teensy8086
Quedan muchos más por poner (añadiré otro día)
- Emulador NES, ATARI y SMS: https://github.com/rossumur/esp_8_bit/tree/master/src Usa salida PAL y NTSC, y está pensado para micros superiores y doble núcleo. Se requiere bypass de VGA, teclado y optimización de memoria.
Manos a la obra
Mediante este hilo, cualquiera puede ponerse a colaborar o a recoger la información que necesita y ponerse por su cuenta a realizar cosas.
El ESP32 se creó para matar moscas a cañonazos, pensado sobre todo en la reducción de la curva de aprendizaje, es decir, para que los desarrolladores de PC pudieran usarlo fácilmente. Así, se puede acceder a una conexión WIFI con un par de instrucciones. Sin embargo, si queremos sacar todo el provecho, es decir, hilar fino, entonces se hace más cuesta arriba.
Cosas a destacar para desarrollar para esta placa:
- Memoria: Los 520 KB son compartidos con todos los módulos y el Sistema Operativo Free RTOS. Si nos quedamos sin memoria, el ESP32 provoca una excepción y se resetea. Si se usa un malloc, y no hay memoria, automáticamente se reinicia. El mejor truco es hacer como cuando se desarrollaban los juegos en los 90's, es decir, se reserva toda la memoria al principio y luego la vamos usando. Existe fragmentación de memoria, así que no se puede coger toda la memoria que queramos, ya que por límite de tamaño (fragmentos), aunque se disponga de espacio libre, no se dispone de dicho tamaño. Por tanto, lo ideal, es usar fragmentos reducidos (no más de 16 KB). Si no se dispone de un fragmento libre, resetea (watchdog). Podemos quitar módulos (WIFI, serie, bluetooth), y cosas innecesarias para ahorrar memoria.
Se dispone de memoria IRAM, es decir, memoria de código. Aunque el fabricante habla de 180 KB, suele ser de como mucho 96 KB y entra dentro de los 520 KB compartidos. Este tipo de RAM sería para variables locales y arrays de código. Si nos quedamos sin IRAM normalmente nos avisa el compilador, pero sino, se resetea el ESP32. Es la más rápida, ya que es cacheada.
- Velocidad memoria: Esto es más viejo que el respirar, y ocurre en la mayoría de microcontroladores, pero paso a ordenar de más rápida a menos, la velocidad de las diferentes tipos de memoria en dicho microcontrolador:
- IRAM: 96 KB cacheados dentro de los 520 KB de SRAM.
- RAM: El resto de SRAM hasta 520 KB que no sean IRAM.
- PSRAM: módulo de RAM externa. Se puede añadir, pero de base la placa viene sin él.
- FLASH: 4 MB alineados a 32 bits (4 bytes), es decir, que si metemos 1 byte, si no compactamos, perderemos 3 bytes. Para lecturas de 1 sólo byte, deberemos desempaquetar (más lento). Los datos (arrays) se colocan aquí con la orden PROGMEM. El código siempre va en FLASH.
- EEPROM: 512 bytes
- IRAM: 96 KB cacheados dentro de los 520 KB de SRAM.
- DMA: Existe DMA de 32 bits, pero requiere declaración de 32 bits y una forma específica de acceder, en concreto, para lograr accesos de microsegundos, conseguir cachear el acceso, con peticiones máximas de 4 KB.
- Núcleos: Se pueden crear tareas, pero sólo hay un núcleo.
- Módulos: El uso de módulos y librerias no sólo trae como consecuencia el consumo de RAM, sino también de FLASH, en concreto si usamos WIFI y peticiones GET HTTP, se consume 70 KB de RAM y 400 KB de FLASH. Si tenemos menos de 70 KB de RAM libre, el ESP32 se reseteará. Podemos usar librerias más pequeñas, pero no son estándar y dan problemas.
- Portar emuladores: Hay que descargar el emulador, adaptarlo a bajos recursos como ESP32, hacer bypass para VGA32 y bypass para probar en PC y ver en diferido. Si se usa SDL o similar, es más fácil. Si la resolución no es muy alta, se puede sacar salida a modo texto.
- Documentación Gameboy:
https://problemkaputt.de/pandocs.htm
https://diegojuod.home.blog/2019/08/17/introduccion-emulador-de-gb
Tema licencias
Las licencias tipo GNU datan de 1983. No debe perderse ni un microsegundo de tiempo en entender el alcance legal de otros proyectos. Por tanto, si quieren ser incluidos, es de obligado cumplimiento, el cambio de licencia.
Mensaje Original 2020/08/28:
Creo nuevo tema, para pedir ayuda y reunir conocimiento.
El año pasado me pillé la placa ttgo vga32,que contiene un microcontrolador TTGO micro32 compatible ESP32:

Se puede programar con:
https://github.com/fdivitto/FabGL
Se dispone de un emulador de VIC20, un ALTAIR, y se puede programar nativamente.
Pero como siempre se quiere más y más y más, pues queria tener emuladores. He probado el del Spectrum:
https://github.com/rampa069/ZX-ESPectrum
Y como no he encontrado más, me puse a pillar código de otros emuladores portados a ESP32, pero no a esta placa, en concreto, que tienen salida a TV o a GLCD.
Tenemos de gameboy:
https://github.com/lualiliu/esp32-gameboy
https://github.com/Ryuzaki-MrL/Espeon
ATARI, NES y SMS:
https://github.com/rossumur/esp_8_bit
En estos he metido mano al código, quitando toda la parte de salida de video y mandos, adaptándolo a la salida VGA (bypass) y entrada de teclado. He tenido que meter mano a la temporización para que más o menos vaya.
Dejo captura de emulador de gameboy con el juego Super Mario Land funcionando:


Dado que mis conocimientos en desarrollo de emuladores son básicos, era interesante, saber si alguien que esté más puesto en emulación está portando más emuladores para ESP32 o si tiene en mente portar, y así me ahorro el seguir con esto,
