Continuamos este estudio comparativo del 6502 vs el 6510 en este caso creando nuestro primer programa en código máquina y grabándolo en una EEPROM, de esta forma vamos a indicarle al procesador que lea y ejecute el programa desde memoria.
Les dejo el link al articulo anterior en la serie, y al final como siempre los links a los artículos de la misma.
Parte 3 – Codeando a Mano la Primera Instrucción de Código Máquina
Qué es una EEPROM
Para poder avanzar en nuestro estudio de los procesadores vamos crear un programa en código máquina que vamos a almacenar en una memoria de sólo lectura. Esto es una eeprom Electrically Erasable Programable Read Only Memory, la cuál vamos a grabar fuera de nuestro breadboard utilizando un grabador de eeprom que el procesador va a tratar como si fuera una memoria de sólo lectura, leyendo instrucciones y datos de la misma pero nunca escribiendolos.
En nuestro caso el chip a utilizar es el AT28C256 de ATMEL. Este chip posee 32768 registros de 8 bits cada uno, por lo que podemos tener hasta 32k bytes de información en este tipo de memorias. El 256K se refiere a 256 K bits que son 32k Bytes (256/8).
Pinout de AT28C256
Este chip viene en formato DIP (Dual Inline Pins) de 28 pines (que parecido a las ROMs del Commodore, ¿capáz que podemos usarlas para algo más adelante ….?)
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
Cómo leer y cómo escribir
Para poder leer o escribir tenemos que realizar una combinación de 3 pines /WE /OE /CE
Lectura
Para realizar una lectura deberemos primero poner en el bus de direccionamiento el address de la memoria que queremos acceder y acto seguido poner los pines:
/WE en +5 Volts (High)
/OE en 0 Volts (Low)
/CE en 0 Volts (Low)
En el bus de Datos tendremos la información asociada a la dirección que pusimos en el address bus..
Escritura
Para realizar una escritura deberemos primero poner en el bus de direccionamiento el address de la memoria que queremos escribir, luego en el bus de datos la información a grabar y acto seguido poner los pines:
/WE en 0 Volts (Low)
/OE en +5 Volts (High)
/CE en 0 Volts (Low)
El /WE o el /CE deberá ser un pulso.
Cómo seleccionamos la memoria desde el procesador
El 6502 y el 6510 pueden direccionar hasta 65536 registros de 8 bits cada uno o 64K como nos gusta llamarlos. Esto nos dejaría utilizar hasta 2 chips EEPROM de 32k cada uno.
Las direcciones que maneja el procesador van desde la $0000 hasta la $FFFF, siempre en hexadecimal como indicamos al anteponer el signo pesos. Si quisiéramos repartir estas direcciones entre 2 chips podríamos asignar de $0000 a $7FFF para el primero y de $8000 a $FFFF para el segundo.
Vamos a ver como se ven estas direcciones en binario para observar si podemos sacar algún patrón útil.
| Espacio de Direccionamiento | Hexa | Binario |
| Inferior | $0000 | 0000 0000 0000 0000 |
| Inferior | $0001 | 0000 0000 0000 0001 |
| Inferior | ……………… | ……………………… |
| Inferior | $7FFE | 0111 1111 1111 1110 |
| Inferior | $7FFF | 0111 1111 1111 1111 |
Podemos observar que el primer bit en Binario es cero. Para direccionar todos los registros de la eeprom necesitamos 15 pines del A0 al A14 con lo que nos sobra el pin A15. Para poner en modo de lectura solamente al chip podríamos entonces conectar en forma permanente los pines:
/WE en +5 Volts (High)
/OE en 0 Volts (Low)
Y el pin /CE podemos conectarlo directamente al pin A15 así cuando esté en 0 Volts (Low) el chip eeprom estará seleccionado y podremos leerlo. Vayamos ahora a ver el segundo espacio de direccionamiento.
| Espacio de Direccionamiento | Hexa | Binario |
| Superior | $8000 | 1000 0000 0000 0000 |
| Superior | $8001 | 1000 0000 0000 0001 |
| Superior | ……………… | ……………………… |
| Superior | $FFFE | 1111 1111 1111 1110 |
| Superior | $FFFF | 1111 1111 1111 1111 |
En este caso el pin A15 queda con un valor de 1 o +5 Volts (High) no podríamos conectarlo directamente al pin de /CE ya que no se activaría por ser Active Low el pin. Lo que deberíamos hacer es invertir el valor de 1 a 0 y propongo hacerlo con una compuerta NAND.
Una compuerta NAND tiene la siguiente tabla de verdad que es la opuesta a una compuerta AND.
| Input A | Input B | Resultado |
| LOW | LOW | HIGH |
| LOW | HIGH | HIGH |
| HIGH | LOW | HIGH |
| HIGH | HIGH | LOW |
Con lo que si conectamos en la misma compuerta NAND como input A la salida en +5 Volts (HIGH) del pin A15 y como input B también la salida en +5 Volts (HIGH) del pin A15 el resultado será un 0 Volts (LOW) que permitirá activar el pin /CE de chip enable.
Para esto podemos utilizar un clásico chip como ser el 74HC00 que posee cuatro compuertas NAND de dos inputs cada una.
Y así quedaría montado en un breadboard.
Primer Programa en Código Máquina
Nuestra eeprom tiene que tener grabada alguna información para que nos resulte útil, por lo que vamos a cargarle un programa en código máquina. En nuestro primer programa vamos a llenar toda la memoria con la instrucción EA, esta es la instrucción de no operación la cual le dice al procesador que no realice nada durante 2 ciclos de reloj.
Este número hexa EA se corresponde con el binario 11101010 la cual utiliza 8 bits, el procesador va a estar en el ciclo de búsqueda de instrucción leyéndolo de nuestra eeprom. Utilizando el siguiente programa python podemos generar un archivo binario que llena completamente las 32768 posiciones de memoria de 8 bits de nuestra memoria eeprom.
rom = bytearray([0xea] *32768) # crea un array de 32768 ea
with open(“rom004.bin”,”wb”) as out_file: # wb significa escribir archivo binario
out_file.write(rom)
Este programa al ser ejecutado con el comando:
$ python3 ./nombre_del_programa.py
Creará un archivo rom004.bin lleno de bytes EA, que podremos ver con el programa hexdump:
% hexdump -C rom004.bin
00000000 ea ea ea ea ea ea ea ea ea ea ea ea ea ea ea ea |…………….|
*
00008000
Todas las 32768 posiciones de memoria (del 0000 al 8000) están llenas con la instrucción de no operación EA. No es un programa muy útil pero si imita muy bien la codificación con resistencias de la instrucción EA hardcodeada en nuestro artículo anterior.
Cómo Se Graba una EEPROM
Ya que tenemos nuestro primer programa como un archivo binario de 32768 bytes, solo nos resta grabar el mismo en una EEPROM y esto se realiza con un grabador de eeproms. En este ejemplo vamos a usar un TL866 II Plus.
Este programador de eeprom es muy sencillo de utilizar a través del programa minipro, al mismo se le indica qué tipo de chip eeprom vamos a grabar y que archivo queremos grabar.
Antes de comenzar a grabar se inserta el chip eeprom en el zócalo zif y se conecta todo por usb a nuestra computadora.
En la siguiente imagen podemos ver como es el ciclo completo desde que ejecutamos el programa python hasta grabar la eeprom.
¿Y qué pasa entonces?
El procesador va a encender y buscar en las posiciones $FFFC y $FFFD la dirección de la primera instrucción a ejecutar ordenados como Low Byte y High Byte. Al haber grabado toda la memoria con la instrucción $EA encontrará con $EA en la posición de memoria $FFFC, luego irá a la posición $FFFD y cargará $EA.
$FFFC contiene $EA = %1110 1010
$FFFD contiene $EA = %1110 1010
Si lo ordenamos por los pines del address bus veríamos:
| A15 | A14 | A13 | A12 | A11 | A10 | A9 | A8 | A7 | A6 | A5 | A4 | A3 | A2 | A1 | A0 |
| 1 | 1 | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 1 | 0 | 1 | 0 |
El Pin A A15 es un 1 que a través de la compuerta NAND se transforma en 0 equivalente a 0 Volts o Low, y como está conectado al pin /CE nuestra EEPROM se activará.
Con esto cargará el Program Counter con la primera posición de nuestro programa ficticio que será $EAEA y buscará el código de la próxima instrucción a ejecutar que será EA ya que es lo único que tenemos en el bus de datos.
Esta ejecución durará dos ciclos de reloj y luego el program counter avanzará a EAEB y volverá a leer el bus de datos en búsqueda de la próxima instrucción que seguirá siendo EA y así continuará.
.
Segundo Programa en Código Máquina
Casi siempre queremos indicar en qué dirección de memoria comenzar el programa y vimos en un artículo anterior que al tener un reset el 6502 y el 6510 buscan la primera instrucción en las direcciones $FFFC para el low byte y $FFFD para el high byte.
Con una pequeña modificación podemos hacer que nuestro programa comience a ejecutar en por ejemplo la dirección $8000.
rom = bytearray([0xea] *32768) # crea un array de 32768 ea
#modificamos dos bytes de nuestro array de EAs
rom[0x7ffc] = 0x00 # low byte que va a ser leído como $FFFC con el contenido $00 para formar la dirección $8000
# 0x7ffd va a ser leído como FFFD por tel procesador ya que estamos usando A15 como chip enable pero la EEPROM solo tiene 15 pines hasta A14
rom[0x7ffd] = 0x80 # high byte que va a ser leido para formar la dirección $8000
with open(“rom005.bin”,”wb”) as out_file:
out_file.write(rom)
Creará un archivo rom005.bin lleno de bytes EA, pero que contiene la dirección $8000 en las posiciones $FFFC y $FFFD en formato low byte primero (little endian) que podremos ver con el programa hexdump:
% hexdump -C rom005.bin
00000000 ea ea ea ea ea ea ea ea ea ea ea ea ea ea ea ea |…………….|
*
00007ff0 ea ea ea ea ea ea ea ea ea ea ea ea 00 80 ea ea |…………….|
00008000
¿Y qué pasa entonces?
El procesador va a encender e ir a las posiciones $FFFC y $FFFD, activará el pin /CE en low a través de la configuración realizada en la compuerta NAND
$FFFC contiene $00 = %0000 0000
$FFFD contiene $80 = %1100 0000
Si lo ordenamos por los pines del address bus veríamos:
| A15 | A14 | A13 | A12 | A11 | A10 | A9 | A8 | A7 | A6 | A5 | A4 | A3 | A2 | A1 | A0 |
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
Luego cargará $00 ya que ya que es el dato presente en la posición de memoria $FFFC, luego irá a la posición $FFFD y cargará $80. Con estos dos datos modificará el program counter a $8000 y comenzará a leer instrucciones de $8000. Claro que sólo leer $EA ya que es lo que está grabado pero luego de leerlo irá a $8001 y seguirá incrementando el Program Counter de a una unidad.
Un gran y simple programa para poder enfocarnos en cómo leer desde EEPROM un programa en código máquina.
Cómo funciona en la Commodore 64
La Commodore 64 posee 4 ROMS, 3 dentro de la placa madre y otra externa y variable:
El Basic ROM de 8 KB implementado con un chip MOS 2364A y ubicada en las direcciones de memorias $A000 – $BFFF. Esta ROM posee las rutinas de las instrucciones del lenguaje BASIC 2.0 que usamos en la Commodore.
El Kernal ROM de 8 KB implementado con un chip MOS 2364A y ubicada en las direcciones de memorias $E000 – $FFFF. Esta ROM posee las rutinas de más bajo nivel de la Commodore como ser las rutinas de ejecución de las primera instrucción, escrituras a pantallas, sonido.
El Character ROM de 4 KB implementado con un chip MOS 2332A y ubicada en las direcciones de memorias $D000 $DFFF. Esta ROM posee el diseño de los caracteres que vemos en la pantalla, cada caracter ocupa 8 bytes siendo una grilla de 8×8 (8 líneas de 8 bits cada una). La Commodore 64 implementa 2 juegos de caracteres de 256 caracteres cada uno.
La cuarta ROM es la más desconocida de todas ya que es cualquier cartucho que conectemos a la Commodore 64, los mismos están ubicados en las direcciones ROM High ($A000 – $BFFF o $E000 – $FFFF) y ROM Low ($8000-$9FFF) y son mapeados dentro de la memoria por el kernall durante el proceso de inicialización de la Commodore 64.
Codificando desde EEPROM visualmente
Para poder estudiar visualmente como grabar una EEPROM y hacer que el procesador ejecute un programa en código máquina desde la misma les dejo esta video que complementa al artículo.
6502 vs 6510 Primer Programa desde EEPROM – Parte 4
Artículos en la serie C64 a Fondo
A continuación el link al próximo artículo en la serie
Parte 5 – I/O Pins del procesador 6510
y aquí los links a los artículos anteriores
Parte 3 – Codeando a Mano la Primera Instrucción de Código Máquina
Referencias
A continuación les dejo algunos links donde profundizar el tema:
VIDEOS
Video de la serie 6502 vs 6510 Parte 4 – Primer Programa desde EEPROM
6502 vs 6510 Primer Programa desde EEPROM – Parte 4
Aquí tiene acceso a toda la serie:
6502 vs 6510 estudio detallado y comparación
PAPERS
74HC00 Datasheet (PDF) – NXP Semiconductors
David Griffith / minipro · GitLab
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:
