Skip to content

readmeSpanish.md

Latest commit

 

History

History
287 lines (259 loc) · 17.3 KB

readmeSpanish.md

File metadata and controls

287 lines (259 loc) · 17.3 KB

Serial PAD

Permite usar un teclado o ratón de PC en una PSX real conectada al puerto de mandos, así como enviar datos a la PSX. Soporta:

Las funcionalidades a destacar son:
  • Ratón PS/2 (usb) - 100% funcional, incluye pantalla de test
  • Teclado PS/2 (usb) - código funcional, falta pantalla de test
  • Comunicación lenta serie - código funcional, falta pantalla de test

De esta forma se puede introducir datos por teclado o ratón en cualquier modelo de PSX o PsOne conectando un teclado a un puerto de mandos de la PSX, dándole una mayor autonomía, pudiendo actuar de ordenador personal, por ejemplo.

El ratón y teclado que van a usarse son de PC, así que este proyecto, no va a hacer uso de ratones de PSX, es decir, que no es compatible con el ratón de PSX original, y sólo funcionará con nuestro programa que traduce pulsaciones de botones.
Los resultados en máquina real, son impresionantes, dado que es muy rápido, tanto el ratón, como el teclado. Para subirlo a máquina real, lo más comodo es usar un cable skywalker, tal y como yo lo tengo, y un conversor de usb a serie, así como la versión modificada send.exe para Windows 64 bits.

Simulación

Para todo aquel que no quiera modificar un mando real de PSX, se puede realizar pruebas mediante emulación:

Una vez instalado el Auto Hot Key, podremos lanzar el KeyboardMouse.ahk, que traducirá los movimiento y pulsación de botones del ratón en pulsaciones de teclado, que el emulador ePSX interpretará como pulsación de botones del mando.

Debemos de configurar los gatillos del mando con las teclas:
  • R1 - R
  • R2 - T
  • L1 - W
  • L2 - E
Si lanzamos el script KeyboardMouse.ahk en una ventana de comandos, veremos como al mover al ratón, se generan pulsaciones de teclas:

Debemos de tener cuidado, y asegurarnos de estar en la ventana del emulador ePSX, ya que cada vez que hagamos algo con el ratón, estará pulsando teclas.

En el emulador, si lanzamos el main.exe, nos saldrá el menú con los botones:
  • Fast - Velocidad rápida del ratón
  • Normal - Velocidad normal
  • Slow - Velocidad lenta
  • X - Invierte el movimiento eje X
  • Y - Invierte el movimiento eje Y
  • Left - Zurdos
En la parte superior, nos aparecerá información de las coordenadas y botones del ratón, así como el estado del mando de la PSX. Si pasamos por encima de los botones, se iluminarán, y si se hace click se activará.
Debemos tener en cuenta, que la emulación no va bien, dado que el script de teclado y el emulador tiene unas demoras, que al final se traduce en unos movimientos no fluidos del ratón y fallos esporádicos. Sin embargo nos es muy útil para ver que al menos funciona.

Modificar mando

Si queremos una respuesta fluida, debemos modificar el mando real.

Se van a usar los 4 botones (gatillos laterales), es decir, R1, R2, L1 y L2. El motivo se debe a que son los más fáciles de modificar sin falta de usar soldador, es decir, que cualquiera puede hacerlo. Estos botones estan unidos a la placa del mando con un hilo para cada uno de los botones, y otro para la masa. La forma de detectar un botón pulsada, es muy sencilla, tna sólo con unirlo con la masa.
No todos los mandos usan el sistema de masa, así que tendremos que tener en cuenta si nuestro mando sirve para este proyecto.

Debemos mirar con el multitester la masa, que se corresponde con la masa real del mando.
Luego usaremos un sistema de buffer de transistores que activaran los botones. Dichos transistores seran controlados por un ARDUINO, de manera, que se leeran los datos del ratón PS/2 y se activarán los botones del mando. Debemos cortar los cables (lo más facil) o bien soldar la placa, una extensión de cables al exterior, para posteriormente conectar al buffer de transistores.

La resistencia para la base del transistor es de 470 Ohmios, y el transistor nos sirven el 2n3904, que es el más básico y barato del mercado. Eso no quita, que podamos hacer lo mismo con optoacopladores o incluso relés sólidos.

Mando físico en Emulador

Una vez actualizado el ARDUINO con el código del ratón, y conectado el ratón al PS/2, podemos hacer pruebas sobre el emulador ePSX, antes de probar con una PSX real, gracias a un conversor de mandos PSX a usb.

Debemos de configurar el mando en el emulador de PSX, de manera que usemos los botones del mando, en lugar de las letras.

Y si todo es correcto, al ejecutar el main.exe, podremos usar el ratón.

Mando físico en consola real

Se requiere los siguiente materiales

  • Mando PSX botones R1,R2,L1,L2
  • Adaptador usb a PS/2 o ratón PS/2
  • Teclado PS/2
  • Ratón PS/2
  • Arduino Nano o UNO
Una vez todo conectado y arrancado el main.exe, al realizar movimientos del ratón, se podrá ver en la pantalla. Debemos garantizar que nuestro ratón sea compatible con una comunicación PS/2. No todos los ratones modernos aceptan una conversión de USB a PS/2. Para estar seguros, es tan sencillo como, depurar en ARDUINO siguiendo la traza de salida a la consola serie, descomentando el código.



Protocolo Ratón

Se ha usado un protocolo muy simple similar a como se usaban los ratones en los primeros COMMODORE y MSX por puerto de juegos, pero con varias mejoras de velocidad.
Se envian cada 25 milisegundos 4 bits, que contienen:

  • 2 bits movimiento X
  • 2 bits movimiento Y
O bien:
  • 2 bits botón izquierdo
  • 2 bits botón derecho

Los bits del movimiento pueden ser:

  • 00 - No hay movimiento
  • 01 - Movimiento positivo
  • 11 - Movimiento negativo
Para los botones, si se da la opción 10 es que el botón está activo. Recordemos, que la PSX en cada retrazo vertical, se leen los datos del PAD, así que se leen entre 16 y 20 milisegundos.
El código de demora de 25 milisegundos, está puesto en el Arduino, pero podemos cambiarlo a 50 milisegundos. Para el caso del emulador de teclado, está puesto a 50 milisegundos, dado que a tiempos inferiores, ocurren problemas de sincronismo.

ARDUINO

Se puede usar casi cualquier placa de ARDUINO, pero en concreto he realizado pruebas con el NANO, que dispone de 2 pines de interrupción, útiles para el PS/2.
La disposición de pines es la siguiente:

  • 2 - CLK conector PS/2
  • 4 - pin datos conector PS/2
  • 5 - base transistor L1
  • 6 - base transistor L2
  • 7 - base transistor R1
  • 8 - base transistor R2
Se ha usado una libreria muy básica de lectura del ratón PS2Mouse.h, que se encarga de leer el movimiento del ratón, así como el estado de los botones.
Los pines activarán la base del transistor, que permitirá activar los botones del mando.

Upload PsEXE y datos

Permite enviar ejecutables y datos a la PSX por medio del puerto de mandos. Se usa un mando (4 botones) o un hack del bus de comunicaciones SPI, con un fake slave spi con arduino, de manera que no es necesario modificar el mando, tan sólo se requiere un alargador de mandos PSX, o directamente podemos conectar los cables al puerto.

Actualmente estoy consiguiendo velocidades de 20480 baudios con un custom mensaje. El cargador permite elegir el puerto en el que queremos el ARDUINO, así como el mando, y podemos:
  • Arriba - Aumenta velocidad
  • Abajo - Reduce velocidad
  • Derecha - Aumenta en 10 posiciones la velocidad
  • Izquierda - Reduce en 10 posiciones la velocidad
  • X - Acepta velocidad y nos deja 10 segundos para desconectar el mando
  • O - Detecta la desconexión del mando
  • START - Reinicia a la posición del cargador de PSXSerial de Hitmen
  • SELECT - Se restablece el programa.
El aviso de desconexión del mando, se hace así, para no interferir en el bus SPI. Si dejásemos el mando, daría problemas de comunicaciones. Si en 10 segundos no recibimos datos correctos o si ocurre un error, se reinicia el programa (no se borra memoria).

Para recibir datos, primero tenemos que tenerlos generados. Para ello, usaremos la herramienta GENFRAME, realizada en PASCAL y que funciona en DOSBOX.

Los modos de velocidad para mando 4 botones (transistores), con cargador UploadExe:

  • 0 - (50 ms 3 bits 60 baudios)
  • 1 - (25 ms 3 bits 120 baudios)

Los modos de velocidad para emulación mando digital emulado (fake spi), con cargador UploadExe:

  • 0 - (50 ms 3 bits 60 baudios)
  • 1 - (25 ms 3 bits 120 baudios)
  • 2 - (50 ms 8 bits 160 baudios)
  • 3 - (25 ms 8 bits 320 baudios)

Los modos de velocidad para emulación mando analógico emulado (fake spi), con cargador UploadExe:

  • 8 - (50 ms 16 bits 320 baudios)
  • 9 - (25 ms 16 bits 640 baudios)
  • 10 - (50 ms 32 bits 640 baudios)
  • 11 - (25 ms 32 bits 1280 baudios)

Los modos de velocidad para mensajes custom, con cargador PADSIO:

  • 12 - (50 ms 64 bits 1280 baudios)
  • 13 - (25 ms 64 bits 2560 baudios)
  • 14 - (50 ms 112 bits 2240 baudios)
  • 15 - (25 ms 112 bits 4480 baudios)
  • 16 - (50 ms 128 bits 2560 baudios)
  • 17 - (25 ms 128 bits 5120 baudios)
  • 18 - (50 ms 224 bits 4480 baudios)
  • 19 - (25 ms 224 bits 8960 baudios)
  • 20 - (50 ms 256 bits 5120 baudios)
  • 21 - (25 ms 256 bits 10240 baudios)
  • 22 - (50 ms 448 bits 8960 baudios)
  • 23 - (25 ms 448 bits 17920 baudios)
  • 24 - (50 ms 512 bits 10240 baudios)
  • 25 - (25 ms 512 bits 20480 baudios)
Esta herramienta se puede lanzar: 
 GENFRAME demo1.exe frame.txt 80010000 12 0 25
Este ejemplo, sería para el ejecutable demo1.exe convirtiéndolo en datos ASCII hexadecimales en el archivo frame.txt, dejando la cabecera de memoria en 80010000, con el modo de velocidad 12 (1280 baudios), sin compresión y con 25 milisegundos.
    Los parámetros:
  • 1 - demo.exe - Ejecutable o datos a enviar
  • 2 - frame.txt - Fichero ASCII con las tramas a enviar
  • 3 - 80010000 - Dirección de memoria donde poner los datos
  • 4 - 12 - Velocidad a enviar
  • 5 - 0 - Sin compresión
  • 6 - 25 - 25 milisegundos en enviar dato

También podemos enviar datos:

 GENFRAME time.tim tim.txt 80100000 12 0 25

Tenemos 2 cargadores, que usaremos según nos interese:

  • UploadExe - usa las librerias asíncronas PADLIB para comunicarse (velocidades de 0 a 11)
  • PADSIO - usa comunicación directa al puerto PADSIO (velocidades de 12 a 25)

Los 25 milisegundos, son la espera en cada transmisión de datos. Si queremos la máxima velocidad, lo mejor es compilar en modo NTSC nuestro cargador (teoría del muestreo), dado que soporta 60 fps.

  • NTSC - 60 fps
  • PAL - 50 fps

Se permite enviar datos al estilo de la herramienta pqbload:

  • TIM - texturas
  • CEL -
  • BGD -
  • TMD -
  • EXE - Ejecutable (automáticamente lo lanza)
  • HMD -
  • SEQ - sonido
  • SEP - sonido
  • VAG - sonido
  • VAB - sonido
Cuando los archivos no son ejecutables, se dejan en la posición de memoria especificada, y se reinicia el cargador, permitiendo cargar más datos, hasta que sea un ejecutable, que es cuando se lanza. De esta forma, podemos pasar todo tipo de datos para proyectos más complejos, dejando los datos en posiciones fijas, y sólo cargando el EXE. Cuando se carga un fichero de datos, se muestra el tipo en el mensaje de la espera de desconexión del mando.



Otros frentes de desarrollo

Se realiza un ataque en varios frentes, desde el más sencillo, al más complejo:
  • Control de teclado remoto y real (puerto PC PS2) con arduino activando 9 botones del Gamepad, por medio de un protocolo muy simple de flanco ascendente y transistores, pero lento en velocidad. Se realizará un programa que envia los datos en msdos x86 100% compatible DOSBOX para el remoto via emulación serie, así como la posibilidad de leer directamente de arduino el teclado con la libreria PS2keyboard.
  • Envio de PS-exe a memoria de PSOne o a tarjeta de memoria de PSOne con arduino activando 9 botones del Gamepad, , por medio de un protocolo muy simple de flanco ascendente, pero lento en velocidad. Se realizará un programa que envia datos en msdos x86 100% compatible DOSBOX para el remoto via emulación serie
  • Carga de PS-exe desde memorias de PSX (128 KB), con posibilidad de trozear el exe en varias tarjetas. Se realizará un programa en msdos x86 100% compatible DOSBOX para trocear el exe en múltiples .MCR de 128 KB. Dichos .MCR se puede guardar en tarjeta real desde PS2 mediante el sakura de puerto paralelo (vmware con windows 95 y 98 con soporte puerto paralelo) o el memcarduino.
  • Recepción de datos por medio de sonido de la PSX, los 2 canales de audio. Se realizará un programa en psx que genera tonos con pulsos que pueden ser decodificados como datos binarios. La psx recibirá comandos remotos y enviará los datos como sonido.
  • Simulación de mando y memoria psx por medio de arduino. He capturado los comandos del mando de la psx, así como los de la memoria, al usar un protocolo SPI a 250 Khz. Estoy realizando un programa en arduino que al recibir los comandos, envie las respuestas a un programa en la psone que interprete para cargar datos.


Uso de MSDOS

El motivo de usar MSDOS, es para lograr máxima compatibilidad con DOSBOX, de forma que se puede usar todo el kit de desarrollo psyq de 16bits, ya que así se puede usar en casi cualquier máquina actual que no sea PC. También se puede usar el msdosplayer para Windows 7 64 bits en adelante.

Historial

  • 2020/08/04 - 40% Upload PsExe y datos
  • 2020/05/25 - 100% ratón PS/2
  • En pruebas - Simulación de PAD con teclado y emulador ePSX.
  • Código comentado para uso de teclado, y envio de ficheros (recibe 100 bytes).


Conclusion

Se usa esta opción, porque mientras que la psx si dispone de puerto serie, la psone blanca, no. Se tiene por tanto que realizar modificaciones. Además se logra una alternativa al SIOCONS.