En esta ocasión vamos a estudiar uno de los grandes deseos que surgieron en los 80 para usar al máximo la Commodore 64, El Brazo Robot
Vamos a estudiar que hacía, como funciona por dentro, que circuitos tenía y cómo lograr conectar una Commodore con un circuito casero que vamos a diseñar para que funcione nuestro brazo Robot.
Continuar leyendo “Los Chiches de la Commodore 64 – Episodio 3 – El Brazo Robot”Vamos a empezar esta serie con una descripción del CPU 6502, estudiando para qué sirve cada patita de este chip (que básicamente es el pin out) y cómo funciona su arquitectura interna. Vamos a estudiar que registros tiene y para qué sirven. Luego vamos a seguir contando cómo recrear esta placa PCB desde cero y terminaremos con un experimento que nos permitirá ver nuestra primera instrucción del 6502 ejecutándose.
En esta ocasión vamos a prender varios leds imitando las luces de KIT el auto fantástico usando el puerto de usuario de la Commodore 64 para esto vamos a utilizar como Chiche un User Port Breakout Board.
Estudiaremos que es esta placa, como funciona, cómo conectar un led y escribir un programa en Basic para prenderlo y apagarlo y finalmente cómo conectar una barra de leds y ver las luces estilo auto fantástico.
Continuar leyendo “Los Chiches de la Commodore 64 – Episodio 2- Luces Auto fantástico con un UserPort Breakout Board”Continuamos este estudio comparativo del 6502 vs el 6510 esta vez estudiando qué son las interrupciones.
Vamos a estudiar qué son las interrupciones, los distintos tipos que poseen los procesadores 6502 y 6510, en que pines se encuentran, cómo responde el procesador a cada una de ellas y cuál es la mejor forma de diseñar un programa para qué puedan ser utilizadas para hablar con los periféricos.
Continuar leyendo “6502 vs 6510 Parte 12 – Como funcionan las interrupciones”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,
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.
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
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!
Hay 4 instrucciones que utilizamos para enviar y retirar información al stack. PHA, PLA, PHP, PLP
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:
Esto graba en memoria (en la sección del stack) lo que teníamos en el acumulador
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
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.
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.
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:
Esto graba en memoria (en la sección del stack) lo que teníamos en el acumulador.
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
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.
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:
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:
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:
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:
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.
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.
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
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
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
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
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.
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.
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
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
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:
A continuación les dejo los links a los artículos anteriores de la serie
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.
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.
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
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.
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,
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 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.
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.
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
Con la información que ya tenemos de interpretar cómo se hace una lectura encaremos la escritura de datos en la memoria.
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.
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.
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
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.
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
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:
Continuamos este estudio comparativo del 6502 vs el 6510 conectando un LCD de 16 caracteres x 2 líneas y programándolo con un mensaje. Vamos a estudiar cómo conectar un VIA 6522 y un CIA 6526 al lcd HD4470U de Hitachi y utilizando nuestro 6502 y nuestro 6510 mostrar el texto “OsoLabs” en el display en dos maquetas breadboard simultáneas.
Nuestro principal display es el LCD de Hitachi el mismo posee el siguiente diagrama esquemático.
Este LCD tiene 16 caracteres que se pueden mostrar en dos líneas y cada carácter puede ser de 5×8 o 5×10 puntos. Posee internamente el dibujo o font de varios tipos de caracteres que se eligen con valores correspondientes mayormente al ASCII. Estos caracteres incluyen el alfabeto tradicional, caracteres japoneses y símbolos. El LCD puede ser controlado por un procesador de 4 bits o uno de 8 bits, nosotros lo utilizaremos en modo 8 bits por estar usando la línea 6502/6510.
En cuanto a velocidad es compatible con un bus de datos de hasta 2Mhz, nosotros vamos a estar utilizando hasta 1Mhz el máximo de velocidad de nuestro 6510.
El siguiente esquema muestra y explica el pin-out
VSS (Ground): conexión a tierra de nuestro LCD
VDD: conexión a 5 Volts +
VE: Pin de contraste, se conecta normalmente a un potenciómetro en su pin de polo y el otro pin va directo a tierra.
Register Select RS: Nos permite elegir si escribir al Instruction Register usando el valor 0 o al Data Register usando el valor 1
Read/Write : Permite escribir si el valor es cero y leer si el valor es 1
Enable: Comienza la lectura o escritura sacando los pines DB7 a DB0 de su modo de triestado.
DB7 a DB0: Bus datos para escribir o leer. En el modo de operación de 4 bits sólo se usando los pines DB7 a DB4
A : Ánodo (pin positivo +5 Volts) para encender la luz de backlight
K: Cátodo (pin negativo 0 Volts) para encender la luz de backlight
Hay tres pines que funcionan para poder leer o escribir los registros internos y la pantalla de nuestro LCD, estos son RS, RW y E. En la siguiente Tabla especificamos cómo realizar cada operación.
RS = 0 /R/W = 0 E=1 permiten enviar una instrucción al LCD, escribiendo el instruction register
RS = 1 /R/W = 0 E=1 permiten enviar datos al LCD, escribiendo el data register.
Generalmente el valor del pin Enable se usa como un Toggle o pulso y este se dispara cuando ya tengo todos los datos de los demás pines (RS, RW y DB7 a DB0) estables y con valores correctos.
El LCD posee instrucciones internas que sirven para desde limpiar la pantalla o elegir el ancho de los caracteres hasta encender o apagar el display, las mismas estan explicadas en la siguiente tabla:
El formato de estas instrucciones es:
Valor del pin RS,
Valor del pin /R/W,
Una cantidad de ceros y luego un 1 para identificar la instrucción en los pines DB7 a DB0,
El resto después del 1 que identifica la instrucción, son los parámetros de la misma.
Por ejemplo la instrucción Display on/off control que controla tres funciones de nuestros display está codificada de la siguiente forma:
| RS | /R/W | DB7 | DB6 | DB5 | DB4 | DB3 | DB2 | DB1 | DB0 |
| 0 | 0 | 0 | 0 | 0 | 0 | 1 | D | C | B |
El valor RS es cero para indicar que estamos escribiendo al instruction register del LCD
El valor /R/W es cero para indicar que es una escritura
La instrucción está indicada por los pines DB7 a DB3 y es 00001
El pin DB2 es un parámetro que indica si prender o apagar el display
El pin DB1 es un parámetro que indica si está prendido o no el cursor
El pin DB0 es un parámetro que indica si el cursor parpadea o no
Si quisiéramos que el display esté prendido, mostrando el cursor y que este no parpadee enviaríamos la siguiente secuencia
| RS | /R/W | DB7 | DB6 | DB5 | DB4 | DB3 | DB2 | DB1 | DB0 |
| 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 |
Para poder empezar a enviar letras a nuestro LCD primero debemos inicializarlo, el datasheet nos indica una secuencia de inicialización que vamos a analizar.
El primer paso es conectar al suministro eléctrico de 5 volts a nuestro LCD, para esto no necesitamos ninguna instrucción solo conectar correctamente los cables.
El segundo paso es enviar la instrucción Function Set que en este caso elige la operación del display como 8 bits (usa todos los pines de DB7 a DB0), una sóla línea y formas de caracteres de 5×8 puntos.
| RS | /R/W | DB7 | DB6 | DB5 | DB4 | DB3 | DB2 | DB1 | DB0 |
| 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | N/A | N/A |
El tercer paso es enviar la instrucción Display on/off control donde indicamos prender el display, mostrar el curso y que este no parpadee.
| RS | /R/W | DB7 | DB6 | DB5 | DB4 | DB3 | DB2 | DB1 | DB0 |
| 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 |
El cuarto paso y último paso en la inicialización es enviar la instrucción Entry Mode Set para decidir cómo es que vamos a mostrar los caracteres en este caso decidimos que después de mostrar una letra corra el cursor un lugar a la derecha
| RS | /R/W | DB7 | DB6 | DB5 | DB4 | DB3 | DB2 | DB1 | DB0 |
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 |
Finalmente ya estamos listos para escribir nuestra primera letra.
Al tener preparado ya nuestro LCD para recibir nuestra primera letra, el mismo espera la información en código ascii explicitado en los pines del DB7 al DB0 por ejemplo, a continuación la tabla de caracteres del lcd.
Para escribir la letra H mayúscula por ejemplo vemos que la combinación es 0100 1000 com lo que deberemos enviar estos valores:
| RS | /R/W | DB7 | DB6 | DB5 | DB4 | DB3 | DB2 | DB1 | DB0 |
| 1 | 0 | 0 | 01 | 0 | 0 | 1 | 0 | 0 | 0 |
El valor RS es 1 para indicar que estamos escribiendo al data register del LCD
El valor /R/W es 0 para indicar que es una escritura
En los pines DB7 a DB0 espera el dato a escribir en memoria y es 01001000
La Commodore 64 posee dos CIA 6526 pero ninguno está conectado a un LCD, utilizando al chip VIC2 y un modulador de RF la Commodore puede comunicarse con monitores con su salida de video y a televisores con su salida RF, en una futura entrega vamos a desarrollar el funcionamiento del chip VIC2.
Para poder estudiar visualmente como conectar el LCD a nuestros procesadores y CIAs/VIAs y como programarlo en assembler para mostrar un mensaje les dejo esta video que complementa al artículo.
LCD con 6510/CIA y 6502/VIA – 6502 vs 6510 Parte 9
A continuación les dejo algunos links donde profundizar el tema:
VIDEOS
Video de la serie 6502 vs 6510 Parte 9 – LCD con 6510/CIA y 6502/VIA
LCD con 6510/CIA y 6502/VIA – 6502 vs 6510 Parte 9
Aquí tienen acceso a toda la serie:
6502 vs 6510 estudio detallado y comparación
Aqui tienen acceso a todos los artículos publicados en Espacio Tec
A continuación les dejo los links a los artículos anteriores de la serie
Parte 3 – Codeando a Mano la Primera Instrucción de Código Máquina
Parte 4 – Primer Programa desde EEPROM
Parte 5 – I/O Pins del Procesador
Parte 7 – VIA MOS 652 Interfaz con periféricos
Parte 8 – MOS 6526 CIA Interfaz con periféricos reloaded
PAPERS
HD44780U (LCD-II), (Dot Matrix Liquid Crystal Display Controller/Driver)
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:
Hola, en esta entrega vamos a estudiar el MOS 6526 también conocido como CIA o complex adapter interface. Son los famosos chips que usa la Commodore 64 entre el procesador y el teclado, ports de usuario y ports de joystick (control port 1 y 2) entre otras conexiones.
Los procesadores tienen como características ser muy rápidos, estamos hablando de 1 millón de operaciones o ciclos de reloj por segundo en el caso del 6510. Un periférico como el datasette o la disquetera está en el orden de 300 bytes por segundo de transferencia.
Si el procesador tuviera que esperar cada acceso de información disponible sería toda la computadora extremadamente lenta, por eso ponemos un chip en el medio para que medie entre el procesador y los periféricos.
Este chip tiene como función recibir la información que el 6510 le envía, mantenerla disponible y pasarla al periférico cuando este la requiera; también recibir la información desde el periférico, mantenerla y avisar al procesador que tiene información disponible para él. De esta forma el bus de datos se mantiene libre hasta que el procesador tenga que comunicarse con el periférico.
Los pines, VCC, RS0 a RS3, /RES, DB0 a DB7, PHI2, R/W, /IRQ presentan funcionamientos similares al VIA MOS 6522, pero primero vamos a dar detalles de funcionamiento de los pines presentes sólo en el CIA. Cuando en el diagrama un puerto comienza con una / leer como BARRA y significa que este pin es Active Low.
/PC y /FLAG se utilizan juntos para realizar un handshake entre el procesador y el CIA, también el pin /FLAG sólo ,puede utilizarse para recibir una señal de otro 6526 y quedar marcado como flag de interrupción encadenando ambos CIA. El pin /PC es output y pin /FLAG es input siempre.
TOD este pin requiere una conexión externa de 60Hz o 50Hz con un nivel programable de TTL para mantener el reloj interno del CIA.
CNT puede recibir pulsos para usar como un contador en Timer A o Timer B o ser output y escribir pulsos del timer A o B.
SP Es un pin de input o output donde los BITS del puerto serial del chip son escritos. El Serial Data Register se conecta con el Shift Register y cuando recibe un pulso en el pin CNT hace un shift out del Shift Register un bit a la vez en el pin SP, esto lo hace por 8 pulsos o 8 bits del registro momento en el cual se genera una interrupción para avisar que se pueden enviar más datos.
/CS el CIA posee un sólo pin que funciona como Chip Select, al estar en Low el chip responde a los datos en DB0 a DB7
Aquí repasamos los pines con funcionamiento similar al VIA
VSS y VCC/VDD son los pines de Ground y 5 Volts respectivamente
PA0 a PA7 Port Address A: son pines de datos bidireccionales (input y output) para el primer puerto de periféricos el A, el periférico se comunica con el 6526 por esos pines.
PB0 a PB7 Port Address B: son pines de datos bidireccionales (input y output) para el segundo puerto de periféricos el B, el periférico se comunica con el 6526 por esos pines.
RS0 a RS3 son pines que permiten seleccionar qué registro interno del CIA se accede cuándo el procesador lee o escribe los puertos de datos D0 a D7
RESB puerto de reset, el 6526 necesita de un reset cuando el 6510 es prendido por primera vez o pasa por un reset, en este pin recibe la señal. (Active Low).
DB0 a DB7 Data Bus: en estos pines el procesador 6510 se comunica con el 6526 para leer o escribir datos y acceder a cualquiera de los registros internos del CIA.
PHI2 en este pin se recibe la señal de reloj que es la misma que tiene el 6510, al estar diseñado el 6526 para trabajar con estos procesadores todo el timing interno funciona coordinadamente con toda la línea 6500.
RWB en este pin específico, se indica si se está realizando una lectura (high) o una escritura (low) a los pines D0 a D7.
IRQB este pin cuando está en estado low crea una interrupción al procesador para que este tome información del puerto de periférico que corresponde.
Los registros varían para reflejar la diferencia en algunas funciones con respecto al VIA que ya estudiamos, el CIA posee 16 registros diferentes aquí los detalles de algunos de ellos.
Este chip posee 16 registros internos que permiten entre otras funciones:
Si queremos usar por ejemplo los puertos del PB0 al PB7 como output para darle información al periférico debemos primero seleccionar el Data Direction Register B. El mismo se selecciona a través de los puertos RS0 a RS3 en este caso poniendo los pines con los valores de 0v o Ground (<0.4 volts) en caso de tener un 0 en la tabla siguiente o 5v en caso de tener un valor 1:
RS3= 0 RS2= 0 RS1= 1 RS0= 1
Esto corresponde con el valor 3 del Register Number (0011), nótese que es diferente al VIA que espera un valor de 0010 o sea de 2 para el data register B.
Luego de esta selección el procesador debe escribir el valor deseado a través de los pines D0 a D7. Para poner un pin en OUTPUT el valor deberá ser 1 y en INPUT deberá ser cero. Si quisiera poner todos los pines como output el procesador escribirá 1111 1111.
Luego el procesador debe enviar la información que quiere mandar de output al periférico para esto se utiliza el registro Output Register. En nuestro caso usaremos el Output Register B para seleccionarlo en los pines RS3 a RS0 poner los siguientes valores:
RS3= 0 RS2= 0 RS1= 0 RS0= 1
Que corresponden al valor de registro uno (0001), fijense que es diferente al valor usado en el VIA que era de cero (0000).
Si quisiera tener como valores de Salida en PB7 a PB0 los valores 10101010 debería escribir estos mismos en el registros enviando esta información por los pines D7 a D0.
Estos puertos soportan input latching, que es una característica por la cual el puerto conserva el valor de input que recibió desde el periférico aunque el mismo no refresque la señal. Los datos se mantienen (aunque cambien los valores en los pines PB0 a PB7) mientras el flag CB1 de interrupción este set y se borran cuando este flag es desactivado.
El CIA puede hacer handshaking usando el pin /PC como output y el /FLAG como input. /PC va a ir a valor cero o low por un ciclo de tiempo P después de una lectura o escritura del Puerto B. Esta señal puede usarse para indicar “data ready” en el puerto B o “data accepted” en el mismo puerto dependiendo si se trató de una lectura o una escritura respectivamente.
Se puede hacer handshake en transferencia de 16 bits usando ambos puertos A y B siempre leyendo o escribiendo primero al puerto A.
Cualquier señal low al pin /FLAG va a disparar una interrupción del bit FLAG, se puede usar como un puerto genérico para recibir interrupciones o se puede conectar al puerto /PC de otro CIA para recibir el low de ese pin y saber que sucedió un handshake en el puerto B de ese otro CIA (CIA 2 por ejemplo)
Los timers A y B del CIA pueden ser arrancados y parados a voluntad usando el control register A o el B respectivamente.
También como funciones adicionales presenta un reloj Time of Day (TOD). El TOD es un reloj de 24 horas con una graduación de una décima de segundo. Está organizado en 4 registros (que se seleccionan con los pines RS0 a RS3), décimas de segundo, segundos, minutos y horas. El mismo necesita en el pin TOD la conexión con un clock de 60 Hz o 50 Hz.
Otra función adicional es contar los pulsos del pin de reloj recibidos en PHI2 en TIMER A o TIMER B o los pulsos recibidos en el pin CNT.
El CIA también posee un puerto serial sincrónico de 8 bits con un buffer de 8 bits. Un bit de control selecciona si se va a recibir un input o output.
En modo input los datos recibidos en el pin SP se ingresan a un shift register cuando se recibe una transición de low a high en el pin CNT. Luego de 8 CNT los datos en el shift register se copian al Serial Data Register y una interrupción es generada. El procesador va a leer los 8 bits contenidos en el Serial Data Register a través de los pines D0 a D7.
En modo output el TIMER A se usa como generador de baudios. Los datos se envían por el pin de SP. La tasa máxima de transferencia en baudios es PHI2 dividido por 4. La transmisión va a empezar después de escribir al Serial Data Register, la señal del TIMER A aparece como pulsos de output en el pin CNT y los datos se escriben al Shift Register y luego saldrán uno a uno por el pin SP cuando un pulso CNT ocurra. Luego de 8 pulsos CNT se genera una interrupción para indicar que se pueden mandar más datos.
Si el procesador carga datos en el Serial Data Register antes de que se produzca la interrupción cuando esta se produzca y se transmitan los datos el Shift Register va a ser cargado automáticamente luego de la transmisión. Si el procesador se mantiene en forma constante 1 byte adelantado al consumo del Shift Register la transmisión será continua.
Los datos son transmitidos con el Most Significant Bit primero.
La Commodore 64 posee dos CIA conocidos en el mother como U1 y U2, aquí podemos ver su conexión esquemática con otras partes de la computadora:
Las funciones de la CIA 1 incluyen el control del teclado, control de dos puertos de joystick, el control de los dispositivos tipo paddle (potenciómetro como para el Arkanoid) y la lectura de datos del datasette conectado al pin de Cassette RD.
Los 8 pines del Port A están seteados como input y conectados a los 8 conectores de columnas del conector de teclado CN1. Los pines del del Port B están seteados como inputs y conectados a los 8 conectores de filas del conector de teclado CN1 (20 pines machos).
Las cuatros direcciones del Control Port 2 (JOYB0, JOYB1 ,JOYB2 y JOYB3) y el pin de botón BTNB están conectadas al puerto A. Las cuatros direcciones del Control Port 1 (JOYA0, JOYA1 ,JOYA2 y JOYA3) y el pin de botón BTNB están conectadas al puerto B. Si están cruzados los A y los B !
Este posee dos funciones principales que son la conexión al puerto de Usuario, la conexión al bus serial de la commodore, conexión al puerto RS-232, la configuración del VIC (selección de la posición de la memoria interna) y el control de las interrupciones no enmascarables NMI.
El Port B está enteramente conectado al User Port al cuál también se conecta el pin 2 del Port A. El Port A en sus conexiones desde el pin PA7 a PA3 están dedicados al puerto serie.
Para acceder a los CIA vamos a usar los puerto RS3 a RS0 que están conectados a los puertos de direccionamiento A3 a A0 del 6510. De esta forma podemos acceder a los registros del CIA 1 con las direcciones de DC00 a DC0F y al CIA 2 con las direcciones de DD00 a DD0F
Los pines de chip enable de cada CIA (recordemos que esperan un resultado de 0 volts o LOW) están conectados a la PLA ( a través del pin 1 de I/O) y a dos chips 74LS239 que son decodificadores y entre ambos conectan la CIA, el VIC y el SID.
El chip select no va a funcionar a menos que también se reciba la señal high del clock Phi2 al mismo tiempo.
El CIA responde al 6510 cuando el ciclo del reloj PHI2 va de low a high y a low nuevamente , esto toma aproximadamente unos 1000 nanosegundos. Durante ese tiempo el pin de CS (chip select) es mantenido en Low y si el pin de R/W es high ocurre una lectura y si es low ocurre una escritura, los pines RS reciben una dirección a un registro interno con el databus dando o recibiendo datos.
Teniendo en cuenta el diagrama de timing para que los datos sean válidos y por ejemplo puedan ser leídos, el 6510 tiene acceder al CIA mientras el pin CS esté en low, el registro interno sea direccionado por los register select RS3 a RS0, PHI2 debe estar high y los datos tienen que ser válidos (mantenidos correctamente en el tiempo).
Nuestros dos CIAs manejan teclado, joystick, timers, lectura de datasette, puerto de usuario, paddles y comunicaciones seriales.
Para ver visualmente como conectar un CIA al 6510 y setearlo como output y también en su función de uso de reloj les dejo como siempre un video en detalle de la serie.
En este vamos a ver cómo se conectan los pines, que código máquina escribir para comunicarnos con los registros internos y un ejemplo de output.
6526 CIA Complex Interface Adapter Programado – 6502 vs 6510 parte 8
A continuación les dejo los links a los artículos anteriores de la serie
6526 CIA Complex Interface Adapter Programado – 6502 vs 6510 parte 8
Video para profundizar el saber sobre la CIA
A continuación les dejo algunos links donde profundizar el tema
Libro Machine Language for the Commodore 64,128, y otras Computadoras Commodore Anexo I
Commodore 64 clock using the CIA TOD clock (from “Compute!”) | Retro64
vasm portable and retargetable assembler
Reemplazo Moderno de la CIA
J-CIA64 6526/8521 Replacement for Commodore 64/128/1570/1571 – Retro 8bit Shop
Referencias de velocidades de transferencias de periféricos:
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:
Hola, en esta entrega vamos a estudiar que usan los procesadores para hablar con los periféricos (datasette, disquetera) sin tener que estar constantemente congelados esperando una respuesta de ellos.
Los procesadores tienen como características ser muy rápidos, estamos hablando de 1 millón de operaciones o ciclos de reloj por segundo en el caso del 6510. Un periférico como el datasette o la disquetera está en el orden de 300 bytes por segundo de transferencia.
Si el procesador tuviera que esperar cada acceso de información disponible sería toda la computadora extremadamente lenta, por eso ponemos un chip en el medio para que hable con el procesador y los periféricos.
Este chip tiene como función recibir la información que el 6510 le envía, mantenerla y pasarla al periférico y también recibir la información desde el periférico, mantenerla y avisar al procesador que tiene información disponible para él. De esta forma el bus de datos se mantiene libre hasta que el procesador tenga que comunicarse con el VIA.
El MOS 6522 conocido también como VIA es un chip que nos permite tener comunicación con dos puertos para periféricos (A y B) que manejen hasta 8 bits de información en el canal de datos cada uno, la misma cantidad que manejan el 6502 y el 6510 en su bus de datos.
Cada puerto tiene capacidad de mantener la información recibida por el periférico (input latching) y cada bit de los puertos puede ser seleccionado como input o output, lo que permite una comunicación directa y bidireccional entre el procesador y el periférico.
Este chip posee 16 registros internos que permiten entre otras funciones:
El VIA posee 40 pines que permiten desde realizar direccionamiento, seleccionar o no el chip, hacer un reset, interrumpir al procesador y comunicarse con los periféricos. Cuando algún puerto tenga como última letra una B larga, en este diagrama significa BARRA, leer como si tuviera una barra encima o sea que el pin es Active Low, se activa cuando el voltaje va a cero (<0,4v en este caso)
VSS y VDD/VCC son los pines de Ground y 5 Volts respectivamente
PA0 a PA7 son pines de datos bidireccionales (input y output) para el primer puerto de periféricos el A, el periférico se comunica con el 6522 por esos pines.
PB0 a PB7 son pines de datos bidireccionales (input y output) para el segundo puerto de periféricos el B, el periférico se comunica con el 6522 por esos pines.
CB1 y CB2 son pines de control del puerto B permitiendo cosas como decidir en base a sus input si interrumpe o no al procesador
CA1 y CA2 son pines de control del puerto A permitiendo cosas como decidir en base a sus input si interrumpe o no al procesador
RS0 a RS3 son pines que permiten seleccionar que registro interno del VIA se accede cuándo el procesador lee o escribe los puertos de datos D0 a D7
RESB puerto de reset, el 6522 necesita de un reset cuando el 6502 es prendido por primera vez o pasar por un reset en este pin recibe la señal. (Active Low).
D0 a D7 en estos pines el procesador 6502/6510 se comunica con el 6522 para leer o escribir datos y acceder a cualquiera de los registros internos del VIA.
PHI2 en este pin se recibe la señal de reloj que es la misma que usa el 6502, al estar diseñado el 6522 para trabajar con estos procesadores todo el timing interno funciona coordinadamente con esta línea de procesadores.
CS1 y CS2B ambos pines son usados para seleccionar al chip (pines de chip enabled) cuando el CS1 es high y el CS2 es low el chip sabe que se están comunicando con él y lee o escribe en el bus de datos respectivamente.
RWB este pin específico se está realizando una lectura (high) o una escritura (low) a los pines D0 a D7.
IRQB este pin cuando está en estado low crea una interrupción al procesador para que este tome información del puerto de periférico que corresponde.
La función de input output del VIA esta programada a través de los registros internos del chip.
Si queremos usar por ejemplo los puertos del PB0 al PB7 como output para darle información al periférico debemos primero seleccionar el Data Direction Register B. El mismo se selecciona a través de los puertos RS0 a RS3 en este caso poniendo los pines con los valores de 0v o Ground (<0.4 volts) en caso de tener un 0 en la tabla siguiente o 5v en caso de tener un valor 1:
RS3= 0 RS2= 0 RS1= 1 RS0= 0
Esto corresponde con el valor 2 del Register Number (DDR B). Luego de esta selección el procesador debe escribir el valor deseado a través de los pines D0 a D7. Para poner un pin en OUTPUT el valor deberá ser 1 y en INPUT deberá ser cero. Si quisiera poner todos los pines como output el procesador escribirá 1111 1111.
Luego el procesador debe enviar la información que quiere mandar de output al periférico para esto se utiliza el registro Output Register. En nuestro caso usaremos el Output Register B para seleccionarlo en los pines RS3 a RS0 poner los siguientes valores:
RS3= 0 RS2= 0 RS1= 0 RS0= 0
Que corresponden al valor de registro cero. Si quisiera tener como valores de Salida en PB7 a PB0 los valores 10101010 debería escribir estos mismos en el registros enviando esta información por los pines D7 a D0.
Estos puertos soportan input latching, que es una característica por la cual el puerto conserva el valor de input que recibió desde el periférico aunque el mismo no refresque la señal. Los datos se mantienen (aunque cambien los valores en los pines PB0 a PB7) mientras el flag CB1 de interrupción este set y se borran cuando este flag es desactivado. Para controlar si usamos o no input latching o si los pines solo reflejan el valor eléctrico que poseen en el instante usamos el registro C, Peripheral Control Register. Lo mismo aplica para el Port A.
El VIA también provee dos timers y un Shift Register de paralelo a serial / serial a paralelo.
El Timer 1 es un contador de cuenta regresiva de 16 bits que se carga usando los registros 4 y 5 donde primero se carga la información en dos registros de tipo latch, recordando el chip la misma y luego se pasa la información a los registros del contador. Cuando este llega a cero se produce una interrupción y se pone a ground el pin de IRQB.
El Timer 2 es un contador por intervalo en el cual desde que se carga su valor inicial comienza a contar o puede también contar los pulsos recibidos en el pin PB6 del Puerto B.
Los modos de ambos Timers se setean con el registro B el Auxiliar Control Register.
El shift register es un registro que va a rotar los 8 bits que posee a través del pin CB2 o puede cargarse (input) a través del pin CB1 o también vaciarse (output) a través del mismo pin CB1. Muy útil para hacer conversiones serial/paralelo paralelo/serial.
El timing del shift register puede ser controlado por el Timer 2, el reloj del sistema PHI2 o un reloj externo.
Commodore usó el VIA en diferentes productos no así en la Commodore 64 donde uso el CIA o MOS 6526 que revisaremos en un próximo artículo. Podemos ver a continuación los motherboard del VIC 20 y la disquetera 1541 donde sí fue utilizado.
Para ver visualmente como conectar un VIA al 6502 y al 6510 les dejo como siempre un video en detalle de la serie. En este vamos a ver cómo se conectan los pines, que código máquina escribir para comunicarnos con los registros internos y un ejemplo de output utilizando Leds. Todo programado directamente en código máquina.
6522 VIA Versatile Adaptive Interface – 6502 vs 6510 parte 7
A continuación les dejo los links a los artículos anteriores de la serie
Parte 3 – Codeando a Mano la Primera Instrucción de Código Máquina
Parte 4 – Primer Programa desde EEPROM
Parte 5 – I/O Pins del Procesador
A continuación les dejo algunos links donde profundizar el tema
Video de la serie 6502 vs 6510 Parte 7 – El VIA
MOS 6522 Versatile Adaptive Interface VIA – 6502 vs 6510 parte 7
Libros y artículos
Libro Machine Language for the Commodore 64,128, y otras Computadoras Commodore Anexo I
MCS6522 VERSATILE INTERFACE ADAPTER
W65C22 (W65C22N and W65C22S) Versatile Interface Adapter (VIA) Datasheet
Commodore 64 clock using the CIA TOD clock (from “Compute!”) | Retro64
Referencias de velocidades de transferencias de periféricos:
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:
