Skip to content

Latest commit

 

History

History
242 lines (211 loc) · 12.2 KB

readmeSpanish.md

File metadata and controls

242 lines (211 loc) · 12.2 KB
Raw

Test VGA ESP32

Test de los modos de vídeo en ESP32 desde el menú utilizando el teclado PS/2 o teclado remoto a través de terminal, como Putty.
Seleccione el modo de vídeo con las teclas de flecha arriba y abajo y pulse ENTER para aceptar.

  • 360x200x70hz bitluni
  • 320x240x60hz bitluni
  • 320x240x60hz fabgl
  • QVGA 320x240x60hz fabgl
  • 320x200x70hz bitluni
  • 320x200x70hz fabgl
  • 360x400x70.4hz bitluni
  • 400x300x56.2hz bitluni
  • 320x350x70hz bitluni
  • 320x400x70hz bitluni
  • 640x400x70hz bitluni
  • TTGOVGA32 PAL CVBS 5V (PAL CVBS GPIO 26)
  • TTGOVGA32 PAL CVBS 5V+ (PAL CVBS GPIO 26)
  • ESP32 PAL CVBS 3V (PAL CVBS GPIO 26)
  • TTGOVGA32 NTSC CVBS 5V (NTSC CVBS GPIO 26)
  • TTGOVGA32 NTSC CVBS 5V+ (NTSC CVBS GPIO 26)
  • ESP32 NTSC CVBS 3V (NTSC CVBS GPIO 26)
  • 320x240x60hz bitluni PLL
  • 320x200x70hz bitluni PLL
  • 384x264x56.2hz bitluni
  • 360x240x56.3hz bitluni
  • T40x25 320x200x70 bitluni
  • T40x30 320x240x60 bitluni
  • T50x37 400x300x56.2 bitlun
  • T80x50 640x400x70 bitluni
  • T80x25 640x400x70 bitluni
  • T40x25x3 320x200x70 bitlun
  • T40x30x3 320x240x60 bitlun
  • T50x37x3 400x300x56.2 bitl
  • T80x50x3 640x400x70 bitlun
  • T80x60x3 640x480x70 bitlun
  • T80x25x3 640x400x70 bitlun
  • 320x200x1x70Hz bitluni
  • 320x240x1x60Hz bitluni
  • 400x300x1x56.2hz bitluni
  • 640x400x1x70hz bitluni
  • 800x600x1x54.2hz bitluni
  • PIC 250 GTO
  • PIC Phantis
  • PIC Game Over
  • PIC Mandril



Versión precompilada

En la carpeta precompile se encuentra la versión compilada para poder ser grabada con el flash download tool 3.9.2.

https://github.com/rpsubc8/ESP32TestVGA/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 (Ricardo Massaro) 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 ESP32TestVGA. 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 testvga.ino del directorio testvga.

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.



Test teclado PS/2

Para testear un teclado PS/2:

https://github.com/rpsubc8/testkeyboardPS2



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
  • ENTER: Envía ENTER (aceptar)
  • Arriba: Arriba (incremento 1)
  • Abajo: Abajo (decremento 1)
  • Derecha: Derecha (incremento 10)
  • Izquierda: Izquierda (decremento 10)
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_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.
  • 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_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.



Monocromo (8 colores)

En la época clásica se usaban monitores en blanco y negro, de manera que se sacaba más partido frente al color. Aplicando un filtro básico de escala de grises se puede conseguir el mismo efecto, con tan sólo 8 colores y el DAC básico de 3 bits.
He creado una tool para convertir la paleta de 8 colores en el modo DAC 3 bits (RGB) a un degradado monocromo. Aquí se puede ver una maqueta de coche del Ferrari 250 GTO con los 8 colores:

Y aquí activando el filtro de escala de grises con 8 degradados:

El filtro se puede conseguir fácilmente, con un monitor VGA monocromo.
En los monitores y TV modernos, si disponen de filtros en el OSD, también es muy sencillo. Si no, se puede variar los valores de cada componente RGB desde el OSD para lograr la saturación.
Si tenemos una capturadora VGA, podemos aplicar el filtro desde el propio Windows, activando la saturación.

Si ponemos el digital vibrance de 50 a valor 0, nos queda en blanco y negro.


Aquí está la paleta del DAC 3 bits de 8 colores con su valor decimal y el binario (RGB):

Aquí está, como se vería desde un monitor monocromo:

Como se puede ver, el orden lógico no se corresponde con el real de luz. Para eso, si aplicamos un orden por luminancia:

Este orden, es lo que se aplica a la imagen internamente, para que así se puede ver realmente los 8 degradados de gris, de forma que el orden es:
  • 0 - 0
  • 1 - 4
  • 2 - 1
  • 3 - 5
  • 4 - 2
  • 5 - 6
  • 6 - 3
  • 7 - 7

Para procesar las imágenes, debemos de convertirlas a escala de gris (256 degradados) desde Gimp o desde Paint Shop Pro, para después aplicar la reducción de 8 colores en degradado de gris:

Debemos asegurarnos que nos quedan 8 colores, aunque estemos usando formatos de imágenes con 16.

Y por último se aplica una conversión a RAW.
A la hora de visualizar, se debe aplicar el orden mencionado.

Aquí tenemos el Phantis con 8 colores:

Y aquí en monocromo:

Aquí está el GameOver con 8 colores:

Y aquí en monocromo:

El mandril de test EGA y VGA con 8 colores:

Y aquí en monocromo: