Bluetooth a PS/2: Necesidades modernas, sistemas de antaño

Como crear un adaptador de teclado Bluetooth a PS/2 si nadie lo ha hecho antes

Si hablara, ella te diría que me conoce desde chico, y yo te digo que la conozco muy bien. A ella le debo parte de mi interés por la ciencia, por las cosas técnicas. Fue tal el revuelo en casa cuando apareció, que algo adentro de mi muy joven yo hizo clic. Con ella podía jugar, dibujar, explorar, hacer mi propio mundo ahí adentro, pero no era simple. Había que aprender, había que probar, pero había que tenerle respeto para no romperla, que ya era una herramienta esencial de trabajo. Fuera del horario laboral éramos yo y ella. No podía molestar cada vez que quería hacer algo, tuve que aprender yo mismo como usarla, como invocar las cosas que quería,  como salir de ese menú raro que se había puesto y no había visto nunca.

Ella, es mi PC 486 de 1997. Cyrix DX2 a 66Mhz en sus orígenes, hoy un DX4 a 100Mhz después de que esa batería asesina le comiera su placa madre original. No importa, sigue siendo ella, con su hermoso gabinete y un disco duro que al día de hoy tiene los mismos dibujos y savegames que le hice cuando tenía 7 años, más o menos. Para mi siempre fue todo pc speaker; era una PC de trabajo. Ya de adolescente un amigo me regaló su vieja SoundBlaster CT2230, y descubrí todo lo que me había estado perdiendo. De vez en cuando juego algún que otro juego, como los legendarios Monkey Island que nunca jugué de chico, le vuelvo a dar una pasada a los niveles de Jill of the Jungle que tanto conozco, o instalo algún que otro software interesante que hoy en día gracias a los archivos online están al alcance de la mano.

Yo y ella, allá por los 90

En fin, ella me acompañó toda mi vida. Siempre en su propio mueble y hoy en día en escritorio compartido con mi setup moderno; comparte monitor y parlantes con mi Lenovo Yoga 720 de 2017 utilizando un conversor de VGA a HDMI. Solo tengo que estirarme, encenderla, tocar dos botones en el monitor y ¡pum!, nos fuimos a 1997. ¿Nos jugamos YA un Indianápolis 500? Dale. Acordate que la carpeta se llama INDI y está en C:\JUEGOS\. Si más vale, cómo olvidarlo, dejame que en Norton Commander uso las flechas del teclado y ya lo pong… ¡Ah!, el teclado. Beige, enorme, crujiente pero de muy buenas teclas y un enter que daba placer, engorroso y con un cable largo. Saco mi moderno y práctico teclado Bluetooth que uso con la 720 y me dispongo a cambiarlo por ese bicho, ¡si solo pudiera usar el mismo teclado para mis dos PCs!

De toda necesidad salen planes y de esos planes, soluciones. No encontré nada en internet que resuelva mi problema, parecía que nadie lo había intentado y ninguna empresa le vió potencial comercial como para ponerse a fabricar un adaptador que permita conectar un teclado Bluetooth a un sistema con puerto PS/2. Ahí nomás se me prendió la lamparita y acepté el desafío, de la misma manera que acepté el desafío de aprender computación cuando era joven. Tenía que poner a uso práctico mis modestos conocimientos de C++ y hacer un proyecto con alguna de esas placas de desarrollo que tan famosas son hoy en día. Arduino tiene una gran comunidad pero su hard está un poco anticuado ya. Así descubrí la ESP-32 de EspressIF, este pequeño gigante tiene WiFi, Bluetooth, un IO completísimo y un procesador de núcleos duales a 240Mhz, todo a un precio accesible, ¡casi está para reemplazar la PC entera!

Mi setup moderno, Yoga 720 a la izquierda, ella abajo a la derecha, teclado Bluetooth al centro

Nunca lo hubiera logrado de no ser porque encontré dos librerías para ESP-32 que la comunidad ya había pre-cocinado, o al menos hubiera tardado muchísimo más que la semana y media que me llevó. La primera es PS2dev, que maneja toda la interfaz PS/2 y emula ser un teclado. PS2dev estaba muy verde, poco desarrollada, solo encontré un usuario que la había usado exitosamente en un sistema no-PC-compatible y un montón más que se quejaban de que no servía para nada. Entonces empecé a debugearla y me encontré con que el problema estaba en el tiempo.

PS/2 (o PC-AT si nos remontamos a sus orígenes), es un protocolo serial bidireccional, donde la PC (el host) y el teclado periférico se turnan para comunicarse por un único cable de datos, regidos por una señal de reloj. El teclado envía las teclas presionadas y las ya no presionadas como códigos de uno o dos bytes de largo llamados make codes y break codes, correspondientes a una tabla que los asignaba a cada símbolo y letra a la que IBM llamó Scan Codes. Normalmente el teclado envía estos códigos y no pasa más nada, la computadora recibe el mensaje y actúa como esperamos. Pero hay ciertas ocasiones donde la comunicación hace uso de su carácter bidireccional, es decir que el host se comunica con el teclado, por ejemplo para solicitarle información, apagar o prender sus LEDs, etc. Para esto la computadora envía mensajes, llamados Mensajes de Comandos PS/2, y espera para cada uno al menos una respuesta de confirmación proveniente del teclado, llamada ACK (por acknowledge o “confirmación” en inglés). Entonces si queremos emular un teclado real tenemos que responder en tiempo y forma a estos mensajes de comandos. PS2dev lo hacía, pero resulta que las BIOS (sistema básico que controla el arranque e IO de una PC compatible) suelen ser muy exquisitas con sus tiempos y encontré varios sistemas donde la actuación de PS2dev no podía superar el encendido de la máquina, haciendo que la BIOS ignorara totalmente a nuestro “teclado”. En una Toshiba 205CDS respondía muy rápido a la pregunta “¿sos un mouse o un teclado?” ocasionando que la BIOS no recibiera el mensaje y configurara el periférico por defecto a un mouse, porque su puerto PS/2 es combinado. En mi 486 respondía muy rápido al mensaje “¡prendé tu LED de Num Lock!”, la BIOS no lo recibía y terminaba ignorando el teclado, asumiendo que estaba funcionando mal. Solo solucioné todos estos errores agregando los delays específicos en el preciso momento que eran necesarios, antes y después de cada ACK. ¡Y estoy hablando de microsegundos!

Con PS2dev finalmente funcionando nos quedaba la otra mitad; la comunicación Bluetooth. Mi teclado es BLE o Bluetooth Low Energy, un nuevo protocolo mucho más eficiente que hoy en día coexiste con el ultra-archi-conocido Bluetooth Classic. Otra librería me dió el dominio para esta interfaz, bt_keyboard, hecha por un usuario de la comunidad que usó el ejemplo publicado por el  mismísima fabricande del ESP32, EspressIF, usando su API para Bluetooth HID recién salida del horno.

Bt_keyboard funcionaba, reconocía mi teclado, se conectaba, ¡recibía los códigos! No podía ser mejor, pero pasaba algo. Al igual que PS2dev, estaba muy verde y EspressIF no se había molestado en incluir entre sus rutinas todas las que se encargaban de reconectar el teclado una vez que había sido emparejado, entonces había que reiniciar y emparejar el teclado con cada encendido. Fue así como investigué sobre BLE y como el ESP32 guarda en su memoria flash las claves permanentes que nos permiten reconectar a un dispositivo previamente emparejado, hice las rutinas que escanean y detectan la presencia del teclado y nos salvan de tener que emparejarlo de nuevo. Ahora sí, ¡practicidad al fin!

Mi 486 luciendo el prototipo del adaptador

Solo un pasito más. Los teclados Bluetooth transmiten códigos para cada tecla, como los que creó IBM para su PC en los 80. Decime que son los mismos. No, ¡claro que no!, no puede ser tan fácil. Los códigos que transmiten los teclados modernos, sea por Bluetooth o algo más conocido como USB, son precisamente códigos HID creados por el consorcio USB. Y no son uno para presionadas (make) y otro para liberadas (break), sino sólo uno que está presente (o no) dependiendo si la tecla está apretada (o no), que se comunica en un paquete de datos cada vez que hay algún cambio en las teclas. Así que el reto estuvo en hacer rutinas que detecten la presencia o no de la tecla en base a los códigos HID, traduzcan esto al respectivo código make o break, y finalmente lo envíen mediante PS2dev al la computadora host.

El último detalle lo tuvo una característica que quizás es la más interesante en lo que refiere a la interfaz PS/2; el llamado comportamiento Typematic o “tipomático”. Si lo traducimos literalmente, una combinación de la palabra “tipo” y “automático”. Por si no te diste cuenta, te lo explico, “tipo”es el nombre que se le da a una letra o símbolo, así que estamos haciendo referencia a: aaaaaaaaaaaaaaaa. Si, a cuando se repiten las letras automáticamente si mantenés apretada una tecla, a eso. Acordate cada vez que lo uses, “miren, ¡estoy tipomatiqueandooooooo!”. USB HID no provee un mecanismo explícito para detectar si una tecla está mantenida apretada y actuar al respecto, hoy en día es la computadora quien lleva el registro de que la última tecla no se soltó y empieza a repetirla internamente para lo que sea que estemos haciendo. En los viejos teclados PS/2 era el mismo teclado el que entraba en modo Typematic después de cierto tiempo de mantener apretada la tecla, usualmente unos 500 milisegundos, para luego enviar una y otra vez el mismo código make de la última tecla presionada, usualmente unas 20 veces por segundo. Esa fue la última cosa que le faltaba a mi proyecto.

Una vez emulado PS/2, solucionados los problemas de conexión de Bluetooh, traducidos los mensajes USB HID a los Scan Codes de IBM, y emulado el comportamiento Typematic, mi proyecto estaba terminado al fin. Un simple cable a ficha DIN-5 o Mini DIN-6 permite conectarlo al sistema, y le pedí a un amigo que me haga una cajita en 3D para protegerlo.

Primera unidad para betatesters, en este caso con conector Mini-DIN

¿Funciona? Si, y muy bien. Pueden encontrar el código fuente en mi sitio de GitHub. De hecho todo este post lo escribí con ella, mi 486, pero no le digas que con un teclado Bluetooth, ¡porque no se dio cuenta y piensa que es PS/2! Ahora si, disfrutar del Indi 500 a simplemente dos botones, y un switch de distancia.

BASIC – 8 – Animaciones (3)

Con todo lo aprendido en los post anteriores vamos a realizar una pequeña animación. Para ello definiremos 2 sprites, que serán los frames del famosisimo Space Invaders:

El programa que estoy utilizando aquí es C64 Studio, un IDE de programación que entre otras cosas trae un sencillo editor de sprites que me permite exportar los DATA a lineas de BASIC, y lo pueden descargar desde aquí: https://www.georg-rottensteiner.de/en/index.html

Luego cargaremos estos valores a partir de la memoria 12288, que corresponden a los punteros 192 y 193. Para hacer una animación solamente tenemos que implementar un loop FOR, y alternamos estos valores en cada iteración.
La parte interesante que la podemos ver a continuación:

100 for sx = 24 to 255
110 poke v,sx
120 poke 2040,192 + ((sx and 8) / 8)
130 next 

El loop se encuentra entre las lineas 100-130, en la linea 110 se va actualizando la posición y en la linea 120 se especifica que frame mostrar segun esa posición.
El truco aquí esta en “+ ((sx and 8) / 8)”: este código toma el valor 1 o 0 segun el estado del bit 3 en la variable sx.
De esta forma las primeras 8 posiciones tomaran el valor 0, lo que hará que el puntero quede seteado en la posición 192, en las siguientes 8 posiciones quedará en 1, por lo que el puntero sera 193, en las siguientes 8 volverá a 0 … y así indefinidamente.
Si quisiéramos que la animacion se reproduzca mas rápido podemos checkear el estado de los bits de menor peso y si queremos que se reproduzca mas lento chequeamos los bits de mayor peso.
Aqui podemos ver como se ve nuestro alien animado:

y el listado completo a continuación:

10 v=53248 
20 poke v+21,1
30 poke 2040,192
40 for t=12288 to 12414
50 read n
60 poke t,n
70 next
80 poke v+39,1
90 poke v+1,75

100 for sx = 24 to 255
110 poke v,sx
120 poke 2040,192 + ((sx and 8) / 8)
130 next 

150 for sx = 255 to 24 step -1
160 poke v,sx
170 poke 2040,192 + ((sx and 8) / 8)
180 next 

200 goto 100

1000 data 14,7,0,14,7,0,3,12
1010 data 0,3,12,0,15,255,0,15
1020 data 255,0,60,243,192,60,243,192
1030 data 255,255,240,255,255,240,207,255
1040 data 48,207,255,48,204,3,48,204
1050 data 3,48,7,158,0,7,158,0
1060 data 0,0,0,0,0,0,0,0
1070 data 0,0,0,0,0,0,0,1
1080 data 14,7,0,14,7,0,195,12
1090 data 48,195,12,48,207,255,48,207
1100 data 255,48,252,243,240,252,243,240
1110 data 255,255,240,255,255,240,63,255
1120 data 192,63,255,192,28,3,128,28
1130 data 3,128,48,0,192,48,0,192
1140 data 0,0,0,0,0,0,0,0
1150 data 0,0,0,0,0,0,0,1

Y esto es todo por hoy, nos vemos en la próxima entrega!

BASIC – 7 – Sprites (2)

En el post anterior vimos como activar un sprite, como seleccionar el area de memoria que dara la forma a nuestro sprite, y lo posicionamos en la pantalla.
Hoy vamos a darle la forma definitiva, para ello tenemos 2 vias:

  1. Usar un editor de sprites, que nos genere los numeros necesarios
  2. Hacerlo a mano

Hoy vamos a optar por la segunda opción, mas que nada para aprender como se hacía a la antigüa usanza, despues podremos utilizar multitud de programas que nos permiten dibujar comodamente y exportar los datos al formato que deseemos

Los sprites en la C64 poseen un tamaño de 24 x 21 pixels, lo que nos da 3 bytes (24px) por 21 = 63 bytes.
Para definir un sprite “a la antigüa” dibujaremos una cuadricula de 24×21, agrupando en columnas de 8 pixels. Luego pintaremos las casillas con los puntos que componen nuestro gráfico, para finalmente convertir cada grupo de 8 pixels en un byte.
Por ejemplo, aqui tenemos un circulo solido relleno:

Cada grupo de 8 bits los convertimos primero a binario, y luego a decimal (podemos utilizar la calculadora de windows, seteandola en modo programador), de forma que el primer byte es 00000000, que en decimal es “0”, el segundo 01111110 es “126” en decimal, y asi con el resto.
A continuación tenemos el programa completo, con los 63 bytes que definen nuestra “pelota”.

10 v=53248
20 pokev+21,1: rem activamos sprite numero 1
30 poke2040,192: rem direccion de inicio 12288
40 fort=12288to12350 : rem leemos los 63 valores
45 read n
50 poke t,n
60 next
70 pokev+39,1: rem elegimos color blanco
80 pokev,100: rem posicion horizontal 100
90 pokev+1,110: rem posicion vertical 110
100 data 0, 126, 0
110 data 3,255,192
120 data 7,255,224
130 data 31,255,248
140 data 31,255,248
150 data 63,255,252
160 data 127,255,254
170 data 127,255,254
180 data 255,255,255
190 data 255,255,255
210 data 255,255,255
220 data 255,255,255
230 data 255,255,255
240 data 127,255,254
250 data 127,255,254
260 data 63,255,252
270 data 31,255,248
280 data 31,255,248
290 data 7,255,224
300 data 3,255,192
310 data 0, 126, 0

Ademas de poder posicionar nuestro sprite en cualquier parte de la pantalla, tambien podemos elegirle un color, expandirlo al doble a lo ancho, o alto, o ambos.
Para darle un color utilizaremo el registro 39 (v + 39 seria) y un número entre 0 y 15 para especificar que color queremos asignarle

Para expandir a lo ancho tenemos el registro 29, y para expandir a lo alto el registro 23. Cada uno de estos registros son de 8 bits, y cada bit se corresponde con el sprite que queremos expandir, así que por ejemplo, si queremos expandir el sprite 1 a lo ancho deberiamos tipear POKE V+29,1
y si queremos expandir el sprite 8 a lo alto lo hacemos con POKE V+23,128
Aqui podemos ver como jugamos un poco con estos registros:
Y con esto tenemos suficiente por hoy. Nos vemos en el proximo capitulo!

BASIC – 6 – SPRITES (1)

Los sprites en la C64 son objetos que podemos definir como nosotros deseemos, y que se pueden posicionar en cualquier parte de la pantalla. Al ser manejados por hardware no tenemos que preocuparnos por preservar el fondo de pantalla, ni mover bytes, pintarlos ni nada que en otras computadoras es tarea corriente.
La C64 puede manejar hasta 8 sprites, y cada uno de ellos se les puede asignar un color independiente, expandirlos en el eje X o Y, posicionarlos en cualquier parte de la pantalla, y un monton de cosas mas.
Cada sprite tiene un tamaño de 24×21 pixels, y ocupa 63 bytes en memoria

En este pequeño ejemplo vamos a definir un sprite cuadrado (todo con el valor 255, que en binario es 11111111), y vamos a ver como lo podemos mover, expandir y cambiar el color.
Primero vamos a ingresar este programa en la c64, con el que vamos a poder ejemplificar varios conceptos 😀

10 v=53248 
20 poke v+21,1
30 poke 2040,16
40 for t=1024 to 1087
50 poke t,255
60 next
70 poke v,100
80 poke v+1,110

En la primera linea seteamos la variable v con el valor 53248. Este valor corresponde al primer registro de los 46 que posee el chip de video de la C64 (el VIC2). De esta manera solamente tenemos que recordar una posición de memoria, y ciertos registros claves.
El primer registro aparece en la linea 20, el número 21, y corresponde al numero de sprite activo, en este caso el número 1. Luego aparece una dirección de memoria (2040) con el que podemos especificar que segmento de la memoria del VIC2 queremos utilizar para definir la forma de nuestro sprite.

NOTA acerca del direccionamiento de memoria del VIC2:
Si bien el 6510 (el microprocesador de la C64) puede direccionar hasta 64kb de memoria, el VIC2 solo puede direccionar 16kb. Por razones que escapan a esta introducción, el VIC2 se puede configurar para que utilize cualquiera de los 4 bancos de 16Kb, y por defecto cuando encendemos la C64 esta configurado para trabajar en el banco 0 (el bloque de memoria que va de 0 a 16384)

En la dirección de memoria 2040, entonces, podemos especificar el lugar donde se almacenarán los valores que daran forma a nuestro Sprite, en segmentos de 64 bytes. Para nuestro ejemplo utilizamos el valor 16, que multiplicado por 64 nos da … 1024… mhmmm..
Eso lo vimos en un post anterior, en el que imprimíamos en pantalla utilizando POKEs directamente en la dirección de video del VIC2.
La idea de utilizar la memoria de video es mostrar como se va llenando la memoria con los valores que necesita el sprite (lineas 40 – 60), y como podemos modificarlos y ver como se reflejan esas modificaciones en la figura del sprite. Por supuesto que en un juego real no vamos a utilizar esa direccion, porque donde borramos la pantalla o actualizamos cualquier valor se nos rompe el sprite.
Finalmente en las lineas 70 y 80 posicionamos el sprite en pantalla.
Si ejecutamos el programa obtendremos el siguiente resultado (observen como se modifica el sprite cuando altero las 2 primeras lineas de texto en pantalla)

Observese tambien que se ve un puntito que representa el cursor.
En la siguiente entrega ya vamos a darle una forma mejor, y vamos a mostrar el uso de los diferentes registros.

BASIC – 5 – Leer el joystick para mover objetos

En el post anterior vimos como mover un caracter por la pantalla, pero habia algunas limitaciones, como por ejemplo que no podiamos realizar diagonales, y que cada vez que queríamos avanzar debíamos pulsar repetidamente las teclas.

Hoy vamos a hacer el mismo programa, pero controlando la pelota con el joystick conectado en el port 2, pero primero… un poco de teoria.

Para leer las posiciones del joystick tenemos las posiciones de memoria 56321 (port 1) y 56320 (port 2).
los bits 0,1,2,3 corresponden a las direcciones (arriba, abajo, izquierda, derecha) y el bit 4 corresponde al boton de disparo.
Estando el joystick en posicion central, sin pulsar disparo estas direcciones nos devuelven el valor 127, que corresponde a %01111111, y a medida que vamos moviendo el joystick y pulsando el disparo se ponen en 0 los bits correspondientes.
Podemos ver rapidamente como se comportan los valores con un sencillo programita de 3 lineas

20 j=peek(56320)
30 print j
40 goto 20

Copia este programa y cuando lo ejecutes comenzara a imprimir el valor 127. Conecta un joystick al port 2 y veras como varia este valor segun las direcciones que muevas.

Vamos ahora si con el programa de la bola modificado para joystick

10 x = 10: y = 10
20 poke 1024 + (40 * y)+ x, 81
30 j = not(peek(56320)) and 127
40 if j = 0 then 30
50 poke 1024 + (40 * y)+ x, 32
60 dx = -((j and 4) / 4) + ((j and 8) / 8)
70 dy = -(j and 1) + ((j and 2) / 2)
80 x = x + dx: y = y + dy
90 poke 1024 + (40 * y)+ x, 81
100 goto 30

Como es usual, primero definimos en la linea 10 la posicion inicial en pantalla, y a continuacion imprimimos la bola. A continuacion leemos el valor del port 2 y, para poder hacer unas operaciones despues, vamos a invertir los bits, y poner el bit 7 en 0 (con esto lo que logramos es que cuando pulsemos el bit se ponga en 1, en vez de 0)

Las otras lineas interesantes son la 60 / 70, que obtienen el valor dx / dy haciendo unos calculos. La ventaja de hacerlo de esta manera sobre el tradicional chequeo de IFs es que ocupa menos lugar (importantisimo) y que ya nos resuelve la deteccion de diagonales (con estas 2 lineas evitamos 8 lineas de IFs)

En la linea 80 actualizamos las posiciones, luego imprimimos la bola, y vuelta a chequear el valor del port 2.
A continuacion podemos ver la diferencia con el programa anterior

El proximo post vamos a comenzar a utilizar sprites. Hasta la próxima!

BASIC – 4 – Leer el teclado para mover cosas

El BASIC de la C64 nos provee 2 instrucciones para ingresar información desde el teclado:

  1. INPUT : Para casos en los que queremos ingresar un nombre o un valor numérico
  2. GET : para cuando necesitamos detectar solo la pulsación de una tecla

Para lo que queremos hacer ahora vamos a utilizar el comando GET. El modo de uso es muy simple, solo toma como parámetro la variable en la que queremos que coloque el valor de la tecla pulsada.
Con este pequeño ejemplo vemos como funciona:

10 get a$
20 print a$;
30 goto 10

Si ejecutamos aparentemente no realiza nada, pero si pulsamos una tecla aparecera su correspondiente letra en la pantalla. Lo que esta haciendo aqui es un loop infinito en el que lee el valor de la tecla pulsada, lo imprime, y vuelve a leer, asi indefinidamente.
Con todo esto podemos hacer nuestro programita en el que controlamos una bola

10 px% = 10: py% = 10
20 a$ = ""
30 get a$ : if a$="" then 100
40 poke 1024+(py%*40)+px%,32
50 if a$="d" then px%=px%+1
60 if a$="a" then px%=px%-1
70 if a$="s" then py%=py%+1
80 if a$="w" then py%=py%-1
90 poke 1024+(py%*40)+px%,81
100 goto 30

Nuevamente definimos nuestras variables de posición, luego leemos el valor de la tecla pulsada, y si no se detecto ninguna salteamos la parte de código que mueve nuestro personaje.
Esto tal vez no tenga demasiado sentido en este ejemplo, pero en juegos mas complejos esta bueno que si no se pulsa ninguna tecla se puedan hacer otras cosas (no tiene sentido volver a imprimir el personaje en la misma posición)

En las siguientes lineas borramos la bola de la posición anterior (el caracter 32 es el Espacio), comprobamos si se pulsó alguna de las teclas W, A, S, D, e imprimimos la bola en la posición actualizada.
NOTA: se podria optimizar mucho más este ejemplo, pero a efectos didácticos vamos a mantenerlo simple.

Y así es como queda:

Agregando una cola que vaya guardando las posiciones anteriores podemos implementar un juego tipo Nibbles, o cualquier cosa que necesitemos mover por la pantalla

BASIC – 3 – Imprimiendo En Pantalla (2)

Vimos en el post anterior que tenemos 2 formas de imprimir en pantalla: con el comando PRINT tradicional o directamente cargando valores en la memoria de video.

La memoria de video de la C64 se compone (simplificando mucho, para lo que queremos explicar) de una matriz de 40 columnas por 25 filas de caracteres, lo que nos da un total de 1000 caracteres. En cualquiera de estas posiciones podemos imprimir lo que deseemos, simplemente colocando el valor correcto.

La posición de memoria 1024 es el inicio de nuestra memoria de video. En ella se encuentra el caracter que corresponde a la esquina superior izquierda de la pantalla, y a medida que vamos incrementando esta posición los caracteres van llenando la pantalla.


Para muestra, vale este pequeño ejemplo:

10 for x = 0 to 1000
20 poke 1024 + x, 81
30 next

Aqui podemos ver como se va llenando la pantalla, de izquierda a derecha, las 1000 posiciones de la misma.


¿Y si queremos posicionar algo? Es muy sencillo, simplemente con esta formula:

m = 1024 + (40 * py) + px

Donde m es la posición de memoria, px es la columna y py es la fila donde queremos posicionar nuestro gráfico. Con toda esta información podemos escribir un pequeño programita que nos dibuja una pelota rebotando por la pantalla:

10 px% = 10: py% = 10: dx% = 1: dy% = 1
20 poke 1024+(py%*40)+px%,32
30 px% = px% + dx%
40 py% = py% + dy%
50 if px%=39 then dx% = -dx%
60 if px%=0 then dx% = -dx%
70 if py%=24 then dy% = -dy%
80 if py%=0 then dy% = -dy%
90 poke 1024+(py%*40)+px%,81
100 goto 20

px y py son la posición de la pelota; dx y dy su dirección.


Inmediatamente pintamos un espacio, porque si no lo hacemos la pelota nos dejará una estela de pelotas, luego incrementamos la posicion según la dirección en la que está yendo, hacemos las comprobaciones para que no salga de la pantalla, y finalmente imprimimos la pelota… y reinicia el ciclo.

Y el resultado es el siguiente… bueno, mas o menos, la captura de pantallas esta hecha a 15 cuadros (frames) por segundo, lo que hace que la pelota desaparezca un poco.

Partiendo de este código se puede realizar un clon de breakout o similar

En el próximo post vamos a ver como leer el teclado, ycontrolar con WASD nuestra bola