Ordenador casero con uP Z80

[avefenix586]

Que tal colegas electrónicos, espero que hayan arrancado bien el año con mas energías para seguir con este hobbies, desafío y aprendizaje de los microprocesadores clásicos como es el caso del CPU Z80. Tritonbeat si le es posible construya también o desarrolle su sistema con Z80 ya sea como los propuestos aquí o a su propio estilo.

Por ahora ando con la idea de preparar en una sola placa el Sistema Mínimo que he propuesto en mis publicaciones para que sea compacto de armar y sea de uso didáctico para aprendizaje, por mi parte mi sistema de Z80 propuesto no esta orientado tanto a alojar algún sistema operativo o interpretes sino que este se asemeja mas a los sistemas de desarrollo que venían dispuestos con su teclado matricial y sus display de 7 segmentos donde ingresabas códigos manualmente, pero en su lugar las aplicaciones de compiladores en la PC se encargaran de generar el código bin o hex de la aplicación listo para subirlo a la placa del Z80.

Para tal fin utilizo el "Z80 Simulator IDE" como compilador de lenguaje Basic o de assembler para obtener el código hex final pero además para subirlo se requiere del auxilio de una aplicación tipo hiperterminal que mande el archivo hex o bin a la tarjeta Z80, Creo que lo deseable seria desarrollar o contar con algún software tipo IDE básico que también pueda incluir a varios microprocesadores como el 6502, 6800 , 8085 , 68000 etc. etc., ósea todo en uno, que tenga incluido su editor de texto, que se encargue de conectarse con compiladores existentes vía linea de comandos o quizás prepararlos así sean muy básicos.

Luego también poder subir el código resultante hex o bin al hacer clic en el menú de subir tal como si se estuviera manejando un Arduino IDE para hacerse la idea mas o menos , eso tendría que diseñarse en algún lenguaje java o Visual como lo a hecho en parte el colega Trilo byte.

Bueno será hasta algún próximo Post.

 

[avefenix586]

Aquí les comparto el esquemático en Proteus del Sistema Mínimo Básico Preliminar en el que se puede hacer algunas practicas de ejercicios simulados dentro de sus limitaciones claro.
Después de tanto tiempo al fin encontré en una pagina la librería de simulación para el CPU Z80 en Proteus, ojala hubiera también alguno para el MC68008 que es la próxima tarjeta que tengo en mente.

Adjunto la librería para el Z80 que deben descomprimir y pegar respectivamente, el contenido de la Carpeta LIBRARY lo copian en la carpeta dentro de la instalación del Proteus que esta en la ruta .../Data/Library y el archivo Z80.DLL lo copian en la ruta .../Data/Models.

A la simulación le adjunte un pequeño programa demostrativo de secuencial para el Puerto A del PPI, ese programa esta hecho con el "Z80 Simulator IDE".
Este diseño de Proteus mostrado en la imagen es lo que quiero convertir en una sola tarjeta Board compacta pero requiero aprender a elaborar el diseño de PCBs con Proteus, yo siempre he usado el programa antiguo PCB Wizard para diseñar mis circuitos monocara.

Eso es todo por el momento.

 

[TRILO-BYTE]

Hace décadas qué no se actualizaba este hilo.
Desarrolle un sistema operativo primitivo para el Z80, usa comandos como el MS-DOS y hace funciones de las instrucciones RST.
AHORITA ando desarrollando una computadora basada en el 6502.
Me gustaría saber si estas interesado en el código fuente de mía avances en el Z80.
Todo esta escrito en ASM.
utilizo PASMO y le pude cargar también BASIC de 1976

 

[torres.electronico]

Tengo en la caja de integrados un pequeño apartado con retro-integrados... Me queda un z80, un MOS6510CBM, un CDP6402ce y la frutilla del postre: un MOS6581. La verdad, jamas los voy a usar, así que están ahí esperando que alguien los quiera para hacer algo como la gente.

 

[Scooter]

El 6581 SID no lo desprecies, se venden bien caros en ebay y la mitad más uno son fake. En una búsqueda rápida 50~100€
El 6510 seguro que se vende bien también aunque creo que están menos cotizados.

O dáselos a un amigo que lo aprecie.

 

[torres.electronico]

El 6581 SID no lo desprecies, se venden bien caros en ebay y la mitad más uno son fake. En una búsqueda rápida 50~100€
El 6510 seguro que se vende bien también aunque creo que están menos cotizados.

O dáselos a un amigo que lo aprecie.

Exacto, están ahí esperando que alguien me los pida. La verdad, no los voy a usar... Me quedé sorprendido con los precios

 

[Scooter]

Por eso te lo decía, venderlo por 2€ no compensa ir a correos, ponerlo en un sobre, un sello discutir si funciona o no... pero por 100 si que compensa el dolor de cabeza.

 

[TRILO-BYTE]

Exacto, están ahí esperando que alguien me los pida. La verdad, no los voy a usar... Me quedé sorprendido con los precios

De donde eres yo soy de México

 

[torres.electronico]

De la capital de los Vientos... Comodoro Rivadavia, Chubut, Patagonia Argentina

 

[TRILO-BYTE]

De la capital de los Vientos... Comodoro Rivadavia, Chubut, Patagonia Argentina

No puede ser!!!

No puede ser!!!

Y justo ahorita ando construyendo una máquina con el 6502, nimodo me toca aliexpress

 

[avefenix586]

Trilo-byte toda información puede ser útil para contribuir al desarrollo de estos Sistemas Mínimos para Z80 y otros CPU similares , así que podría compartirla en el foro si es posible, así a los que nos interese este tema podamos revisarlo.

Yo recuerdo que me diseñe en Turbo Pascal 7.0 un compilador muy rudimentario para el Microprocesador 8085, también para el Z80 y andaba avanzando un poco para el 8088, era algo bien básico, muy alejado de todas las fases que usa un compilador completo como debe ser mas para lenguajes de alto nivel.

Mi compilador rudimentario solo pasaba dos veces por el código fuente, la primera pasada era para determinar la dirección de las variables, de las etiquetas de saltos y de las Subrutinas que se guardaban en una tabla, ya la segunda pasada traducía los nemónicos reconocidos a su código OP hex. ,mientras que las etiquetas y variables eran sustituidas por sus direcciones previamente guardadas, quedando listo en un archivo *.Hex para subirse desde la misma aplicación mediante un menú a través del puerto paralelo mediante una circuitería auxiliar, esos programas los tenia guardados en un disco duro pero lamentablemente este se malogro.

Algo así quisiera implementar en Visual Basic , que sea como un IDE básico que compile y envié código desde una sola aplicación a una Placa de microprocesador clásico que contenga solo un Bootloader para recibir el código binario o hex. y lo pueda ejecute , así evitar estar usando varias aplicaciones para esa finalidad, pero además que también se guarde ese código en la Memoria y que cada vez que energice la Placa del Z80 el programa se cargue y ejecute sin tener que enviarlo de nuevo como lo hace el Propeller de Parallax.

Vaya con esos chips antiguos originales podría uno tener algo con que ir al "Precio de la Historia" para venderlos y que salga para las vacaciones de la familia jeje, como el caso del Apple 1 que dicen que esta valorizado en medio millón de dólares, a cuanto cotizarían tan solo un solo chip como el CPU original de esa Apple 1?

 

[TRILO-BYTE]

Una pena, no se como construir un compilador voy a ver si en la semana subo todo los códigos fuente del Z80.
Diagramas y el Z88Dk para programar en ASM.

Si pudieras orientarme en hacer un compilador.
Subiré el sistema operativo del Z80 también y avances del 6502 también

 

[avefenix586]

En si yo tampoco se hacer un compilador y para evitar confusiones lo mas adecuado seria decir que hice un "Ensamblador" en lugar de compilador, tengo la esperanza de que en algún disco refundido por allí encuentre alguna copia de mis programas de Turbo Pascal que ya vagamente recuerdo como volver a replicarlos por completo para poder actualizarlos.

En mi tiempo de estudiante había una zona de venta de libros usados que me gustaba frecuentar, entre ellos vi una revista de proyectos electrónicos de mas de 100 hojas que no recuerdo su nombre, entre los proyectos principales de su portada habían dos que me llamaron la atención uno era sobre un Microcontrolador potente de la familia 8051 pero sobre todo un proyecto de programador de memorias Eprom UV .

En casa revise con detenimiento la publicación del programador de Eproms, el circuito era de buffers, contadores y compuertas lógicas que se manejaba mediante el Puerto paralelo de la PC lo cual era muy practico y además lo acompañaban unos programas escritos en Turbo Pascal , así fue como aterrice en el Turbo Pascal, ya tiempo antes me había construido mi propio programador de memorias Eeprom UV manual, con unas tarjetas con su zócalo y muchos switch (todo un manojo de cables aglomerados en su caja) ,así podía configurar e ingresar las direcciones y sus datos, pero me resultaba muy tedioso usarlo de ese modo, así que el contenido de aquella revista era justo lo que necesitaba para mejorar mi programador casero.

Mas adelante vi en la revista Cekit que además de sus volúmenes de Electrónica Básica que se vendían en los quioscos de periódicos tenia también un Volumen dedicado a Microprocesadores en especifico al CPU 8085, allí presentaba un circuito para practicas con varios módulos, una que contenía al CPU 8085 aparejado con un 8155 (RAM + PPI) mas otros módulos de leds, displays , para el ingreso de los programas se usaba un teclado matricial 4x4 apoyado en el chip 74c922, es allí que inicio ya mi interés de construir módulos de Microprocesadores a pesar que antes ya tenia conocimiento del Z80 solo en teoría, con Cekit ya me anime a construir mi tarjeta de Microprocesador 8085 pero no la hice tal como estaba en Cekit sino que le agregue unas modificaciones que tenia también se relacionaban con el programador de la revista antes mencionada.

Para programar en el modulo 8085 de Cekit tenias que ingresar primero la dirección 0 y luego un dato, la dirección 1 y su dato , la dirección 2 y su dato … así sucesivamente se repetía la secuencia hasta completar todo el programa que escribiste en nemónicos y que ensamblaste a mano, allí fue también donde pensé de porque la PC no se encarga de traducirlo por mi ? y eso me llevo a adaptarle la circuitería para el puerto paralelo y tomar como base ese programa de Turbo Pascal del programador de Eprom para crear mi versión de ensamblador básico.

Mi versión de ensamblador no era muy flexible así que tenia que cumplir con escribir el código con ciertas reglas como el de usar siempre espacios entre palabras de los Nemónicos y los datos para que sean reconocidas apropiadamente, mi ensamblador de aquel entonces era algo torpe pero funcionaba y me entregaba el código hex. correcto que ya podía enviar directamente a la placa de Cekit desde mi aplicación en Turbo Pascal.

Si usaba por ejemplo esta instrucción "MOV A , B" me lo reconocía sin problema porque usaba los espacios en blanco para delimitar y capturar palabra por palabra incluido los símbolos de puntuación específicos para ser identificados comparándolas con una lista de palabras reservadas, en cambio si escribía "MOV A,B" se hacia mas confuso reconocerlo por estar junto sin espacios, lo que no se traducía se contabilizaba en una cuenta de errores, mi ensamblador no me decía en que linea se produjo el error solo la cantidad de errores totales y ya yo tenia que revisar donde me equivoque para corregirlo.

Trilo-byte veras que no es complicado hacer un ensamblador como el que menciono, por eso que hasta siguiendo mi mismo método me anime a crear también un ensamblador para el 8048, para el caso del Z80 estaba en avances y con el que tuve dolores de cabeza fue con el 8088 que opte por limitar las instrucciones a reconocer de tanta variedad de combinaciones que tiene en su repertorio de instrucciones, en la siguiente publicación tratare de hacer memoria haber si te puede ayudar algunas de mis pautas para diseñar un ensamblador básico.

 

[avefenix586]

Empezando con las pautas que use para mi ensamblador básico, programe en el Turbo Pascal dos fases bien definidas de exploración del código fuente, la primera fase es la mas ligera mientras que la segunda fase es mas extensa, la secuencia mas o menos programada en el Turbo Pascal de la primera Fase era algo así:

1.- En el editor del mismo Turbo Pascal escribía mi programa fuente en assembler y al guardarlo lo renombraba con la extensión *.A85 para distinguir que era un archivo fuente para CPU 8085, de allí también que el archivo del 8088 le puse extensión *.A88 y para el del 8049 le puse la extensión A48 , al Z80 no recuerdo si le puse A80 o Z80 porque no lo termine , pero ya en la actualidad seria mejor usar BIN o HEX.

2.- Al ejecutar mi aplicación dentro del entorno de Turbo Pascal le había preparado un menú con 7 u 8 opciones, una de ellas era justamente la de Ensamblar , al seleccionarla me pedía que escriba el nombre del archivo a ensamblar, digamos Ejemplo1.A85 , le daba Enter y se procedía a abrir el archivo.

3.- El archivo .A85 al ser abierto era cargado en una matriz de cadenas de caracteres de un ancho limitado digamos 40 caracteres por registro, de tal forma que cada linea del archivo fuente se almacenaba en cada registro de la matriz de forma secuencial.

4.- Las variables las definía con un Nombre seguido de una directivas de DB o DW , las variables solía ponerlas casi siempre antes del inicio del código, mas por cuestión de orden porque también podía ponerlas en cualquier parte del código o en otra zona de memoria con la directiva ORG y que coincida siempre en una zona de la memoria RAM.

5.- Entonces arrancaba la secuencia que llamaremos de asignación de direcciones para las variables, etiquetas de saltos y de subrutinas, en esta secuencia se revisaba linea a linea en la matriz de caracteres secuencialmente para identificar las instrucciones comparándolas desde una tabla donde estaba registrado cuanto ocupaban en bytes cada una de las instrucciones del 8085, se incluía también lo que ocuparan las variables DB o DW, llevándose así una cuenta completa de bytes de inicio a fin y justo cuando se llegaba a identificar una variable, etiqueta de salto o subrutina esta era capturada con el valor del contador de esa ubicación en una tabla de direcciones temporales.

6.- En la primera Fase solo interesa contabilizar cuantos bytes ocupaba cada instrucción bien identificada, como vemos en el repertorio de instrucciones del 8085 este tiene instrucciones de un solo byte, de dos y hasta un máximo de tres bytes, en esta primera pasada no nos interesaba en si los datos que acompañaban a cada instrucción, solo contabilizar los bytes que ocupan las instrucciones del programa completo e ir sumándolas en un contador, que nos refleja la dirección de ubicación de cada instrucción en la memoria, pero solo capturamos las que se correspondan con variables , etiquetas de saltos y de subrutinas..

A manera de ejemplo seria este breve programa sencillo para contabilizar los bytes

ORG 0 ; directiva o instrucciones siempre van después de uno o mas espacios en blanco o un tab, ORG manda el inicio a partir de la dirección 0 y también el contador de instrucciones = 0
NUMERO1 DB 22H ; variable identificada que ocupa un byte , asignación en tabla a dirección 0 , contador + 1 = 1
NUMERO2 DB 11H ; variable que ocupa un byte , asignación en tabla a dirección 1 , contador + 1 = 2
RESULTADO DW 0 ; variable que ocupa dos bytes , asignación en tabla a dirección 2, contador +2 = 4

INICIO : NOP ; se identifica etiqueta de salto INICIO, asignación en tabla a dirección 4 , NOP ocupa un byte entonces contador +1 = 5
LDA NUMERO1 ; LDA ocupa tres bytes, contador + 3 = 8
MOV B , A ; MOV ocupa un byte , contador + 1= 9
LDA NUMERO2 ; LDA ocupa tres bytes , contador + 3 = 12
ADD B ; ADD ocupa un byte, contador + 1 = 13
STA RESULTADO ; STA ocupa tres bytes , contador + 3 = 16
SALTO1 : NOP ; se identifica etiqueta de salto SALTO1 , asignación en tabla a dirección 16 , NOP ocupa un byte entonces contador +1 = 17
MVI A , 0FFH ; MVI ocupa dos bytes, contador + 2 = 19
MVI H , 33H ; MVI ocupa dos bytes, contador + 2 = 21
MVI L , 22H ; MVI ocupa dos bytes, contador + 2 = 23
DCR A ; DCR ocupa un byte, contador + 1 = 24
JZ SALTO1 ; JZ ocupa tres bytes , contador + 3 = 27
INR L ; INR ocupa un byte , contador + 1 = 28
JMP INICIO ; JMP ocupa 3 bytes , contador + 3 = 31
FIN : HLT ; se identifica etiqueta de salto FIN, asignación en tabla a dirección 31 , HLT ocupa un byte entonces contador +1 = 32

Y así continuaríamos el recorrido por nuestro programa identificando variables, etiquetas de salto y de subrutinas asignándoles su respectiva dirección en la tabla temporal de direcciones o también se podría decir de punteros, eso es todo lo que hacia mi programa ensamblador en la primera fase.

En nuestra tabla de direcciones o punteros aparecería así el contenido y esa información la tomara la segunda fase del ensamblador cuando lo requiera.

NUMERO1 0
NUMERO2 1
RESULTADO 2
INICIO 4
SALTO1 16
FIN 31

la instrucciones de código OP y su numero de bytes lo maneje con instrucciones de comparación sucesivas con "IF ... = ... then..." o "Case...End" , el programa al analizar cada linea si se encontraba que en la primera columna había un carácter diferente a espacio (ASCII 32) lo toma como una posible etiqueta de variable o de salto o de subrutina,

En cambio si en esa linea encuentra uno o mas espacios en blanco los va recorriendo hasta alcanzar el primer carácter valido y va capturando los siguientes caracteres deteniéndose al llegar al próximo espacio en blanco , digamos que nos captura después de los espacios los caracteres "N" "O" "P" = NOP, detiene la captura y comienza a compararlo con todas las 74 instrucciones registradas , al encontrar la coincidencia obtiene el numero de bytes que ocupa esa instrucción para poder sumarlo al contador de direcciones, termina allí con esa linea y pasa a la siguiente linea de la matriz de caracteres repitiendo el mismo procedimiento hasta completar todas las lineas y en caso de no poder identificar alguna instrucción porque esta mal escrita me tiene que dar al final el numero de errores encontrados.

Esa es la idea general de la primera fase del ensamblador básico que en resumen seria "Contabilizar los Bytes" de nuestro programa fuente.

Eso es todo por ahora.

 

[TRILO-BYTE]

Mi sistema Z80 de hecho me base en tus diseños para hacer las placas de hecho son muy parecidas.
Te dejo un link del video que subí
No es mi voz, le puse esa voz por que subí toda una serie de programación en ENSAMBLADOR y es muy aburrido.

Subí en tiktok toda la serie de la computadora Z80 y ahorita la del 6502 tuve que construir todo el Atari 2600 para probar unos microprocesador 6502 qué compre en Aliexpress

 

[avefenix586]

Trilo-byte viendo tu video se ve que ya estas en otra liga como el colega Gudino jeje, Como que esa no es su voz real ? y como le hace para usar una voz artificial tan natural? que software es ese? ,yo también quisiera hacer mis videos pero como tengo una voz muy aburrida para hacer videos tutoriales quisiera ponerme una voz mas llamativa como la del celebre kompayaso (que en paz descanse) , así de rato en rato soltar su risota y alguno que otro chascarrillo jeje.

Están interesantes los videos de Diseño y construcción de una computadora de 8 BITS, construir estos Sistemas Microprocesadores en módulos si resulta practico y para los fines didácticos en vez de hacerlos en una sola placa que de por si tiene que ser diseñada para doble cara, ahora como se ve bastante difusión de los servicios de manufactura china de PCBs , alguno de mis colegas que manejan Eagle o Proteus mandan a hacer sus placas a china y le quedan muy profesionales así que yo también me ando animando a hacer mi diseño de Z80 en una sola placa y mandarlo a china por eso ando aprendiendo de a pocos el Proteus PCB (solo lo usaba siempre para esquemáticos )

Hace unos meses anduve también tanteando el Visual Basic que viene con Excel siguiendo algunos tutoriales para crearme unos formularios y macros para hacer mi inventario personalizado , de allí que ahora me iré a probar un Visual Basic neto, haber si creo una Aplicación y pueda migrar los ensambladores que hice en Turbo Pascal al Visual Basic, así diseñar algo que se acerque a una IDE básica y que soporte diferentes microprocesadores clásicos y también desde allí que cargue vía algún hiperterminal el código binario a las placas respectivas, bueno es la idea que tengo desde hace años.

Si están usando los programas de la empresa Oshonsoft ,que tiene sus compiladores para Pics y Atmel, además de los compiladores Basic para algunos microprocesadores clásicos 8085 y Z80 ,habrán visto que su reciente lanzamiento novedoso (hace casi un año lo vi) fue un Compilador Basic para el 6502, si sigue en esa linea es posible que lancen también un compilador Basic para el 6809 o el 8088 , yo esperaría que lo hicieran para el 68K también.

En este video muestran los circuitos Microprocesadores propuestos en la pagina Grant's Searle ya implementados, en estas versiones con solo un USART a mi me dan la sensación de estar algo mutiladas a falta de algún PPI por el que pueda uno interactuar con señales de entradas y salidas,
Alguna vez se me ocurría pensar porque no los diseñadores nos regalaron un diseño final de despedida de esos microprocesadores clásicos en versiones de microcontrolador en un solo chip con sus periféricos incorporados , tener un 8085, 6502, 6809 incluso un 8088 con su FPU , RAM , Flash y periféricos en un solo chip, en fin ocurrencias mías jeje.

 

[TRILO-BYTE]

Yo todos mis videos los grabe en mudo y cuando tengo varios abro tiktok y los subo y en la opción de audio le das en grabar y grabas con tu voz y ya que grabaste el audio le das en filtro de voz y así queda.

Voy a subir el código fuente del Z80 y del 6502 y el código fuente del Tiny BASIC lo hice correr en mi Z80.

Yo prefiero hacer las placas a módulos por que ni yo se si lo que estoy haciendo es correcto.
Me base en tus diseños y el bootloader lo escribí en ASM y también me base en tu idea aunque no subiste archivos de ningún tipo me pareció una buena idea así que escribí mi propio bootloader.
En la semana subiré mis diagramas y código fuente aunque en tiktok describí paso a paso como fui diseñando la computadora Z80 pero lo que es el microprocesador 6502 ese si me esta costando trabajo entenderle

 

[avefenix586]

Hace un tiempo había descubierto la existencia del condenado Free Pascal, lamentablemente muy tarde pues mis cds antiguos que ya estaban rayados los bote y en uno de ellos estaba todo lo que había hecho en Turbo Pascal 7.0 referente a mi programador de Eproms y los ensambladores , aunque le había sacado una copia en un disco duro este también con el tiempo se me malogro, me dije bueno ya ni modo total mis programas son obsoletos para estos tiempos ósea que ya no serian soportados por compatibilidad, sin imaginar que habían salido versiones de turbo Pascal como el Free Pascal que corren en Windows 10,

Así que ahora que tengo el Free Pascal instalado con algunos detalles mas por descubrirle he vuelto a retomar el proyecto de ensambladores y pues como en aquel entonces estoy empezando a recrear el primer ensamblador que hice que fue para el 8085, rebobinando en mi memoria la lógica que seguí en aquel entonces, yo recuerdo que mis programas ensambladores llegaban a ocupar entre 1800 a casi 3000 líneas de código de acuerdo al microprocesador, además que tampoco me fijaba mucho en la optimización de código y mas en el resultado final de entregarme mi código Hex como se esperaba.

Hace una semana escribí casi 200 líneas de código en Free Pascal para ejecutar la primera fase que explique sobre mi ensamblador básico, que consistía en una primera pasada para reconocer etiquetas y variables para guardarlas en una tabla de punteros, esta primera fase es la parte mas ligera por así decirlo (también depende de los Nemónicos) , por ahora no tiene corrector de errores es decir no contabiliza errores ni reconoce nombres repetidos, cosas que se agregara mas adelante.

Para escribir un código fuente básico en ensamblador tenemos que hacerlo con un modelo casi estandarizado que seria el mostrado en la primera imagen , las etiquetas de salto o subrutina siempre pegados a la primera columna de cada linea , yo antes lo había limitado a un máximo de 10 o 12 caracteres y que también debía terminar con dos puntos al final del nombre y sin espacios como por ejemplo "Inicio:" y no "Inicio :".

Para el caso de las instrucciones estas deben estar siempre después de al menos un espacio en blanco o un tab , así serán analizadas como posibles instrucciones a identificar , en caso no se reconociera se contabilizara un error mas pero esto mas adelante se agregara el numerador de errores, por ejemplo si en vez de poner "NOT" pongo "NIT" en un resumen final se adiciona al numero de errores totales encontrados.

En la segunda Imagen de la consola les muestro lo que hace al ejecutarse el programa en Free Pascal referente a la primera pasada del ensamblador , allí podemos ver que hay una numeración que es la dirección que le corresponde a cada etiqueta y a cada instrucción identificadas, tenemos un contador de direcciones que va incrementándose de acuerdo a lo que va ocupando la instrucción en bytes, en esta pasada solo nos interesa contabilizar el numero de bytes que ocupa cada instrucción reconocida y por lo pronto no nos interesa los datos que lo acompañan, algo bueno con el 8085 es que tiene Nemónicos muy bien diferenciados , no como el caso del Z80 que se complica un poco con el uso de la instrucción "LD" para variedad de instrucciones que ocupan diferentes bytes pero aun peor es el 8088 que por ejemplo usa la instrucción MOV y en diferentes modos de direccionamiento puede tomar 2 bytes hasta 8 bytes creo recordar ,por lo que requiere mas análisis para poder determinar el numero de bytes que corresponde en la primera pasada del ensamblador.

Bueno por ahora mis avances empiezan en la programación del Ensamblador a grandes rasgos, las correcciones de errores o mejoras las iré haciendo poco a poco al código de Free Pascal , primero culminar el ensamblador para el 8085 que es casi como preparar un molde o patron sobre el cual se irán moldeando los demás ensambladores como el Z80 que seria el siguiente y de allí otros mas como el 6502 y el 68008.

PD. Trylo-byte después de diseñar tu computadora 6502 te sugiero dar el siguiente salto al 68008.

 

[Dr. Zoidberg]

Free Pascal....es igual a viejo IDE de Borland!!!!