Skip to content

Latest commit

 

History

History
218 lines (187 loc) · 13.5 KB

readmeSpanish.md

File metadata and controls

218 lines (187 loc) · 13.5 KB

Tiny MCUME esp81

Modificación del emulador MCUME zx81 (Jean MarcHarvengt) a la placa TTGO VGA32 v1.0, v1.1, v1.2 y v1.4 con ESP32.

He realizado varias modificaciones:
  • No se usa PSRAM, funcionando en ESP32 de 520 KB de RAM (TTGO VGA32 v1.x)
  • Uso de un sólo core
  • OSD de bajos recursos
  • Creado proyecto compatible con Arduino IDE y Platform IO
  • Se puede usar cualquier pin digital para el video (hardware.h)
  • Menú de velocidad de video de emulación, VGA, teclado
  • Soporte para modo 64 colores (DAC 6 bits) y 8 colores (DAC 3 bits).
  • VGA 320x200 y 360x200 de bitluni, así como 320x200 con parámetros de fabgl
  • Opción de eliminar el cálculo de redondeo IEEE (double) de la VGA
  • Carga de ficheros pfiles
  • No se requiere la libreria de bitluni completa. He reducido a lo mínimo, ahorrando RAM y FLASH, basado en la librería de Ricardo Massaro
  • Soporte modo Hi-res y pseudo hi-res
  • Soporte CVBS PAL NTSC Blanco y Negro en placa TTGO VGA32 (pin 26 CLK PS/2)
  • El modo CVBS por defecto no tiene borde y sale en modo invertido de color, para que se puede ver en el mayor número de TV sin problemas.
  • Proyecto compatible con Web Editor y ArduinoDroid (6.3.1) con tool makeandroid.bat
  • El OSD se muestra con la tecla F1
  • Añadido soporte de teclado desde terminal serie usb, monitor VStudio o putty.
  • Teclado mapeado 
     //Keyboard Matrix
 // Port____Line____Bit__0____1____2____3____4__
 // FEFEh  0  (A8)     SHIFT  Z    X    C    V
 // FDFEh  1  (A9)       A    S    D    F    G
 // FBFEh  2  (A10)      Q    W    E    R    T
 // F7FEh  3  (A11)      1    2    3    4    5
 // EFFEh  4  (A12)      0    9    8    7    6
 // DFFEh  5  (A13)      P    O    I    U    Y
 // BFFEh  6  (A14)    ENTER  L    K    J    H
 // 7FFEh  7  (A15)     SPC   .    M    N    B



Versión precompilada

En la carpeta precompile se encuentran varias versiones ya compiladas para poder ser grabada con el flash download tool 3.9.2. con los juegos de demostración en FLASH.

https://github.com/rpsubc8/ESP32TinyMCUMEesp81/tree/main/ESP32/precompile

Debemos de elegir el tipo ESP32:

Posteriormente, seleccionaremos los archivos tal y como la captura adjunta, con los mismos valores de offset:

Y le daremos a start. Si todo ha sido correcto, sólo tendremos que reiniciar el ESP32.



Requerimientos

Se requiere:
  • TTGO VGA32 v1.x (1.0, 1.1, 1.2, 1.4)
  • Visual Studio 1.66.1 PLATFORMIO 2.5.0 Espressif32 v3.5.0
  • Arduino IDE 1.8.11 Espressif System 1.0.6
  • Librería reducida Arduino bitluni 0.3.3 (incluida en proyecto)




ArduinoDroid

Se debe ejecutar, sólo una vez, el script makeandroid.bat, que nos deja toda la estructura de datos del directorio dataFlash en el directorio raiz, así como reemplazando las archivos principales con llamadas de los .h sin usar el directorio de datos dataFlash.
Al finalizar, el propio script, termina borrando el directorio dataFlash.
El script utiliza el fart.exe (find and replace text).
Una vez, se haya ejecutado con éxito, se puede usar con el ArduinoDroid.



Arduino Web Editor

Se debe ejecutar, sólo una vez, el script makeandroid.bat. Una vez finalizado, se sube a la nube como un proyecto cualquiera, ya sea comprimido en zip o por archivos.

PlatformIO

Se debe instalar el PLATFORMIO 2.5.0 desde las extensiones del Visual Studio. Se requiere también Espressif32 v3.5.0.

Luego se seleccionará el directorio de trabajo TinyMCUMEesp81ttgovga32. Debemos modificar el fichero platformio.ini la opción upload_port para seleccionar el puerto COM donde tenemos nuestra placa TTGO VGA32, si por algun motivo no nos lo detecta.

Luego procederemos a compilar y subir a la placa. No se usa particiones, así que debemos subir todo el binario compilado. Está todo preparado para no tener que instalar las librerias de bitluni ni fabgl.



Arduino IDE

Todo el proyecto es compatible con la estructura de Arduino 1.8.11. Tan sólo tenemos que abrir el MECUMEesp81.ino del directorio MECUMEesp81.

Debemos instalar las extensiones de spressif en el gestor de urls adicionales de tarjetas https://dl.espressif.com/dl/package_esp32_index.json
Ya está preparado el proyecto, de forma que no se necesita ninguna librería de bitluni ni fabgl. Debemos desactivar la opción de PSRAM, y en caso de superar 1 MB de binario, seleccionar 4 MB de partición a la hora de subir. Aunque el código no use PSRAM, si la opción está activa y nuestro ESP32 no dispone de ella, se generará una excepción y reinicio del mismo en modo bucle.



Modo Hi-res



Teclado UART

Se se activa la opción use_lib_keyboard_uart, se permite usar el teclado del PC desde el monitor VStudio o desde el putty (115200 bauds), de manera simple, dado que no es mediante lectura SCANCODE down, up:
  • Tecla TAB o tecla F2: Muestra OSD
  • Space: Barra espaciadora
  • ENTER: Envía ENTER en el ZX81
  • +: Envia ALT_GR
  • -: Envia SHIFT LEFT
  • .: Envia .
  • Arriba: SHIFT + 7 y Kempston Arriba
  • Abajo: SHIFT + 6 y Kempston Abajo
  • Derecha: Kempston derecha
  • Izquierda: Kempston izquierda
  • A..Z, a..z: a..z
  • 0..9: 0..9
Desde el Arduino IDE, no se permite dicha funcionalidad, dado que el monitor serie requiere el envio del ENTER por cada acción.



Opciones

El archivo gbConfig.h se seleccionan las opciones:
  • use_lib_vga8colors: Obliga a usar RGB modo de 8 colores (3 pines). Saca 8 colores, frente a los 64 del modo normal (6 pines RRGGBB).
  • use_lib_log_serial: Se envian logs por puerto serie usb
  • use_lib_keyboard_poll_milis: Se debe especificar el número de milisegundos de polling para el teclado.
  • gb_delay_emulate_ms: Milisegundos de espera por cada frame completado.
  • use_lib_delay_tick_cpu_auto: Si está a 1, la CPU se autoajusta a 20 ms por frame.
  • use_lib_delay_tick_cpu_milis: Si use_lib_delay_tick_cpu_auto está a 0, lo que definamos aqui, será la espera en milisegundos por frame.
  • FIX_PERIBOARD_NOT_INITING: Solución realizada por dcrespo3D para la inicialización en algunos teclados.
  • use_lib_cvbs_bitluni: Si está activo, no usa código de VGA, ni genera salida VGA. Usa la librería modificada de CVBS Bitluni. Si está comentado, usa todo el código de VGA. En la placa TTGO VGA32 se está usando el pin 26, es decir, el CLK del conector PS/2 del ratón.
  • use_lib_cvbs_bitluni_not_backbuffer: No usa el doble buffer en CVBS, ahorrando memoria. Puede ocasionar defectos visuales (flickering).
  • use_lib_cvbs_pal: Si está activo junto con use_lib_cvbs_bitluni, la salida de video será en norma PAL, sino NTSC.
  • use_lib_cvbs_ttgo_vga32: La placa TTGO VGA32 utiliza una salida de 5 voltios, en lugar de 3v. Por tanto se debe tener descomentada dicha línea si se usa la salida de TV, para poder reducir a 1 voltio la salida del DAC.
  • use_lib_cvbs_ttgo_vga32_bright: Si la salida del DAC en la TTGO VGA32 de 5v, es muy bajo, si se activa esta opción se puede incrementar un poco el brillo. Usar con cuidado, dado que la norma CVBS es de 1 voltio.
  • use_lib_invert_color_default_value: Permite la inversión de color, es decir, blanco por negro. En el modo CVBS por defecto está invertido. Sus valores son 1 o 0.
  • use_lib_stats_time_unified Permite ver trazas por el puerto serie con los fps, así como microsegundos actuales, mínimos y máximos por frame. Lo mismo para el video.
  • use_lib_fix_double_precision No usa el cálculo de frecuencia de video VGA con el propio ESP32, evitando posibles problemas de precisión con la mantisa. Es útil para ESP32's que calculen mal la frecuencia.
  • use_lib_debug_i2s Traza con los cálculos del modo de video.
  • use_lib_vga360x200x70hz_bitluni Modo de video 360x200 con los parámetros de bitluni.
  • use_lib_vga320x200x70hz_bitluni Modo de video 320x200 con los parámetros de bitluni.
  • use_lib_vga320x200x70hz_fabgl Modo 320x200 con los parámetros de fabgl.
  • use_lib_border_x Desplaza en múltiplos de 4 pixels la pantalla, útil para el modo de video 360x200. No exceder el valor 10, ya que se saldría del buffer.
  • use_lib_keyboard_uart: Permite usar el teclado del PC desde el PC por terminal monitor VStudio o desde el putty, sin falta de tener teclado. Útil para no tener que usar el teclado físico PS/2 y para desarrollo.



DIY circuito

Si no queremos usar una placa TTGO VGA32 v1.x, podemos construirla siguiendo el esquema de fabgl:

Para el caso de querer salida de video cvbs, en lugar de VGA, debemos de sacar un cable directo del pin 26 del conector PS/2 del ratón, activando la opción use_lib_cvbs_pal, así como use_lib_cvbs_ttgo_vga32 del gbConfig.h. Si no activamos dicha opción, la salida será de más de 1 voltio, teniendo que ser reducida con un reductor de voltaje (potenciómetro).

El conector de PS/2 es visto desde el propio jack de la placa, es decir, jack hembra. El pin en PS/2 es el CLK, es decir, el 5.

En esta imagen se puede ver el mosfet SOT23 interno de la placa TTGO VGA32, de manera, que la salida en CLK (pin 5) es 5 voltios.



Test DAC cvbs

Para TTGO VGA32 como la salida es 5v, o hacemos reducción de voltaje o podemos reducir la escala del DAC. En 3.3v de salida, con máximo el valor de 77, ya nos daría 0.99v, que sería 1v. Si tenemos 5v de salida, con 50, ya tenemos 0.97v, que sería 1v. De esta forma, ya no necesitamos resistencias reductoras, es el cable directo. Mientras no nos pasemos de 77 en 3.3v o 50 en 5v, no tendremos problema, sobre todo si sólo necesitamos 2 colores (blanco y negro). Podemos hacer pruebas con un multímetro, sobre todo en la TTGO VGA32 v1.x: 
//ESP32 Pin 26
//DAC - Voltaje
//  0 - 0.06
// 38 - 0.52
// 77 - 1
//255 - 3.17

#include <Arduino.h>
#include <driver/dac.h>


const int arrayValue[4]={0,38,77,255};
unsigned char cont=0;


void setup() {
Serial.begin(115200);
dac_output_enable(DAC_CHANNEL_2);
}


void loop() {
dac_output_voltage(DAC_CHANNEL_2, arrayValue[cont]);
Serial.printf("%d\n",arrayValue[cont]);
delay(4000);
cont++;
cont &= 0x03;
}
Los valores máximos al escribir en el buffer de video en una placa ESP32 es de 54, mientras que para TTGO VGA32 v1.x sería de 35.



Tool p2h

He creado una herramienta muy básica, para convertir los archivos .p en .h en modo lista para ser procesados por el emulador. Tan sólo tenemos que dejar los archivos .p en la carpeta input\pfile y ejecutar el archivo p2h.exe, de forma que se generará una salida en el directorio dataFlash. Para pruebas, se ha dejado un archivo en el directorio pfile, que se recomienda borrar en caso de realizar una nueva lista personalizada. También se recomienda borrar los archivos del directorio MECUMEesp81\dataFlash\pfile para tener un proyecto limpio.

Tool p2h 

 input/
  pfile/ 
 output/
  dataFlash/
   pfile/
Posteriormente debemos copiar el directorio dataFlash en el proyecto TinyMCUMEesp81ttgovga32\MECUMEesp81 sobreescribiendo la carpeta dataFlash previa. Se recomienda limpiar el proyecto y volver a compilar.
Esta herramienta es muy simple, y no controla los errores, por lo que se recomienda dejarle los archivos con nombres muy simples y lo más sencillo posible.
El proyecto en PLATFORM.IO está preparado para 2 MB de Flash. Si necesitamos los 4MB de flash, tendremos que modificar la entrada del archivo platformio.ini 
board_build.partitions = huge_app.csv
En el Arduino IDE, debemos elegir la opción Partition Scheme (Huge APP).