El período comprendido entre la aparición de Space Invaders (1978) y el gran colapso de los videojuegos (1983) se conoce a menudo como la Edad de Oro del gaming. Veamos qué pasó durante esos gloriosos años.
Un recorrido por la edad dorada del gaming
6502 vs 6510 Episodio 11 – El Stack o Pila
Continuamos este estudio comparativo del 6502 vs el 6510 esta vez estudiando que es el Stack o Pila.
Vamos a estudiar en dónde se encuentra, que instrucciones lo usan, qué tamaño tiene y cuál es la mejor forma de crear un programa para poder aprovecharlo,
Qué es el Stack
El stack es una porción de la memoria que se utiliza para el almacenamiento de datos temporales. Tiene la característica de ser de organización LIFO (last in first out) lo que significa que el último dato que guardamos en el stack es el primero que va a salir de éste. En este ejemplo vemos que aunque el valor A es el primero que entra en el stack, el mismo es el último que sale luego del valor B.
El stack se encuentra ubicado en la página uno de la memoria con lo que sus direcciones comienzan siempre con $01 y tiene 256 bytes de tamaño, en consecuencia sus direcciones de memoria van desde $01FF a $0100.
Para saber en que aparte del stack nos encontramos tenemos una variable llamada Stack Pointer o SP y que siempre va a indicar la próxima posición vacía del stack. El stack pointer siempre es inicializado en $FF y el $01 de su high byte está harcodeado dentro del 6502 y el 6510.
Algo muy importante a tener en cuenta con el stack es que sólo tenemos 256 posiciones de memoria y que el mismo es circular cuando llenamos la dirección $0100 la próxima es $01FF y si teníamos información útil aquí la misma es sobreescrita perdiéndola, por lo tanto, es muy importante limitar la cantidad de saltos anidados a subrutinas e información que copiamos al stack. A continuación veremos cuantas posiciones de memoria del stack cada instrucción utiliza.
El stack es muy útil en aquellos programas que no trabajan con direcciones de memoria conocidas pero sí con un orden conocido para acceder a la memoria (quien accede primero y quien después). Este tipo de código llamado reentrante se utiliza mucho para poder atender a las interrupciones.
El uso del stack pointer siempre comienza con su inicialización en $01FF.
Registros del Procesador
El Procesador posee algunos registros internos de los cuáles forma parte el stack pointer (recordemos que el stack en sí mismo no es un registro sino un 256 bytes en memoria) y que siempre conviene tenerlos en cuenta.
El acumulador o registro A es un registro de 8 bits que nos va a dejar almacenar valores y realizar operaciones matemáticas en los mismos ya que está conectado tanto a la ALU (unidad aritmético lógica) como a al bus de datos.
Los registros X e Y son registros de 8 bits que nos van a dejar almacenar valores y utilizarlos como índices en distintas operaciones de acceso a memoria.
El Program Counter o PC, es un registro de 16 bits que almacena la dirección de memoria en la cual vamos a ejecutar la próxima instrucción, se divide en sus 8 bits high o PCH y sus 8 bits low o PCL ya que la memoria es de 8 bits en su contenido y para poder “llenarlo” debemos acceder dos veces a ella.
El stack pointer con 8 bits en su dirección de memoria low y 8 bits grabados como $01 en su parte High el cúal como vimos indica la posición dentro del stack.
El Processor Status Register o P contiene 8 bits de los cuáles se usan 7
- C/Carry (Bit 0): Es el noveno bit en las operaciones aritméticas y entre muchos usos refleja el “me llevo uno” de la suma. El valor 1 indica True.
- Z/Zero (Bit 1): Puesto automáticamente en 1 por el procesador cuando todos los 8 bits de una operación dan como resultado 0 en el registro del acumulador.
- I/Interrupt Disable (Bit 2): Cuando este bit está en 1 el procesador no acepta interrupciones en su pin IRQ o durante el comando BRK.
- D/Decimal Mode (Bit 3): Al tener este Flag en 1 el procesador trabaja con aritmética decimal en lugar de aritmética binaria el número 14 en aritmética decimal se representa como 0001 0100 (14) y en aritmética binaria cómo (0000 1110) (0E).
- B/Break Command(Bit 4): Este bit lo pone en 1 el procesador cuando una interrupción es causada por el comando break, si fuera causada por una interrupción real este bit estaría en 0.
- Expansion (Bit 5): Reservado para uso en futuras expansiones del procesador. (Nota del Narrador: “y al final nunca se usó”).
- V/Overflow (Bit 6): Cuando usamos aritmética con signos negativos y positivos sólo tenemos 7 bits disponibles ya que el octavo se utiliza para el signo (0 positivo y 1 negativo). Este bit indica cuando nos “llevamos uno” en una operación aritmética. También se utiliza para reflejar el valor del bit 6 cuando se ejecuta la instrucción bit. Este flag pasa a valor 1 cuando se recibe una transición de High a Low en el pin de SOB (Set Overflow) del procesador.
- N/Negative Result (Bit7): Se utiliza en aritmética que respeta el signo (cuando usamos números desde el +127 a -128). Este flag siempre va a mostrar el bit 7 del último resultado de todas las operaciones matemáticas que realizamos.
Instrucciones y el Stack
Las instrucciones que usamos en el Stack ocupan utilizan un número fijo de bytes siendo 3 para las interrupciones, 2 bytes para las subrutinas y 1 byte para los datos guardados por el usuario.
El stack comienza en $01FF y se decrementa. Esta nomenclatura que parece rara se creó porque existían implementaciones donde se usaba una sóla página de memoria (el stack era $00FF ubicado en la zero page) entonces los usuarios utilizan espacio para programas y variables comenzando desde la dirección $0000 e incrementando el program counter y el stack decrementa desde $00FF. ¡Con suerte nunca se juntaban en el medio!
Instrucciones que lo usan directamente
Hay 4 instrucciones que utilizamos para enviar y retirar información al stack. PHA, PLA, PHP, PLP
PHA
El stack sólo puede comunicarse con el Accumulador para recibir datos que nosotros queramos guardar en él, la instrucción para guardar datos por excelencia es Push Accumulator to Stack o PHA. Esta instrucción realiza los siguientes pasos:
- Tomar el Opcode de la operación, Incrementar el Program Counter.
- Leer el byte de la próxima instrucción y descartarla.
- Guardar el byte que se encuentra en el acumulador en la posición de memoria $0100+SP, decrementar SP.
Esto graba en memoria (en la sección del stack) lo que teníamos en el acumulador
PLA
Para poder tomar los datos que teníamos en el stack y volver a traerlos a memoria tenemos la instrucción Pull from Accumulator PLA
- Tomar el Opcode de la operación, Incrementar el Program Counter.
- Leer el byte de la próxima instrucción y descartarla.
- Incrementar el stack pointer SP.
- Guardar el byte que se encuentra la posición de memoria $0100+SP y guardarlo en el Acumulador.
Hay que destacar que el sacar datos del Stack no borra los datos que tenemos en el mismo, sino que sólo desplaza el stack pointer, podríamos si quisiéramos seguir accediendo a estos datos con una instrucción de load desde la dirección $01FF, LDA $01FF.
Processor Status Register
Existe otro byte muy útil de analizar qué es el que mantiene el status de todo el procesador, este byte se denomina Processor Status Register y contiene varios bits útiles como ya hemos visto que representan el estado del procesador.
Si vamos a realizar algunos cambios o realizar operaciones que puedan modificar estos bits y no queremos perder los bits originales tenemos la operación PHP y su contraparte para recuperar los datos PLP.
PHP
Para guardar los bits del PSR la instrucción por excelencia es Push PSR to Stack o PHP. Esta instrucción realiza los siguientes pasos:
- Tomar el Opcode de la operación, Incrementar el Program Counter.
- Leer el byte de la próxima instrucción y descartarla.
- Guardar el byte que se encuentra en el Processor Status Register en la posición de memoria $0100+SP, decrementar SP.
Esto graba en memoria (en la sección del stack) lo que teníamos en el acumulador.
PLP
Para poder tomar los datos que teníamos en el stack y volver a traerlos a memoria tenemos la instrucción Pull from Processor Status Register PLP
- Tomar el Opcode de la operación, Incrementar el Program Counter.
- Leer el byte de la próxima instrucción y descartarla.
- Incrementar el stack pointer SP.
- Leer el byte que se encuentra en la posición de memoria $0100+SP y guardarlo en el Processor Status Register.
Instrucciones que lo usan indirectamente
Hay 4 instrucciones que usan el stack para almacenar datos sin que nosotros decidamos qué datos son, JSR, RTS y BRK, RTI.
Cada vez que hacemos un salto hacia una subrutina JSR deberemos saber de alguna forma a dónde volver luego de ver el comando de fin de la subrutina RTS. Para saberlo utilizamos el stack donde almacenaremos el byte high y low de la dirección de la próxima instrucción luego del salto. También en forma parecida van a funcionar BRK que indica salto a una interrupción y RTI que es el regreso desde la misma.
JSR
La instrucción JSR o Jump to Subroutine utiliza el stack para guardar información de retorno a la ejecución del programa actual una vez esta subrutina haya finalizada, veamos los pasos que realiza:
- Tomar el Opcode de la operación, Incrementar el Program Counter.
- Leer el low address byte de la dirección de salto, Incrementar el Program Counter (queda listo para la próxima instrucción).
- Operación interna Guardar el Address Low en ADL.
- Enviar el byte alto PCH del program counter al Stack en la posición de memoria $0100+SP, decrementar SP, mantener el Address LOW en ADL.
- Enviar el byte bajo PCL del último byte de la posición de memoria de la instrucción JSR, generalmente es donde se encontraba el byte High de la dirección de la subrutina, al Stack en la posición de memoria $0100+SP, decrementar SP, mantener el Address LOW en ADL.
- Buscar el high byte del address al cual saltar ADH, grabar el stack pointer.
- Copiar el byte the low address de la dirección de salto ADL al Program Counter Low (PCL), tomar el ADH y guardarlo en el Program Counter High (PCH).
RTS
La instrucción RTS nos devuelve desde una subrutina hasta la próxima instrucción a ejecutar después de la llamada a la misma en donde estuvimos ejecutando código. Sus pasos de ejecución son los siguientes:
- Leer Opcode, incrementar el program counter.
- Leer el próximo byte y descartarlo, incrementar program counter.
- Incrementar el stack pointer.
- Traer byte desde el stack y grabarlo en PCL, incrementar stack pointer.
- Traer byte desde el stack y grabarlo en PCH.
- Incrementar program counter.
BRK
El comando BRK simula la ejecución de una subrutina, algo muy importante a tener en cuenta es que él mismo nos va a dar como dirección de regreso Program Counter + 2 con lo que tenemos que tener un cuenta poner un byte que se pueda descartar después del break como ser por ejemplo un NOP, o nuestro programa no va a funcionar ya que volverá a un dirección incorrecta. También podemos utilizar ese byte extra para poder almacenar un código de por qué sucedió el break.
Esta instrucción tarda 7 ciclos antes de comenzar a ejecutar el programa que va a atender la interrupción (handler), y sus pasos de ejecución son los siguientes:
- Leer Opcode, incrementar rl program counter.
- Leer el próximo byte y descartarlo, incrementar program counter.
- Grabar PCH en el stack, setear el flag B, decrementar stack pointer.
- Grabar PCL en el stack, decrementar stack pointer.
- Grabar processor status register en el stack, decrementar stack pointer.
- Leer nuevo PCL desde $FFFE.
- Leer nuevo PCH desde $FFFF.
RTI
La instrucción RTI nos regresa desde dentro del programa que usamos como handler de la interrupción y reversa alguno de los pasos de la llamada a interrupción original. Estos son sus pasos:
- Leer Opcode, incrementar el program counter.
- Leer el próximo byte y descartarlo, incrementar program counter.
- Incrementar el stack pointer.
- Traer byte desde el stack y grabarlo en el processor status register, incrementar stack pointer.
- Traer byte desde el stack y grabarlo en PCL, incrementar stack pointer.
- Traer byte desde el stack y grabarlo en PCH, incrementar stack pointer.
Un programa que usa el stack
El siguiente programa en código máquina usa el stack a través de 8 instrucciones PHA, PLA, PHP, PLP, JRS, RTS, BRK y RTI. Fue ejecutado en un procesador 6510 original creado en la semana 13 del año 1986.
Si ponemos un analizador de protocolo a ver los resultados de estos comandos podemos observar los siguientes resultados, el formato de los mismos sera:
10 0 Descartar no lo vamos a utilizar en el análisis
1000000000000000 Address Bus en Binario
10100010 Data Bus en Binario
8000 Address Bus en Hexadecimal
r Operación de Lectura “r” o escritura “W”
a2 Data Bus en Hexadecimal
ldx Si es una instrucción, el correspondiente mnemónico de assembler si no es un dato o dirección de memoria y se lee literal.
Inicializar el Stack pointer en $01FF
Lo primero que pasa con este programa es que comenzamos en la dirección 8000, cargamos ff en el registro X y lo transmitimos al Stack, la última operación que aparece como a9 es un ciclo que gasta el procesador en guardar el valor FF en el registros interno del Stack Pointer.
PHA y PLA
En este segmento del programa vemos cómo almacenar dos valores desde el acumulador al stack y como traerlos.
Cargamos el valor 64 al acumulador.
10 0 1000000000000011 10101001 8003 r a9 lda
10 0 1000000000000100 01100100 8004 r 64
Lo transferimos al stack y el próximo ciclo de instrucción 8006 se pierde ya que es utilizado internamente
10 0 1000000000000101 01001000 8005 r 48 pha
10 0 1000000000000110 10101001 8006 r a9 lda
Escribimos el valor 64 en la dirección 01ff del stack en memoria, el stack pointer queda en 01fe
10 0 0000000111111111 01100100 01ff W 64
Cargamos el valor 99 al acumulador.
10 0 1000000000000110 10101001 8006 r a9 lda
10 0 1000000000000111 10011001 8007 r 99
Lo transferimos al stack y el próximo ciclo de instrucción 8009 se pierde ya que es utilizado internamente
10 0 1000000000001000 01001000 8008 r 48 pha
10 0 1000000000001001 01101000 8009 r 68 pla
Escribimos el valor 99 en la dirección 01fe del stack en memoria, el stack pointer queda en 01fd
10 0 0000000111111110 10011001 01fe W 99
Pedimos transferir un valor desde el stack (el 99) y la próxima instrucción 800a se descarta
10 0 1000000000001001 01101000 8009 r 68 pla
10 0 1000000000001010 01101000 800a r 68 pla
Se escribe la posición actual del stack pointer 01fd en el address bus y se descarta el dato y se incrementa el stack pointer.
10 0 0000000111111101 01110000 01fd r 70
Se lee la posición actual del stack pointer 01fe y se guarda el valor en el acumulador
10 0 0000000111111110 10011001 01fe r 99
Pedimos transferir un valor desde el stack (el 64) y la próxima instrucción 800b se descarta
10 0 1000000000001010 01101000 800a r 68 pla
10 0 1000000000001011 10101001 800b r a9 lda
Se lee de la posición actual del stack pointer 01fe y se descarta y se incrementa el stack pointer.
10 0 0000000111111110 10011001 01fe r 99
Se lee la posición actual del stack pointer 01ff y se guarda el valor en el acumulador
10 0 0000000111111111 01100100 01ff r 64
PHP y PLP
En este segmento del programa vemos cómo almacenar dos veces el Processor Status Register, la segunda vez lo cambiamos para que el flag de testeo Zero esté en 1 asignando previamente al acumulador un valor de 0. Para terminar el programa traemos desde el stack esos valores.
Cargamos el valor 64 al acumulador.
10 0 1000000000001011 10101001 800b r a9
10 0 1000000000001100 01100100 800c r 64
Pedimos transferir al stack el Processor Status Register y el próximo ciclo de instrucción 800e se pierde ya que es utilizado internamente
10 0 1000000000001101 00001000 800d r 08 php
10 0 1000000000001110 10101001 800e r a9
Escribimos el valor 3d en la dirección 01ff del stack en memoria, el stack pointer queda en 01fe
Este valor representa el número binario 0011 1101 usando los flags del procesador es
N=0,V=0,E=1,B=1,D=1,I=1,Z=0,C=1 Podemos ver que el flag Z está en cero ya que el resultado de la última operación es 64 distinto de cero.
10 0 0000000111111111 00111101 01ff W 3d
Cargamos el valor 0 al acumulador.
10 0 1000000000001110 10101001 800e r a9
10 0 1000000000001111 00000000 800f r 00
Pedimos transferir al stack el Processor Status Register y el próximo ciclo de instrucción 8011 se pierde ya que es utilizado internamente.
10 0 1000000000010000 00001000 8010 r 08 php
10 0 1000000000010001 00101000 8011 r 28
Escribimos el valor 3f en la dirección 01fe del stack en memoria, el stack pointer queda en 01fd
Este valor representa el número binario 0011 1111 usando los flags del procesador es
N=0,V=0,E=1,B=1,D=1,I=1,Z=1,C=1 Podemos ver que el flag Z está en uno ya que el resultado de la última operación es cero.
10 0 0000000111111110 00111111 01fe W 3f
Pedimos transferir un byte desde el stack (el 3f) al Processor Status register y la próxima instrucción 8012 se descarta.
10 0 1000000000010001 00101000 8011 r 28 php
10 0 1000000000010010 00101000 8012 r 28
Se lee de la posición actual del stack pointer 01fd y se descarta y se incrementa el stack pointer.
10 0 0000000111111101 01110000 01fd r 70
Se lee la posición actual del stack pointer 01fe y se guarda el valor en el Processor Status register
10 0 0000000111111110 00111111 01fe r 3f
Pedimos transferir un byte desde el stack (el 3f) al Processor Status Register y la próxima instrucción 8013 se descarta.
10 0 1000000000010010 00101000 8012 r 28 php
10 0 1000000000010011 00100000 8013 r 20
Se lee de la posición actual del stack pointer 01fe y se descarta y se incrementa el stack pointer.
10 0 0000000111111110 00111111 01fe r 3f
Se lee la posición actual del stack pointer 01ff y se guarda el valor en el Processor Status Register
10 0 0000000111111111 00111101 01ff r 3d
JSR y RTS
En este segmento del programa vemos cómo saltar hacia una subrutina., cómo se almacena la dirección de retorno y que pasos se dan en el programa para volver al mismo momento desde donde partió el llamado de la subrutina.
Comienza nuestro programa en la dirección $8013 con un JSR para saltar a la subrutina, pero en lugar de tener a continuación una dirección de memoria tenemos el byte 1c, este es el low address en el que comienza nuestra subrutina con un lda #$44 como podemos ver al hacer un dump en binario de nuestro código, seguido de este tenemos el byte 80, lo que apunta nuestra subrutina la dirección $801C ya que siempre las direcciones de memoria de JSR son absolutas.
Se lee el byte de la dirección del futuro Low address $1C, esto va a pasar a PCL en algunos ciclos más.
10 0 1000000000010011 00100000 8013 r 20 jsr
10 0 1000000000010100 00011100 8014 r 1c
Se lee de la posición actual del stack pointer 01ff y se descarta.
10 0 0000000111111111 00111101 01ff r 3d
Se escribe PCH, el High Byte del program counter en la posición actual del stack pointer 01ff y se decrementa el stack pointer que queda en 01fe.
10 0 0000000111111111 10000000 01ff W 80
Se escribe PCL, el Low Byte del program counter en la posición actual del stack pointer 01fe y se decrementa el stack pointer que queda en 01fd.
10 0 0000000111111110 00010101 01fe W 15
Se lee la instrucción en la posición de memoria del high byte de la subrutina y se copia al PCH para poder hacer el jump a 801C una vez actualizado el program counter.
10 0 1000000000010101 10000000 8015 r 80
Comienza la ejecución de nuestra subrutina cargando el valor 44 en el acumuladore
10 0 1000000000011100 10101001 801c r a9 lda
10 0 1000000000011101 01000100 801d r 44
Se carga la instrucción sta para grabar el acumulador en la posición de memoria 2003
10 0 1000000000011110 10001101 801e r 8d sta
10 0 1000000000011111 00000011 801f r 03
10 0 1000000000100000 00100000 8020 r 20
Se escribe la posición de memoria 2003
10 0 0010000000000011 01000100 2003 W 44
Se pide volver de la subrutina con la instrucción rts, se lee la próxima instrucción en la posición 8022 y se descarta.
10 0 1000000000100001 01100000 8021 r 60 rts
10 0 1000000000100010 10101001 8022 r a9
Se lee de la posición actual del stack pointer 01fd y se descarta y se incrementa el stack pointer.
10 0 0000000111111101 01110000 01fd r 70
Se lee de la posición actual del stack pointer 01fe el low byte del PCL a y se incrementa el stack pointer.
10 0 0000000111111110 00010101 01fe r 15
Se lee de la posición actual del stack pointer 01ff el high byte del PCH a y se incrementa el stack pointer.
10 0 0000000111111111 10000000 01ff r 80
El Program Counter queda en 8015 y se busca la próxima instrucción en esa dirección
10 0 1000000000010101 10000000 8015 r 80 brk
BRK y RTI
En este segmento del programa vemos cómo se ejecuta una interrupción brevemente, hablaremos más de interrupciones como suceden y para que se usan en un próximo capítulo.
Este programa causa una interrupción por software llamada break la cuál hace que el procesador vaya a las direcciones $FFFE y $FFFF para buscar los bytes que indican que programa comenzar a ejecutar, este en nuestro caso es el que comienza en la etiqueta irq:
El break nos va a dar como dirección de regreso Program Counter + 2 con lo que tenemos que tener un cuenta poner un byte que se pueda descartar después del break como ser por ejemplo un NOP o nuestro programa no va a funcionar ya que volverá a un dirección incorrecta. También podemos utilizar ese byte extra para poder almacenar un código de por qué sucedió el break.
Esta instrucción tarda 7 ciclos antes de comenzar a ejecutar el programa que va a atender la interrupción (handler). A continuación nuestro programa corregido (notar el NOP) y veremos todos nuestros address familiares corridos un byte.
Nuestro segmento de programa entonces comienza en $8018 con el comando BRK cuyo código es $00, lee a continuación el próximo byte y lo descar
10 0 1000000000011000 00000000 8018 r 00 brk
10 0 1000000000011001 11101010 8019 r ea NOP
Escribe en el stack en las posiciones 01ff a 01fe la posición a la cual regresar $801a, nótese que si no tuviéramos la instrucción NOP regresaremos un byte antes a nuestro programa y este NO FUNCIONARIA.
10 0 0000000111111111 10000000 01ff W 80
10 0 0000000111111110 00011010 01fe W 1a
Escribe en el stack el Processor Status Register
10 0 0000000111111101 00110110 01fd W 36
Lee el vector fffe y ffff (low y high byte) para saber dónde está el handler o programa que manejará la interrupción, en este caso en la posición 8023.
10 0 1111111111111110 00100011 fffe r 23
10 0 1111111111111111 10000000 ffff r 80
Con el program counter en 8023 correspondiente a la etiqueta irq: carga la primera instrucción para guardar el valor 55 en el acumulador.
10 0 1000000000100011 10101001 8023 r a9 lda
10 0 1000000000100100 01010101 8024 r 55
Lee una instrucción para guardar el valor del acumulador en la posición de memoria 2005
10 0 1000000000100101 10001101 8025 r 8d sta
10 0 1000000000100110 00000101 8026 r 05
10 0 1000000000100111 00100000 8027 r 20
Escribe en la posición de memoria 2005 el valor 55
10 0 0010000000000101 01010101 2005 W 55
Lee la instrucción rti para salir del handler de interrupciones.
10 0 1000000000101000 01000000 8028 r 40 rti
Ciclo Interno, Lee el próximo byte y lo descarta.
10 0 1000000000101001 00000000 8029 r 00
Se lee de la posición actual del stack pointer 01fc y se descarta y se incrementa el stack pointer.
10 0 0000000111111100 00101101 01fc r 2d
Se lee de la posición actual del stack pointer 01fd y se copia la información al Processor Status Register y se incrementa el stack pointer.
10 0 0000000111111101 00110110 01fd r 36
Se lee la posición actual del stack pointer 01fe y se copia la información al PCL y se incrementa el stack pointer.
10 0 0000000111111110 00011010 01fe r 1a
Se lee la posición actual del stack pointer 01fe y se copia la información al PCH y se incrementa el stack pointer.
10 0 0000000111111111 10000000 01ff r 80
Se resumen la ejecución del programa en un loop infinito que salta a la posición de memoria 8019 en forma recurrente,
10 0 1000000000011010 01001100 801a r 4c jmp
10 0 1000000000011011 00011010 801b r 1a
10 0 1000000000011100 10000000 801c r 80
10 0 1000000000011010 01001100 801a r 4c jmp
10 0 1000000000011011 00011010 801b r 1a
10 0 1000000000011100 10000000 801c r 80
10 0 1000000000011010 01001100 801a r 4c jmp
10 0 1000000000011011 00011010 801b r 1a
10 0 1000000000011100 10000000 801c r 80
Cómo se incrementa el Stack dentro del procesador 6510
Si queremos realmente profundizar y ver como el CPU decrementa el stack, podemos usar un proyecto como visual6502 que nos muestra como funcionan las señales internas del procesador.
Primero saber que para decrementar en realidad se realiza la suma al complemento por lo que si queremos restarle uno a FD es lo mismo que sumarle FF
FD -1 = FC
FD + FF = FC
Veamos algunas de las señales internas utilizadas.
- En el bus interno de Address Low ADL El Stack Pointer le carga su valor de $FD en nuestro ejemplo. mediante la señal S/ADL.
- Este valor $FD es cargado al registro B de la ALU mediante la señal ADL/ADD
- Se genera el valor $FF y se carga en el bus SB,
- Este valor $FF se carga del bus SB al bus registro A de la ALU mediante la señal SB/ADD.
- Finalmente con la señal SUMS se realiza la suma de ambos valores.
- El resultado de la alu queda en el bus SB mediante la señal ADD/SB(0-6) y ADD/SB(7) que cargan los primeros 7 bits y el último en el bus SB respectivamente.
- El stack pointer es cargado mediante la señal SB/S con lo que es actualizado con el valor decrementado
- Luego la señal S/ADL cargar el stack pointer en el registro Low interno y la señal ADL/ABL carga finalmente los 8 bits inferiores del address bus con el valor del Stack Pointer.
Más abajo que esto no podemos llegar adentro de un 6502 (Más profundo y llego a China)., para más información busquen el Diagrama de Hanson del interior del 6502 y el proyecto visual6502 ambos sitios incluidos en las referencias de este artículo.
Cómo funciona en el Commodore 64
El stack es utilizado en la Commodore 64 para todas estas instrucciones que vimos originalmente con exactamente las mismas funciones y parámetros. Todo el código que vimos en este artículo fue ejecutado en un MOS 6510 de la semana 13 de 1986.
El stack también comienza en la dirección $01FF y el valor del stack pointer es inicializado en la rutina de inicialización de la commodore:
.,FCE2 A2 FF LDX #$FF START LDX #$FF
.,FCE4 78 SEI SEI
.,FCE5 9A TXS TXS
.,FCE6 D8 CLD CLD
.,FCE7 20 02 FD JSR $FD02 JSR A0INT ;TEST FOR $A0 ROM IN
.,FCEA D0 03 BNE $FCEF BNE START1
.,FCEC 6C 00 80 JMP ($8000) JMP ($8000) ; GO INIT AS $A000 ROM WANTS
.,FCEF 8E 16 D0 STX $D016 START1 STX VICREG+22 ;SET UP REFRESH (.X=<5)
.,FCF2 20 A3 FD JSR $FDA3 JSR IOINIT ;GO INITILIZE I/O DEVICES
.,FCF5 20 50 FD JSR $FD50 JSR RAMTAS ;GO RAM TEST AND SET
.,FCF8 20 15 FD JSR $FD15 JSR RESTOR ;GO SET UP OS VECTORS
;
.,FCFB 20 5B FF JSR $FF5B JSR CINT ;GO INITILIZE SCREEN
.,FCFE 58 CLI CLI ;INTERRUPTS OKAY NOW
.,FCFF 6C 00 A0 JMP ($A000) JMP ($A000) ;GO TO BASIC SYSTEM
Esta rutina es llamada cada vez que se ejecuta un reset a través del vector del mismo nombre que está en las direcciones $FFFC, $FFFD
.:FFFA 43 FE .WOR NMI ;PROGRAM DEFINEABLE
.:FFFC E2 FC .WOR START ;INITIALIZATION CODE
.:FFFE 48 FF .WOR PULS ;INTERRUPT HANDLER
Estudio visual
Para poder estudiar visualmente cómo funciona el stack les dejo esta video que complementa al artículo.
El Stack – 6502 vs 6510 Episodio 11
Referencias
A continuación les dejo algunos links donde profundizar el tema:
WEBSITE
Aqui el sitio de OsoLabs con todos los videos y artículos
VIDEOS
Video de la serie 6502 vs 6510 Episodio 11 – El Stack
El Stack – 6502 vs 6510 Episodio 11
Aquí tiene acceso a toda la serie:
6502 vs 6510 estudio detallado y comparación
PAPERS
MCS6500 Microcomputer Family Programming Manual
Load and Run from 6502 ASM (1/2) | C64 OS
27c3: Reverse Engineering the MOS 6502 CPU (en)
Y como siempre la serie de Ben Eater del 6502
Build a 6502 computer | Ben Eater
Todos los ejemplos de código de los videos los pueden encontrar en:
60 años con BASIC
A 60 años de la creación de BASIC, damos una mirada a sus orígenes, su evolución y su legado
El pasado primero de mayo de 2024 se cumplieron 60 años de la creación de BASIC. Un lenguaje que fundó imperios, fue menospreciado por muchos y enseñó a programar a toda una generación. O dos.
BASIC es un acrónimo de “Beginner´s All-purpose Symbolic Instruction Code” (o “Código simbólico de instrucciones de propósito general para principiantes”), un conveniente juego de palabras, nunca más representativo y tal vez algo forzado, para designar un lenguaje que fue desarrollado para enseñar programación a los alumnos que no estuvieran relacionados necesariamente con las ciencias de la computación es decir, al resto de nosotros.
Nació en el Dartmouth College de la mano de John G. Kemeny y Thomas E. Kurtz y últimamente acreditando también como co-desarrrolladora a Mary Kenneth Keller quién fue una monja que tuvo el merito de ser la primera mujer en acceder al departamento de informática de esa institución (1958) y la primera también en obtener un doctorado en ciencias informáticas otorgado en los Estados Unidos (1965).
Estuvo inspirado en los lenguajes FORTRAN II y Algol 60. Pero el objetivo era hacerlo relativamente simple al punto que las “instrucciones” son simples palabras en Inglés y operaciones aritméticas de uso común.
Según Kurtz, la idea era simplificar el lenguaje lo suficiente para que casi no fuera necesario memorizar estructuras, llevándolo al lenguaje común donde los significados fueran casi obvios. “¿No es mas simple usar HELLO y GOODBYE que LOGON y LOGOFF?”, decía. Un ejemplo es que lo que en un bucle en FORTRAN se expresaría como “DO 100, I = 1, 10, 2” en BASIC se convierte a “FOR I=1 TO 10 STEP 2“, resultando en una sentencia (u “oración”) más explicita y fácil de recordar y entender.
La estructura de un programa de BASIC tradicional consiste en una secuencia de instrucciones, una por línea, siendo estas numeradas para ordenar la secuencia. Tradicionalmente y como una buena costumbre, esta numeración se hace de 10 en 10 para simplificar el agregado de líneas intermedias posteriormente sin tener que re numerar todo o parte del programa. Las instrucciones de un programa BASIC pueden reducirse a un mínimo de cinco:
LET, para asignar una valor a una variable (LET A=2)ç
INPUT, para recibir información del usuario (INPUT "Ingrese su edad", A)
PRINT, para imprimir información (PRINT "Tienes " + A + " años.")
IF ... THEN, para tomar decisiones y ejecutar otra instrucción según si una condición es verdadera o falsa (IF A > 18 THEN LET M=1)
GOTO, para saltar a alguna parte del programa (GOTO 10)
Sin embargo los dialectos de BASIC incluyen otras instrucciones que simplifican tareas (como por ejemplo el FOR …. NEXT para bucles citado más arriba), siendo algunas estándar y otras de las mas diversas, incluso dependientes de las características del hardware en el cual esta implementada cierta versión del lenguaje. En la versión original, por ejemplo, se implementan catorce instrucciones.
La gran explosión de BASIC se debió a la versión que Microsoft desarrolla para la Altair 8800.
A mediados de los años 70 con la aparición de los microprocesadores comienzan a aparecer los kits de desarrollo que se vendían a desarrolladores, estudiantes, y sobre todo a hobbistas. En 1974 MITS una empresa con sede en Albuquerque, Nuevo México (EEUU) desarrolla uno de estos kits basado en el procesador 8080 de Intel, el cual es tapa de la Popular Electronics de enero de 1974. Se populariza tanto que para la fecha de su lanzamiento en enero de 1975, se venden 2000 unidades en un solo mes.
En una ingeniosa jugada Bill Gates y Paul Allen escriben una carta a Ed Roberts, presidente y fundador de MITS preguntándole si estaría interesado en una versión de BASIC para la maquina. El membrete de la carta era de Traf-O-Data una empresa que ambos por entonces jóvenes (junto con Paul Gilbert) habían fundado en 1972. Roberts estuvo encantado con la idea, y Gates y Allen escribieron una versión del interprete BASIC para un microprocesadores de 8 bits, lo cual llevo a que en 1975 fundaran Microsoft que fue, durante la ultima década de los 70’s una empresa especializada en lenguajes de computación.
A partir de 1977, con la aparición de las primeras computadoras personales, muchas desarrollaron su propia versión de BASIC aunque una gran mayoría utilizó la versión de Microsoft. Lo importante de esto es que BASIC entró a los hogares y a las oficinas (recordar que la primer PC de IBM de 1981 también tenía BASIC en ROM) como la interfaz estándar para comunicarse con una computadora, teniendo un entorno completo de programación listo y funcionando con solo presionar el switch de encendido. Era común que uno hiciera cursos de BASIC, así como también los programas para copiar y tipear que se difundían en revistas y libros. Estuvo presente incluso en calculadoras científicas, y consolas de juegos desde la Atari VCS en adelante.
BASIC fue evolucionando a medida que las computadoras se volvieron mas potentes. Las números de linea desaparecieron, se volvió primero más estructurado, luego aparecieron versiones que implementan paradigmas como la Programación Orientada a Objetos, u Orientada a Eventos como Visual Basic, que en su momento de mayor difusión fue una de las herramientas mas utilizadas para el desarrollo de software.
¿Pero qué paso con BASIC?
Las computadoras personales fueron desapareciendo lentamente y la interfaz de BASIC dejó lugar a los escritorios de los distintos sistemas operativos modernos. Por un lado ya no era tan accesible programar y por otro lado la tecnología avanzo con nuevos lenguajes de programación que quizás fueron más apropiados para resolver ciertos problemas que fueron surgiendo, como por ejemplo la programación web, donde aparecieron herramientas específicas.
Pero también se empezaron a escuchar críticas que cuestionaron a BASIC como herramienta de enseñanza moderna. Algunos autores profesaban que quién aprendía a programar en BASIC arrastraba una serie de vicios que luego se hacían difícil de erradicar en sistemas de desarrollo más modernos.
Sin embargo es imposible negar el peso que tuvo BASIC. Por su simpleza, su potencia, y su casi omnipresencia quienes hoy tenemos entre 40 y 50 seguro dimos nuestros primeros pasos ahí. Incluso muchos lo hemos utilizado como herramienta no solo en el ámbito educativo u hogareño.
Un dato curioso es que BASIC se implementó por primera vez en una computadora General Electric (GE-225, aunque luego fue reemplazada por un modelo superior) que se compró específicamente para este proyecto. Esta era una mainframe que permitía la conexión simultánea de varios usuarios. Lo anecdótico es que esta familia de computadoras fue diseñada por Chuck Prosper y Arnold Spilberg. Si les suena el apellido, sí, es el padre de Steven, que si bien según relatos de Arnold nunca estuvo interesado en la informática, terminó siendo pionero en la integración de ambas “ciencias/artes”: pensemos en Jurassic Park… pero esta, es otra historia.
Para quienes estén interesados en saber más, además de Wikipedia, en una fecha como esta pero 10 años atrás, la revista Time publicó un excelente artículo sobre los 50 años de este hermoso lenguaje que muchos llevamos en el corazón: https://time.com/69316/basic
Los 5 juegos más originales de la Sega Genesis
Podemos debatir si es o no la mejor consola de 16 bits. Lo que no vamos a negar es que la morocha de Sega Genesis tuvo un catálogo de títulos tan creativos como impresionantes. En esta nota te contamos cuáles son.
***
La Genesis es mi consola de 16 bits favorita y todavía hoy, en pleno 2024, está más viva que nunca. Quizás no podía igualar el poder de la SNES, y ciertamente no tenía el reconocimiento de su nombre como la consola de Nintendo.
Sin embargo, gracias a su veloz mascota azul, una gran cantidad de excelentes ports de arcade y una estrategia de marketing que se centró en los jugadores mayores, Sega le dio a Nintendo una competencia más que digna.
Si me preguntan, la Genesis ayudó a elevar la calidad de los juegos en todo el mundo y fue la gran precursora de géneros que terminaron explotando en popularidad muchos años después.
¿Sabían, por ejemplo, que un FPS llamado Zero Tolerance –otro típico clon de Doom– les permitía jugar de a dos? Necesitabas dos televisores, dos cartuchos, dos consolas y un cable link (un cable especial que se conecta al segundo puerto del controlador en ambas máquinas). Pero que se podía, se podía.
Esta consolita también tuvo unos rail-shooters que exprimían la capacidad técnica del hardware (pienso en Spare Harrier o Panorama Cotton), propuestas de estrategia en tiempo real (Herzog Zwei), adictivos RPG´s (Rings of Power, las sagas de Shining Force y Phantasy Star) y un montón de títulos que desbordaron creatividad.
Veamos cinco de ellos, que también resultan ser títulos favoritos (y grandes recomendaciones) de la morocha de Sega.
***
Crusader of Centy, ¿el precursor de Pokemon?
Este impecable action RPG –claramente inspirado en la saga de Zelda– vio la luz en el año 1994 y tiene algunos curiosos paralelismos con el primer juego Pokemon (que, ojo… saldría 4 años después).
La historia da inicio en la ciudad de Soleil. Allí existe una regla que requiere que todos los niños de 14 años se entrenen para prepararse para la guerra. El protagonista, Corona, acaba de cumplir la edad estipulada y recibe la espada y escudo de su padre, quien murió en batalla defendiendo a la ciudad de monstruos.
Crusader of Centy tiene varios aspectos interesantes. El primero de todos es que, en los primeros momentos del juego, Corona gana la habilidad de hablar con plantas, monstruos y animales, pero pierde la de comunicarse con los humanos (recién la recupera a mitad de juego). Esto hace que la dinámica sea diferente y le permite a él conocer la otra cara de la moneda (spoiler alert: los verdaderos monstruos, de alguna manera, son los humanos).
Otra característica, quizás la más atractiva, es que va conociendo animales a lo largo de su viaje que le permiten adquirir diferentes habilidades. Este es el elemento más “Pokemon” que tiene el juego.
Es posible equiparse hasta dos animales para recibir sus efectos, y combinarlos para lograr resultados diferentes. Una cheetah te permite doblar la velocidad al caminar, una mariposa te da control manual sobre tu espada o una ardilla te permite que tu espada rebote en las paredes. También podés combinar los efectos de un pingüino (que hace tu espada de hielo) y un león (que hace tu espada de fuego) para darle un efecto más poderoso.
Si bien no es necesario “capturar” a todos los animales para terminar el juego, la mayoría de ellos te brindan habilidades necesarias para avanzar hacia otras partes del mapa. Y es muy divertido atraparlos a todos.
El curioso caso de General Chaos
General Chaos (¡creado por Electronics Arts!) salió en 1993 y es uno de los padres fundadores del género RTS con los que ahora todos estamos familiarizados. Cada equipo intenta capturar la ciudad capital de su oponente. Las batallas en sí son fáciles de entender (y aprender). Antes de luchar, cada bando elige uno de los cuatro conjuntos de escuadrones preestablecidos. Los equipos tienen cinco soldados con varias armas.
General Chaos es realmente un juego simple y adictivo. El concepto de guerra rudimentario hace que sea muy divertido hacer volar a tus oponentes. Quizás sea de los títulos más subestimados de la Genesis.
Esta obra también puede considerarse como un ejemplo temprano de lo que ahora se denomina “party games”. El modo para un jugador, aunque inicialmente atractivo, lamentablemente carece de profundidad y longevidad, sin embargo, no se puede decir lo mismo de los espléndidos modos cooperativo y de batallas compatibles con múltiples jugadores, en los que la acción es convenientemente caótica, frenética y evoca una amarga rivalidad.
Fatal Labyrinth: un roguelike en la Genesis
Soy el primero en admitir que Fatal Labyrinth (1991) se veía tan feo que parecía un juego de 8 bits más que de 16 bits, pero pocos me divertían tanto. Su aspecto más atractivo es el estilo roguelike (un género que descubrí con este juego, de hecho).
El subgénero del roguelike (o de “exploración de mazmorras”) es uno en el que énfasis está puesto en el contenido aleatorio: mazmorras generadas aleatoriamente, con enemigos, objetos y trampas al azar. La jugabilidad es el aspecto primario, por encima de la estética.
En este tipo de juegos morís con frecuencia, pero tiene una curva de aprendizaje que estimula el avance, e incluye ciertas mecánicas de juego que recompensan al que sigue intentando.
Gracias a Fatal Labyrinth, luego me fanaticé con el subgénero y me llevó a conocer Pixel Dungeon, del cual me enamoré perdidamente.
Dentro de la historia de la Genesis, Fatal Labyrinth es bastante único. Es el único juego de exploración de mazmorras tipo roguelike con mecánicas de RPG que haya visto en la consola. Es verdad que dura unas pocas horas, pero el hecho de que los mapas y objetos sean generados aleatoriamente brinda cierta rejugabilidad.
El subgénero roguelike hoy es uno de los más populares. Pienso en joyitas como Into the Breach, Dicey Dungeons, Slay the Spire, Rogue Legacy y tantos otros. Pero en aquella época era algo completamente desconocido. Por eso quizás Fatal Labyrinth me volvió tan loco en su momento.
El juego tiene lugar en una vista aérea mientras el jugador atraviesa habitaciones y pasillos para encontrar las escaleras al siguiente nivel. Dentro de estos pisos, encontraremos elementos y equipos mientras nos enfrentamos a enemigos por turnos. Los monstruos no reaparecen, pero si colgás demasiado tiempo en un mismo piso… lo harán. Por cierto, ¡este juego está disponible en Steam!
Gain Ground: acción y estrategia
Nuevamente les recomiendo un juego de 1988 que se ve feíto, pero que cuenta con una mecánica que lo hace especial. Junto a Gunstar Heroes, Sunset Riders y General Chaos, éste es el otro clásico que vale la pena jugar en modo cooperativo. ¡Y si no lo habré jugado!
El juego combina acción y estrategia. Comenzás controlando a un número pequeño de personajes, cada uno con sus habilidades y características particulares. A medida que se va avanzando, vas rescatando a nuevos personajes con otro tipo de habilidades. Los primeros niveles comienzan en la Edad Oscura, luego avanzás hacia la Edad Media, la China pre-revolucionaria, el presente y, finalmente, el futuro lejano.
Recientemente me enteré de que Gain Ground tiene una versión remasterizada para la PlayStation 2 (se ve mucho más linda) y también una versión del original para Steam.
Atravesando paneles en Comix Zone
Comix Zone no sólo es uno de los juegos más originales de la Genesis, sino también del mundo entero. Un artista de comics (Sketch Turner) queda atrapado en una de sus creaciones y tiene que atravesar la historia cuadro por cuadro, atravesando paneles, atacando enemigos a medida que literalmente se dibujan frente a vos.
El gran problema con el juego es que era extremadamente corto (sólo 3 niveles) y muy difícil. Pero se veía tan bien que daban ganas de jugarlo una y otra vez. Además, contaba con algunas situaciones en las cuales podías elegir dos caminos, haciendo que el nivel variara ligeramente.
Nunca más vi un juego beat-em-up tan único como éste. Fusionó el clásico genero de acción y pelea con un diseño fresco, algunos rompecabezas para resolver, manejo de items y un estilo súper particular.
¿Jugaron estos cinco juegos de la morocha de 16-bits? ¿Qué otro título de la Genesis pueden recomendar? ¡Los leemos!
***
Si les gustó esta nota, recomienden a sus amigos. Y sino les gustó, le avisan a sus enemigos. ¡Recuerden que pueden apoyar a Espacio TEC subscribiéndose al Club Pixel o aportando con un cafecito!
Quien escribe, los saluda.
Lupa “morocho consolero” Sívori
Podés seguirme por en Instagram y en Facebook. También tengo este blog de vicios personales.
«I’m in my own comic book – Noooo!» (Sketch Turner)
C64 a Fondo – Indice
A continuación les dejo los links a los artículos anteriores de la serie
6502 vs 6510 Episodio 10 – Conectando una Memoria Static RAM
Continuamos este estudio comparativo del 6502 vs el 6510 esta vez conectando una memoria Static RAM del modelo 62256 que posee 32kb.
Vamos a estudiar cómo conectar esta memoria tanto a un 6510 con CIA 6526 como a un 6502 con VIA 6522, incluiremos todas las rutinas de assembler para poder probar la memoria, sus conexiones físicas y timing de la memoria con el procesador, punto central de su funcionamiento.
La Memoria HM62256B
Esta memoria es una static ram, esto implica que los datos que esta posee no necesitan ser refrescados cada cierta cantidad de ciclos de reloj sino que los mismos se conservan mientras esta no pierda electricidad.
Su denominación de 256 refiere a sus 256Kbits disponibles, estos están organizados en 32768 entradas de 8bits cada una lo que conocemos normalmente como 32Kbytes.
PinOut
Este chip viene en formato DIP (Dual Inline Pins) de 28 pines y es muy parecido en su layout a la eeprom AT28C256 que vimos en un artículo anterior.
A14 – A0: Estos pines nos permiten seleccionar qué registro de ocho bits queremos acceder dentro de nuestra memoria, al ser 15 pines podemos direccionar 2ˆ15 = 32768 registros de 8 bits. Estos pines se conectan al bus de direccionamiento.
I/O 0 a I/O 7: Los pines de I/O es donde vamos a ver el contenido de cada registro previamente seleccionado para leer la memoria, o donde vamos a enviar los datos que tenemos para escribir la memoria. Estos pines se conectan al bus de datos.
VCC: En este pin es donde el chip espera una alimentación de +5Volts
GND: Este es el pin de referencia a tierra del chip
/WE: El pin de write enable al recibir una señal de low o 0 Volts permite grabar en los registros de la memoria. Como la estamos utilizando como una ROM conectamos este pin directamente a +5 Volts para que sea de sólo lectura. La barra / significa que este pin es active low con lo cual espera 0 Volts para activarse
/OE: El pin de output enable conecta o desconecta los pines de I/O del bus de datos. Si el pin está en +5 Volts la memoria se desconecta del bus de datos poniendo sus pines de datos en un estado de alta impedancia. La barra / significa que este pin es active low con lo cual espera 0 Volts para activarse
/CE: El pin de chip enable conecta o desconecta los pines del chip para una lectura o escritura trabajando en conjunto con /OE y /WE. Es active low con lo cual espera 0 Volts para activarse
Timing para una lectura
Cuando un procesador y una memoria necesitan comunicarse ya sea para lectura o escritura hay dos tiempos generales que tienen que ser compatibles: el tiempo en que la memoria responde y el tiempo que el procesador puede esperar. Para poder leer o escribir tenemos que realizar una combinación de 3 pines /WE /OE /CE. En el caso de una lectura WE debe estar en High y OE y CE en low, para una escritura los 3 pines deben estar en LOW.
Timing de la Memoria en una lectura
Para poder hacer una lectura de la memoria, primero el procesador debe poner en el address line o bus de direccionamiento la dirección donde está el dato que quiere leer, esta dirección consiste en los unos y ceros o los highs y lows de los pines A15 a A0.
La memoria no tiene inmediatamente disponibles los datos elegidos sino que tarda en buscar el dato y en poner el mismo en el bus de datos con sus 8 bits representados por los pines D7 a D0 y tarda en que estos estén estables, que sean válidos y que reflejen el valor interno en la memoria por lo que el procesador tiene que esperar un tiempo hasta que estos datos sean válidos y recién ahí leerlos, en el caso del datasheet del ejemplo 70ns como mínimo debe ser el tiempo de espera del procesador.
Hagamos el análisis paso por paso utilizando el siguiente diagrama.
Primero el procesador tiene que colocar los 16 bits del address line en forma correcta pero estos puede que no sean seteados al mismo tiempo o en algún orden específicos con lo que el bit 1 puede setearse luego el 15, luego el 12, etc. Tenemos que esperar hasta el punto donde comienza TRC o Read Cycle Time que es el momento donde el address bus tiene los 16 bits en forma correcta.
El procesador deberá esperar un tiempo tAA o Address Access Time, que es el tiempo para que los datos en el bus de datos sean válidos y con valores correctos. Cuando el tiempo tAA termina recién ahí los datos o bits o highs y lows que están en el bus son válidos y representan la dirección deseada.
Este tiempo posee dos subcomponentes tACS o chip Select to access time que es el tiempo que tarda el chip en activarse cuando recibe una señal low en el pin de Chip Select y también tOE o Output Enable to Output Valid, qué es el tiempo que tarda en activarse los pines de output luego de recibir un low en el pin de Output enable y que estos pines reflejen el valor correcto del contenido de la memoria en el bus de datos..
¿Cómo sabemos cuánto puede tardar como máximo el chip en darnos datos válidos una vez que tenemos un address válido en el bus de direccionamiento? Con una tablita de tiempos de acceso disponible en el datasheet de cada chip.
Si vemos para el chip de la familia HB62256B si termina el mismo en -7 el tiempo máximo de address access time o tAA es de 70 nanosegundos, podemos deducir que es tiempo máximo de tACS el chip select to access time o lo que tarda en activarse el chip ya que este timer tarda 70 ns y el de tOE de Output enable to output valid solo tarda 40ns como máximo.
tAA = 70 ns
tACS = 70ns
tOE = 40ns
Otro tiempo importante que vamos a utilizar en el futuro es el tOH o el Output hold time from address change, este tiempo es cuánto los datos vamos a mantenerse como válidos desde que cambió el address en el bus de direccionamiento, este es de 5ns
tOH = 5ns
Ahora cómo sabemos si el procesador que utilizamos puede esperar 70 nanosegundos? Estudiando el diagrama de timing del mismo,
Timing del Procesador 6502 en una lectura
El siguiente es el diagrama de tiempos del procesador 6502 hecho por Western Design Center. El problema con este diagrama es que mezcla los tiempos de escritura y de lecturas al mismo gráfico por lo que construí un diagrama simplificado para poder entenderlos mejor.
Por otro lado la velocidad de cada uno de estos intervalos va a depender de a que voltaje nosotros manejemos el cpu, como estamos usando +5 Volts esa es la columna que utilizaremos. Estos voltajes nos van a dar un máximo de 14Mhz para correr nuestro CPU pero lo vamos a estar corriendo a 1Mhz.
El ciclo del Reloj
El primer tiempo que nos interesa saber es el de un ciclo completo de reloj, este está representado en el diagrama como PHI2 y se divide en tPWL y tPWH (Clock Pulse Width Low y High respectivamente). Al usar un reloj de 1Mhz vamos a tener disponibles 1000 nanosegundos para todo el ciclo completo de reloj.
(1)
tPWL va de 0ns a 500ns
tPWH va de 500ns a 1000ns
El mínimo de tiempos de estos intervalos podría ser de 35ns cada uno o sea 70ns de ciclo de reloj si lo corriéramos a 14Mhz pero sabemos que por lo menos necesitamos 70ns para que nuestra memoria nos de los datos con lo cual esta velocidad no es adecuada.
Las preguntas que debemos responder primero para ver si podemos esperar esos 70ns que tarda en acceder a los datos la memoria que estamos utilizando es cuando el procesador configura el address en sus pines y cuando r ealiza la lectura.
Estableciendo el Address en el Bus de Direccionamiento
El segundo tiempo que vamos a tener que estudiar es el tADS o Address Setup Time , es el tiempo que le toma al cpu estabilizar los highs y lows en los pines del bus de direcciones. Y el tercer tiempo es el tAH o Address Hold Time, por cuánto tiempo esos highs y lows son válidos en el bus de direcciones.
(2) tADS = 30ns
(3) tAHT = 10ns
El tADS comienza en el falling edge del comienzo del ciclo del reloj.
El tAHT se mantiene desde el falling edge (transición de High a Low) del final ciclo del reloj.
Leyendo los datos
El cuarto tiempo a estudiar es el tDSR o Data Setup Time, que es cuánto tiempo tardan en estabilizarse los highs y lows en el bus de datos y el quinto tiempo es el tDHR o data Hold read time o cuánto tiempo esos datos són válidos.
(4) tDSR = 10ns
(5) tDHR = 10ns
El tDSR termina desde el falling edge (transición de High a Low) del ciclo del reloj en ese falling edge es cuando ocurre la lectura.
El tDHR son por lo menos 10ns desde el momento de la lectura.
Tenemos que asegurarnos que la RAM esté dando datos válidos durante tDSR + tDHR. Tenemos que asegurarnos que la RAM esté dando datos válidos durante tDSR + tDHR.
Si hacemos un esquema podemos ver:
0ns a 30ns necesitamos que el address sea estabilizado tADS
30ns a 1010 ns el address el válido tAHT
990ns a 1010ns los datos tiene que ser válidos tDSR + tDHR
Con lo cual la ram tiene 990 – 30 = 960ns para poder dar los datos en el bus, pero como vimos la RAM sólo tarda 70ns como máximo para darnos los datos por lo que tenemos mucho tiempo disponible.
Pero por cuánto tiempo la RAM mantiene los datos válidos en el bus? Para esto está el timer tOH de la RAM que es de 5ns a partir de que cambia la dirección de la ram, pero la dirección cambia recién en el ns 1010 que es cuando expira el timer de address hold time del procesador lo que nos da unos 5ns extras para la lectura.
990 ns a 1015ns la RAM da valores de highs y lows válidos en el bus de datos
Por esto podemos hacer la lectura por que el procesador requiere de 10ns después del momento de la lectura y la RAM mantiene los datos válidos por 15ns
De forma similar a como hicimos este análisis podemos realizar lo mismo para la escritura de la memoria variando solo algunos valores de los parámetros.
Un gran lugar para poder ver alternativamente como funcionan los diagramas de tiempo del 6502 es este sitio donde se ve muy bien visualmente Visual Guide to 65xx CPU Timing
Timing para una escritura
Con la información que ya tenemos de interpretar cómo se hace una lectura encaremos la escritura de datos en la memoria.
Timing de la Memoria en una escritura
Veamos este nuevo diagrama de tiempos para la escritura.
Y también los nuevos valores mínimos y máximos para estos parámetros
Este diagrama asume que el pin de OE output enable está fijo en Low y según la nota 4 la escritura se va a realizar cuando CS y WE ambos estén el Low.
Comienza el tiempo tWP o Write Pulse Width cuando el último pin entre WE y CS entren en low y dura hasta que el primero de ellos pase a High.
tWP = minimo de 50ns
Los datos deben ser válidos en el bus por lo menos desde tDW o Data Write time overlap y mantenerse válidos por un período tDH o Data Hold form write time
tDW = 30ns
tDh = 0ns
Con lo cual por lo menos 30ns antes de que WE o CS pasen a ser High los datos deben mantenerse como válidos.
Si analizamos lo que puede pasar, el bus de datos puede tener cualquier información errónea sin problemas y esos datos se escriben en la ram, pero por lo menos 30ns antes de que se termine la escritura los datos deben ser válidos ya que estos quedarán en la RAM, estos datos válidos pueden ser mantenidos por 0ns enel bus si queremos ya que ya han sido escritos ya que el mínimo de tDH es cero.
Timing del Procesador 6502 en una escritura
Veamos este nuevo diagrama de tiempos para la escritura.
Sabemos que los siguiente tiempos se cumplen debido a nuestro análisis anterior:
0ns a 30ns necesitamos que el address sea estabilizado tADS
30ns a 1010ns el address el válido tAH
1000 ns a 1010ns tDHR
Los datos se vuelven inválidos al final de tDHR que coincide con tAH y con un nuevo timer tDHW o Write Data Hold Time
tDHW = 10ns desde el falling edge fin del clock cycle
1000 ns a 1010ns tDHW
El write ocurre en el falling edge del final de clock cycle. Pero para que la escritura sea correcta los pines de CS o WE tienen que ser high antes de que el address, los datos o el write hold time sean inválidos.
Si conectamos el pin de chip select CS a cualquier de las address lines estaríamos en problemas ya que debemos asegurar que el pin CS sea high mientras todavía todos los pines de address son válidos y todos los pines de datos son válidos, pero no tenemos forma de poder apagar un pin antes que los otros asegurándonos que sea siempre así.
Lo mismo nos sucede con el pin de R/W del procesador no hay forma de garantizar que vaya a cambiar antes que los pines de address.
Con lo que nada nos asegura que CS o WR pasen a ser High (terminando la escritura) antes de que el address y los datos seán inválidos.
Para solucionar esto podemos hacer que el CS chip select pin sólo sea LOW durante el ciclo de pulso alto del reloj o tPWH de 500 a 1000 ns, de esta forma nos aseguraremos que el address bus tenga direcciones válidas y que unos nanosegundos tDW antes de apagarse el CS tenemos todavía datos válidos, ya que los hold timers de tAH y tDW nos mantendrían valores válidos en address y data bus respectivamente aún después de poner el High el pin de CS. En nuestro ejemplo serían 10ns extras.
Para lograr esto podemos conectar el pin a15 si lo usáramos para seleccionar nuestro pin de chip select conectado a través de dos compuertas nand de forma tal que solo en el pulso high del reloj y cuando el pin a15 sea cero el pin de la memoria de chip select reciba un cero o low.
Al agregar dos compuertas nand debemos sumar un tiempo más que el que tarda la compuerta en evaluar sus inputs y darnos un output, este tiempo se llama maximum propagation delay (tPHL).
En el caso de las compuertas que utilizamos este es de 25ns al usar 2 vamos a tener como máximo 50ns de delay, lo que implica que la señal de chip select va a ir a low 50 ns después de que si no usáramos las compuertas, en este setup ese tiempo no influye ya que tenemos 960ns disponibles con el address valid antes de que los datos estén válidos (llendo de los 30ns a los 990ns) esto nos llevaría sólo al intervalo 80ns a 990ns no implica problema alguno.
Timing en el procesador 6510
El timing en el 6510 es bastante más lento que en el 6502 y eso debemos tomarlo en cuenta, observemos estos valores y diagramas del datasheet original, el primer diagrama es de lectura y el segundo tiempos de escritura. 
También tenemos algunos tiempos diferentes que los del 6502 más moderno
Así por ejemplo podemos observar el timer tADS o Address Setup Time el cual tarda 300ns en lugar de los 30ns del 6502 moderno. Si tuviéramos que hacer la cuenta con los tiempos para nuestra memoria ahora deberíamos comenzar así:
tADS = 300ms
tAH = 10ms
tDHR=tHR=10
0ns a 300ns necesitamos que el address sea estabilizado tADS
300ns a 1010ns el address el válido tAH
1000 ns a 1010ns tDHR
Y nuestra RAM muestra datos válidos desde
(tADS+tAA) a (tAH+tOE) = 300ns+70ns a 1010ns + 5ns
370ns a 1015ns la RAM da valores de highs y lows válidos en el bus de datos
Si nos referimos al manual de Hardware de la línea de procesadores 6500 él mismo nos dice que a 1Mhz el address está estable. sí o sí, 300 nano segundos después de que comienza la fase uno y los datos deben estar estables al menos 100 nanosegundos antes de que termine la fase dos de nuestro ciclo de reloj. Esto nos da 575 ns para poner los datos en el bus de datos.
Y podemos observar los diagramas para timings de Read y Write respectivamente.
Read Timing Diagram
Write Timing Diagram
Cómo funciona en el Commodore 64
En nuestra querida Commodore 64 no estamos usando una memoria estática como la de este empleo si no que es dynamic ram, esta misma debe ser refrescada constantemente de lo que se encarga el chip de video VIC2. Esta memoria se selecciona por filas y columnas utilizando las señales de RAS y CAS.
Tampoco tenemos un sólo chip sino 8 chips cada uno de 64536 entradas y 1 bit de datos en cada entrada, con lo que si queremos representar un byte necesitamos los 8 chips y 1 bit de cada uno de ello, de ahí que cuando se rompe un chip de ram nada funciona ya que afecta al contenido de un bit en cada posición de la RAM.
Estudio visual
Para poder estudiar visualmente cómo conectar una ram estática y programarla les dejo esta video que complementa al artículo.
RAM con 6510/CIA y 6502/VIA – 6502 vs 6510 Parte 10
Referencias
A continuación les dejo algunos links donde profundizar el tema:
VIDEOS
Video de la serie 6502 vs 6510 Parte 10 – RAM
RAM con 6510/CIA y 6502/VIA – 6502 vs 6510 Parte 10
Aquí tiene acceso a toda la serie:
6502 vs 6510 estudio detallado y comparación
PAPERS
Visual Guide to 65xx CPU Timing
MOS 6500 Family Hardware Manual
Y como siempre la serie de Ben Eater del 6502
Build a 6502 computer | Ben Eater
Todos los ejemplos de código de los videos los pueden encontrar en:
Mozo, hay un Huevo de Pascua en mi ordenador!
Algunos de los easter eggs mas famosos, revisitados en esta entrega en el dia de pascuas.
La película Ready Player One (2018) dirigida por Steven Spilberg y basada en el libro homónimo de Ernest Cline popularizó el ya ultra conocido (gracias a internet) “primer easter egg (huevo de pascua) de la historia”. De la historia de los videojuegos, aclaremos. Y también aclaremos que eso es lo que creemos, solo hasta que aparezca uno anterior.
Cuenta la historia que Atari era reacia a dar a conocer los nombres de los programadores, artistas y diseñadores de sus videojuegos que por aquel entonces se publicaban para sus sistemas, en este caso para el Atari VCS/2600. Lo cual tenía a estos personajes algo disconformes. Así fue que en un acto de rebeldía, en el juego Adventure (1979), si el jugador hacía una cierta serie de acciones aparecería en pantalla la leyenda”Created by Warren Robinet”, en clara declaración de autoría e inmortalizando un nombre que de otra forma, hubiese quedado como uno más del montón.
Hay que entender el contexto, claro. No es que Atari fuera un explotador tampoco. Simplemente, la industria aún estaba en pañales. Y “el Atari” era, de alguna manera, considerado un juguete. Se vendía en los mismos mostradores que los juegos electrónicos, y las máquinas de pong hogareñas. Entonces los cartuchos de juegos eran meros accesorios que uno podía comprar (o pedirle a Santa) para cambiar el juego de la consola. Un gran avance sobre la generación anterior (las maquinas de Pong), que solo tenían un juego (o variantes de esta) y la cosa ya se estaba poniendo aburrida. Fairchild ya lo había hecho un año antes, pero la idea estaba en el aire. Y bajo esa lógica, así como Mattel no publicaba los accesorios de Barbie con el nombre de sus diseñadores, ¿porque lo haría Atari o quien fuese con sus cartuchos? “Sí, lo hizo un ingeniero. Un empleado. Pero te lo vende Atari”. Desde el punto de vista de la empresa, daba igual quién fabricaba qué parte.
Pero sucede que a diferencia del caso de Barbie, los juegos terminaron siendo lo más importante de la consola. Y si le sumamos el hecho que la VCS/2600, debido a sus limitaciones, era extremadamente difícil de programar, estos tipos era Rockstars. Invaluables y… mal pagos. Bueno, según ellos. Artistas. Así que no es de extrañar esa necesidad de querer firmar la obra.
Vamos a repasar algunos easter eggs fomosos que tal vez ya nuestros lectores conozcan, o tal vez no. En cualquier caso, siempre es divertido encender alguna de estas máquinas de 40 años y ver que todavía siguen ahí. Y esto las hace un poquito mas humanas… ¿no les parece?
Microsoft!
Cuenta la historia que Jack Tramiel, fundador de Commodore, en una maniobra (y canchereada a lo “che pibe”) le dijo a Bill Gates “yo ya me casé una vez” cuando éste le propuso la idea de que el interprete BASIC que le había vendido para sus nuevas microcomputadoras PET lo usaran bajo el modelo de licencias. Pero Jack ya había pagado una vez y no quería atarse a nadie. Bill entonces, previendo un posible juicio donde tuviese que demostrar autoría, dejó escondido dentro del código de su interprete la palabra “Microsoft!”. El comando mágico es
WAIT 6502,x
…donde X es la cantidad de veces que se escribe.
Claro que luego los ingenieros de Commodore lo descubrieron (Bill no se contuvo y lo escribió en una CES…) y lo eliminaron; pero si aún tienen acceso a una de las primeras PET, Billy sigue saliéndose con la suya.
Corolario: cuando Commodore necesitó un nuevo BASIC para la flamante y pronto a estrenarse Amiga… bueno digamos que por eso es que en la pantalla de la contemporánea C128 tuvieron que poner “BASIC 7.0 (c)1977 Microsoft Corp.” Pero Jack ya no estaba.
Software y Herdware
Ya que mencionamos la Commodore 128, los ingenieros que participaron en su desarrollo también quisieron dejar su marca. Bueno. Es que se había puesto de moda. Dentro de los gabinetes de las “súper avanzadas” Apple Macintosh (1984) y Commodore Amiga (1985) podemos ver inmortalizadas en el plástico las firma de los artistas que las crearon. Cada plataforma que salia al mercado era un sistema completamente nuevo al cual había que inventarle todo, esto requería de trabajo en equipo. Y mucho esfuerzo. Así que había que dejar la huella.
El comando mágico es entonces:
SYS 32800,123,45,6
… y aquí podemos ver quienes fueron los encargados del Software y quienes del Hardware o “herdware”, juego de palabras porque Bill Herd fue el encargado de liderar el equipo.
Pero ya lo habían hecho antes también. Si en la Commodore 16, Commodore 116 o Commodore Plus/4 (son básicamente la misma maquina en diferentes configuraciones) escribimos:
SYS 52651
… aparecerán los nombres de los involucrados.
Rebeldes
Como vimos al principio, los Easter Eggs no son solo una manera de firmar la obra. Sino también pretenden dejar un mensaje. A veces menos y a veces más explicito.
Terminando este artículo (que podría volverse infinito), me pareció muy emblemático el caso de la Amiga 500 (1987).
Commodore era una empresa que tras la renuncia de Jack Tramiel se volvió algo caótica. Cuando los ingenieros terminaron el desarrollo del Amiga, tenían en sus manos la computadora de consumo masivo (léase “hogareña” o “personal”) más poderosa del momento. Pero fue un fracaso en ventas, principalmente porque la gente de Marketing (al menos la gente de marketing de USA, aclaremos), no supo venderla. Eran áreas que estaban muy desconectadas entre si, lo que trajo mucha rivalidad interna y frustración en los desarrolladores.
Así que para la salida de la Amiga 500 nuestros enojados amigos dejaron en ROM (Kickstart 1.2) lo siguiente: Al presionar ambas teclas ALT, ambas teclas SHIFT, y las teclas de función obtenemos los siguientes mensajes en la barra de menu:
… + F1 : “System Software: Carl, Neil & Kodiak”
… + F2: “Graphics Software: Dale, Bart, Jim & :RJ:
… + F3: “QA: Jon, Bruce, Stan, Kim & Jerry
… + F4: “LG Support: Caryn, Dave, Victor, Terry, Cheryl & Nancy”
… + F5: “CBM Software: Andy, Barry, Dave & Eric”
… + F6: “Pics: Sheryl & Jack”
… + F7: “Docs: Rick, Mitch, Peggy & Rob”
… + F8: “Chips: Jay, Akio, Glenn, Edwin, Mark & Dave”
… + F9: “HW: Dave, Bill, ChrisR & Josh”
… + F10: “Me Made Amiga, They fucked it up.”
Wow.
Cuando Commodore descubrió ese ultimo, imagínense que no les resultó nada gracioso, porque si bien la combinación de teclas es algo … digamos … complicada, no es tan difícil que se dé, así que pidieron que se remueva.
Pero lejos de hacerlo, solo lo escondieron más. En las siguientes revisiones del ROM, con F10 podíamos leer: “Moral Support: Joe Pillow & The Dancing Fools” (la explicación de estos personajes requiere un artículo aparte)
Pero si presionamos la combinación antes citada con F1 y quitamos el diskette del drive interno, aparecerá el mensaje “The Amiga, Born a Champion”.
Pero esto no es todo. Si luego, sin soltar nada, presionamos el botón izquierdo del mouse y volvemos a introducir el disquette, vuelve a aparecer “We made Amiga…”
Los Chiches de la Commodore 64 – Ep 1 – El Reset Jabonera
En esta ocasión vamos a estudiar a un gran amigo que nos dejó excelentes recuerdos a la hora de obtener vidas infinitas en nuestros videojuegos, El Reset o Jabonera.
Vamos a estudiar que hacía, como funciona por dentro, que circuitos tenía y cómo lograr poner vidas infinitas en alguno de nuestros videojuegos favoritos.
Qué es el reset
El reset es un dispositivo que nos dejaba llamar al circuito de reset del procesador 6510 sin tener que apagar el mismo y sin la necesidad de borrar la memoria y comenzar desde cero. De esta forma podemos modificar posiciones de memoria con un programa cargado en la misma.
Su forma más típica es la de un cartucho blanco con un botón rojo que se conecta al puerto de usuario.
El puerto de usuario posee el siguiente pinout
Estamos interesados en dos pines específicos el pin 12 de ground o tierra que nos va a poder dar valores LOW o cero y el PIN 3 o Reset. Algunos diseños también usan el pin 1, el pin N o el pin A como ground.
El PIN 3 está conectado a través del PCB del Commodore 64 directamente con el Pin 40 o de Reset del Procesador 6510. El Botón de reset activa el reset del procesador.
Así se ve la conexión de ambos resaltada en azul donde vemos la conexión del Pin 3 del puerto de usuario al pin 40 del procesador 6510. También existe otro modelo de reset que está conecta al puerto serial y hasta puede estar conectado en la disquetera.
La línea de reset se mantiene en High cercano a los 5 Volts gracias a una resistencia de 1Kilo ohms que conecta la línea de reset con los 5 Volts del mother, en el diagrama R36.
Cómo funciona el reset internamente
El botón de reset internamente es un circuito que conecta el pin 3 de reset al pin 12 de ground a través de un botón de push que se encuentra normalmente abierto, al presionarlo y unirlo al pin 12 de ground hace que el pin 3 del user port conectado al pin 40 del procesador reciba un voltaje de low (menor a 0,4 Volts).
En esta foto podemos ver el pin 1 unido al pin 3 (recordar que una alternativa de pin de grund era el uno) y un botón para reset conectados a un placa que expande el puerto de usuario.
En nuestras latitudes (33 grados sur) hemos encontrado directamente cables soldados al botón y a los dos pines del user port de la mother lo que no solemos recomendar.
En nuestros pagos esta es la típica jabonera a la que estamos acostumbrados, la que conectamos al User port.
La misma posee un botón conectado a los pines 3 como reset y 12 como Ground a través de dos alambres.
Si medimos con un osciloscopio cada vez que presionamos el reset vemos como la línea del reset conectada al pin 3 baja a 0 volts. En la imagen el probe o punta de testeo del osciloscopio está conectado al pin 3 de reset y el cable de ground al pin 12.
Al recibir un low en el pin 40 del procesador se activa la rutina de reset del 6510 que en este caso va hasta la posición de memoria $FFFC y $FFFD y se fija que dirección de memoria está aquí adentro y va a ejecutar ese programa.
En el caso de la Commodore 64 va a la rutina que está en la posición $FCE2 y ejecuta el siguiente programa:
Esta rutina inicializa la commodore sin borrar la memoria:
- Primero carga el valor $FF al registro X para luego configurar el stack pointer,
- Deshabilita las interrupciones prendiendo el flag de interrupciones,
- Configura el stack pointer en FF dejándole listo en $01FF,,
- Borra el flag de modo decimal del procesador,
- Se fija si existe algún cartucho con autostart y si existe este lo ejecuta (a partir de la posición $8000),
- Si no había cartucho llama a las rutinas de inicialización IOINIT (inicialización de dispositivos),, RAMTAS (inicilaiza y testea la RAM), RESTOR (configura los vectores como ser también el de reset $FFFCy $FFFD), y por último CINT que inicializa la pantalla,,
- Limpia el flag de interrupciones habilitándolas nuevamente y
- Arranca el programa de Basic a través de la posición de memoria $A000.
Finalmente vemos que nos deja en el prompt de basic pero con el programa que estuviera en memoria a la hora de pulsar el botón de reset todavía cargado en la misma.
¿Cómo lo usamos?
Primero cargamos un programa a memoria desde disco o cassette y ni bien este terminó de cargar pulsamos el botón de reset.
Si el programa que había en memoria es un programa en basic debemos antes de usarlo restaurar los punteros al código y memoria del mismo. Esto se realiza con los siguientes comandos.
(pO = p [Shift] o; pE = p [Shift] e) estas son las abreviaturas de poke para po y peek para pe
pO2050,8:sys42291:pO46,(pE(35)-pE(781)>253):pO45,pE(781)+2and255:clr
Luego de esto podemos correr el programa Basic, listarlo con LIST o grabarlo a disco.
Si lo que tenemos es un programa en código máquina, como por ejemplo un juego, podemos verlo con un monitor de código máquina o por si ejemplo si tenemos el wonderboy y queremos ponerle como truco vidas infinitas tipeamos los siguientes comandos desde el basic.
POKE 2676,238
SYS 2112
El comando Poke modifica la posición de memoria de las vidas y el comando SYS es una llamada a ejecutar el programa que está en la dirección 2112 que es el comienzo del juego.
Conclusión
Y de esta forma funciona nuestra querida Jabonera que tanto hemos usado para poder interrumpir alguno que otro videojuego y ahora sí ,con vidas infinitas, poder terminarlo. Un circuito muy simple y uno de nuestros clásicos chiches de Commodore.
Estudio visual
Para poder estudiar visualmente cómo funciona el Reset Jabonera, les dejo este video que complementa al artículo.
Referencias
A continuación les dejo algunos links donde profundizar el tema:
VIDEOS
El Reset Jabonera – Lo Chiches de la Commodore 64 Parte 1
Aquí tiene acceso a toda la serie de videos:
Artículos
Aquí encuentran todos los Artículos sobre Los Chiches de la Commodore:
PAPERS
Esquema del Mother parte Izquierda Commodore 64
Esquema del Mother parte Derecha Commodore 64
Wonder Boy Cheats, Codes, and Secrets for Commodore 64 – GameFAQs
Todos los ejemplos de código de los videos los pueden encontrar en:
Los Chiches de la Commodore 64 – Ep Cero – Introducción
¡Bienvenidos! Estamos empezando una nueva serie llamada Los Chiches de la Commodore 64. Nuestra querida Commodore nos dio muchas alegrías pero ella no podría haber hecho todo sola, por eso, siempre se valió de algunos Chiches.
En esta nueva serie vamos a estudiar cuáles son esos chiches, como funcionan por dentro y como usarlos.
Qué son los Chiches
Los Chiches son todos aquellos dispositivos clásicos y modernos que nos ayudan a usar la Commodore como por ejemplo la Famosa Jabonera de Reset, el sd2iec, los joysticks, el lápiz óptico, los adaptadores para el mouse, los cartuchos, los death test, las expansiones de memoria, módems tradicionales, modem wifi. Y podría seguir mucho tiempo más.
Siempre fueron un pequeño misterio cómo funcionan por dentro, de qué circuitos de la máquina se valen y sobre todo ¡Cómo se usan! ¡Más de uno tiene alguna función oculta que todavía al día de hoy no descubrimos!.
Qué vamos a ver
En este viaje vamos a estudiar:
Nuevos dispositivos de entrada salida como ser:
- Adaptadores VGA como el Apollo 64+.
- Sd2iec para conectar una sd card a tu Commodore.
- Pi1541 para tener una 1541 con sdcard que respete todos los vericuetos e idiosincrasias de nuestra querida 1541.
- El clásico Sánguche (leer con voz de yo quiero un sangucheee) S-Video a RGB a HDMI.
Dispositivos modernísimos como ser:
- El cartucho Ultimate II+, una gran navaja suiza.
- Modem wifi para acceder a una bbs a través de Internet.
- VersaCart para poder armar tu propio cartucho.
- La Ram Expansion Unit (REU) a través de una raspberry pi.
- Joysticks modernos con microswitches.
- IRQHack.
Dispositivos Clásicos como ser:
- La Jabonera de Reset.
- El cartucho CPM.
- El clásico modem de Commodore.
- La REU de ampliación de memoria 1750.
- Joystick Colossus.
- Turbo Cartridge.
- FastLoad.
No te preocupes si no entendiste ni la mitad de los acrónimos, esta serie es para vos.
Bienvenidos
En fin tenemos para divertirnos un buen rato y aprender cada día más de nuestra querida Commodore 64. Así que para todos los que siempre quisieron saber cómo funcionan esos maravillosos chiches que usa nuestra Commodore, así como para los que recién los están descubriendo ahora, les pido que me acompañen en esta nueva aventura.
Saludos
Carlinho de OsoLabs
En Video
Aquí puede encontrar el video Introductorio para la nueva serie.
Kartings y gaming: más allá de Mario Kart
¿Cómo comenzó la revolución de las carreras de kartings? Quizás haya sido en 1992 con Super Mario Kart de Nintendo, aunque otros apuntan a que inició antes, con el clásico de Atari de 1982, Pole Position, o incluso con Crashing Race, un juego de 1976 de Taito. En esta nota, un repaso por los orígenes y la historia de los “karting games” más importantes.
***
El loco, loco mundo de los kartings
Ningún género de videojuegos genera más pasiones y enemistades como el de kartings, también llamado “mascot racers”. En este tipo de juegos, los conductores se atacan entre sí mientras corren, con armas y power-ups que pueden recoger en las pistas, haciendo que todo se vuelva muchísimo más caótico, aleatorio y entretenido.
A menudo esas pistas también están llenas de obstáculos. Como resultado, conducir no se trata sólo de hacer giros cerrados y pisar fuerte en las rectas, sino también de evitar trampas y disparos, mientras te alineás contra los corredores enemigos para usar tu propio arsenal.
La mayoría de estos juegos utilizan franquicias existentes, normalmente videojuegos que comenzaron en otros géneros. El caso de estudio más claro es el de Mario Kart, que nació como un spin-off de la saga de Mario.
Apareciendo en la Super Nintendo en 1992, la serie ha tenido tanto éxito que tenemos versiones en todas las consolas y dispositivos portátiles de Nintendo posteriores, con al menos una entrega, con la excepción de Virtual Boy y Game Boy Color (los Mario Karts portátiles comenzaron a aparecer recién con la Game Boy Advance).
Actualmente existen más de 15 entregas de Mario Kart, siendo la más reciente el Mario Kart Live: Home Circuit (2020) para la Nintendo Switch. Una versión de realidad aumentada que utiliza coches que se conectan de forma inalámbrica a la consola, lo que permite a los jugadores experimentar una carrera de Mario Kart como si estuviera sucediendo en su propio living.
Crashing Race y el comienzo de una era
Pero vayamos un poquito más para atrás en el tiempo. Si bien todos los juegos de carreras de karts se remontan, por supuesto, a los inicios de los juegos de carreras en general, la primera aparición del combate como una mecánica de juego fue en el arcade de Taito de 1976, Crashing Race.
Los detalles son escasos, pero parece haber sido una carrera de dos jugadores para eliminar tantos otros autos como fuera posible.
Los juegos de carreras de arriba hacia abajo con peligros en la pista, power-ups temporales, misiles y/o diseños de pista más inventivos, como Super Cars (1990), Turbo Kart Racer (1991) y Micro Machines (1991), también pueden haber sido una influencia importante.
Incluso antes que ese trío, Pole Position (1982) de Namco no tuvo combate, pero sí fue relevante porque inspiró al juego de Super Nintendo F-Zero (1990), el primero en presentar al mundo el famoso “Modo 7”, una característica de hardware que escala y rota rápidamente sprites 2D (con transformaciones afines) para dar la ilusión de pistas 3D.
Después del éxito de F-Zero, Nintendo centró su atención en un juego de carreras para dos jugadores. El problema era que la Super Nintendo no podía manejar las altísimas velocidades del F-Zero en un juego multijugador que utilizara el Modo 7, por lo que utilizó kartings en lugar de autos de carreras futuristas.
Uno de los primeros prototipos tenía solo un elemento: se podían usar latas de aceite para hacer que el otro conductor hiciera un trompo. Luego, el equipo decidió poner a Mario en uno de los karts… y así siguió un juego de carreras con temática de Mario.
La llegada de Super Mario Kart
Al combinar imaginativamente los típicos elementos de los plataformeros (potenciadores, monedas, obstáculos que evitar, vidas limitadas, enemigos que intentan matarte) con los de los juegos de carreras, el equipo creativo termino por crear un género nuevo.
Chicos, Super Mario Kart (1992) no se parecía a nada que hubiésemos visto antes. Hoy se ve bastante viejuno, pero fue una revolución absoluta en su momento. Podías saltar a través de abismos, quedar aplastado bajo un golpe en el Castillo de Bowser y usar una gran variedad de potenciadores.
También había un emocionante modo de batalla uno a uno y una pista psicodélica infame (y endemoniadamente difícil) llamada Rainbow Road, que se convirtió en una estampa de la franquicia.
Por supuesto, como suele ocurrir con todos los juegos que definen un género, Mario Kart fue copiado hasta el harzato. El primer vivo fue Sega, sacando Sonic Drift para la Game Gear, que no ofrecía nada nuevo más allá de la posibilidad de jugar en una pantalla portátil.
Ubisoft, ni lento ni perezoso, sacó Street Racer para la SNES en 1994. El juego superaba técnicamente a todo lo que se hubiera visto hasta ese momento e incorporaba un modo adicional que funcionó como una suerte de precursor de Rocket League en el que competías para meter una pelota de fútbol en un arco.
Karts… karts everywhere!
El ataque de los clones no se detuvo ahí. Miracle Designs lanzó Atari Karts (1995) en la desafortunada consola Atari Jaguar. Apogee (famosa por Duke Nukem) publicó el adorable Wacky Wheels que yo amaba de chico, un juego de 1994 para DOS con gráficos y diseño que a primera vista parecían sacados directamente de Super Mario Kart.
Ninguno de estos clones tuvo un impacto real en la industria, por lo que le correspondió a Nintendo encontrar una forma interesante de hacer avanzar el floreciente género. Entonces entró a la competencia Mario Kart 64 (1996), una increíble secuela que se sigue manteniendo intacta hasta el día de hoy.
Es cierto que los diseños de los cursos a menudo parecían demostraciones técnicas. El nivel del desierto tiene a un tren que lo atraviesa, por ejemplo, pero todo el resto del nivel está medio vacío. Tenemos que recordar que, para ese momento, el 3D aún estaba en pañales.
Lo que no le podemos negar a Mario Kart 64 es el factor diversión. La Nintendo 64 se destacó por sus excelentes propuestas para cuatro jugadores. Y, en este sentido, meter carreritas en modo multijugador era tremendamente divertido.
Kartings y aventuras con Diddy
Los talentosos muchachos de Rare pronto le demostraron a Nintendo cómo evolucionar realmente al género: Diddy Kong Racing (1997) no fue un simple spin-off de Donkey Kong Country; sigue siendo, hasta el día de hoy, uno de los mejores exponentes del género.
Mientras que Mario Kart se deleitaba con la suerte y el caos, DKR era más un juego de habilidad y estrategia que incluía un muy copado modo aventura para uno o dos jugadores. Y, lo que es todavía más memorable, ofrecía la posibilidad de elegir entre tres tipos de vehículos.
Algunas pistas requerían un vehículo específico, pero la mayoría se podían abordar en el automóvil, avión o aerodeslizador que uno eligiera, y las tácticas, rutas y posibles atajos cambiaban en consecuencia. ¡Ningún otro juego similar ha desafiado las convenciones del género con tanta audacia!
El género se llenó de propuestas muy rápidamente con el cambio de siglo. ¿Me creen si les digo que más de veinte juegos de kartings aparecieron en todas las plataformas entre 1999 y 2001? La mayoría eran malardos, genéricos y súper olvidables: teníamos el del Pájaro Loco, Mickey Mouse, los Looney Tunes, South Park, los Muppets, los personajes de Nickelodeon, etc.
La mayoría de ellos eran terribles y se manejaban peor que un oxidado carrito de compras. Sólo uno logró impulsar realmente al género. ¿Quién habría dicho que el Crash Team Racing (1999), spin-off de Crash Bandicoot de Naughty Dog, sería tan bueno?
Crash Team Racing: el único héroe en esta historia
CTR se manejaba perfecto y se veía mejor todavía. La PlayStation tuvo finalmente un buen juego para competir con Mario Kart 64. En la opinión de este humilde servidor, Crash Team Racing es incluso mejor.
El juego de kartings de Crash tomó prestado el modo aventura de Diddy Kong Racing para contar una historia muy tonta sobre cómo salvar al mundo de un extraterrestre que quería convertir la Tierra en un estacionamiento, pero presentó un sistema de deslizamiento mucho más sofisticado.
El gaming mobile y el futuro de los kartings
Por otro lado, el gaming mobile también tuvo sus exponentes. El primer juego de kartings destacado que llegó a los teléfonos es sorprendentemente anterior al iPhone. MGS Karting fue lanzado en 2002 para los Nokia Serie 60. Tenía gráficos 3D simples pero atractivos, varios corredores seleccionables, una docena de pistas, 10 potenciadores, multijugador Bluetooth y hasta modos de torneo y contrarreloj.
Mientras tanto, en las tierras de Nintendo, Mario Kart 7 (2011) puso la serie en 3D estereoscópico e introdujo vehículos transformables. A mitad de una carrera, si conducías por una rampa especial, tu karting se metamorfoseaba en un planeador o en un vehículo submarino durante un breve período.
También podías construir tu propio vehículo a partir de diferentes partes, una característica que se vio por primera vez en el olvidado (pero genial) Lego Racers de 1999.
Sin embargo, su característica más fuerte fue un regreso concentrado a pistas estrechas y relativamente pocos rivales en la pista, lo que ayudó a devolverle la precisión al juego, que era la piedra angular del Mario Kart original.
Palabras finales
Más allá de estos títulos mencionados, ya no hay mucho más para decir sobre los videojuegos de kartings. El desarrollo de consolas es demasiado caro hoy en día para que se justifiquen las propuestas genéricas.
Sin embargo, todavía hay un lugarcito para el género, como lo demuestra el éxito de Mario Kart 8. Todavía sigue siendo el juego de la saga más vendido y ofrece mucha diversión a pesar de su continua dependencia en la suerte.
¿Y ustedes? ¿Cuál es su juego de kartings favorito? Y lo que es más importante: ¿se van a animar al primero torneo de Mario Kart 64 que propone Espacio TEC?
¡Nos leemos!
***
Si les gustó esta nota, recomienden a sus amigos. Y sino les gustó, le avisan a sus enemigos. ¡Recuerden que pueden apoyar a Espacio TEC subscribiéndose al Club Pixel o aportando con un cafecito!
Luciano “It´s a me” Sívori
Podés seguirme por en Instagram y en Facebook. También tengo este blog de vicios personales.