Intentando un ZX81 en la FPGA OLS (o un Spectrum 16k)

[jepalza]

O como acabar en fracaso antes de empezar

Bromas aparte. Estoy tratando de meter un ZX81 con 1k de RAM (por ahora) en el OLS (Open Logic Sniffer) mas que nada por diversión, por que está mas que "re-que-te-inventado" (al igual que el Spectrum o el Jupiter entre tantos otros, el Jupiter ademas, de Mcleod_Ideafix en este mismo OLS (los fuentes andaban por algún sitio de la red, que no recuerdo, quizás Mcleod lo recuerde)).

Pero tengo dudas al no conocer en exceso este mundillo de las FPGA.

La cosa, es que he logrado meter el emulador de Z80 (Fz80) (hay mas, como ESTE otro, pero he elegido FZ80 al azar). Tengo tambien la RAM de 1k, y la ULA (proyecto ZX97_Gate), pero esta última, aún no he logrado sintetizarla, por que está en VHDL, no en Verilog, y no sé como se enlazan entre ellos. (será la próxima pregunta, en caso de no conseguirlo).

Con La ROM estoy teniendo algunos problemas. Creo haber descubierto alguno de los problemas, pero si alguien me orienta, mejor, y así voy directo al tema. Uno de ellos, es la lentitud con la que sintetiza la ROM en caso de ponerlo como código de verilog, sin embargo, si lo hago como Core (con el Core Generator), va mas rápido. Pero es que me gustaría que fuera en verilog, para poder alterar los bytes de la ROM a gusto, para trampear llamadas y redirigirlas a otras rutinas, para añadir funcionalidades extras al ZX81. Si está como Core, tengo que cambiar los bytes en la ROM y volver a regenerar el Core, y me parece un lío. Si alguien sabe el porqué de la lentitud, lo diga, por favor. (o si hay otro método parecido al Core, pero mas ligerito).

[DistWave]

¿Se pueden meter "cosas" en el OLS? ¿Y cómo le conectas un teclado o sacas video?

[jepalza]

¡Si, Hombre! Mcleod_Ideafix fué el primero en conseguirlo, metiendo un Jupiter Ace completito (está en las páginas finales, mas o menos). Luego, Mentalthink también hizo alguna demo de algo sobre las VGA. Y yo ando con esto del ZX81 (si lo consigo).

En cuanto a teclado, vídeo, y cintas no es tan complicado, solo es emplear alguna de las 16 entradas/salidas o una de las 16 entradas (32 al total) para pinchar la electrónica, y programar la FPGA para que acceda a ellas. El problema, es que la OLS es muy cortita en capacidad y en entradas/salidas, que le hace quedarse muy justo para la gran mayoría de proyectos. Un ZX81, un Jupiter ACE, un Spectrum de 16 (quizás) y como mucho, una Atari 2600, poco mas.
Si le le pone RAM externa, se gana para llegar incluso a un Spectrum 48k, pero no hay pines suficientes para una SRAM, mas teclado, video, etc. Si se usa una SDRAM y un teclado PS/2, quizás se logre, pero para hacer eso, te compras cualquier otro FPGA mas completo a precios poco mayores, como los PAPILIOS.

La OLS por lo justita que es, es mas bien para divertirse programando, para aprender, vamos.

[radastan]

¿Joseba? ¿tú con FPGA? ¿El defensor de la lógica CMOS/TTL? ¿El anticristo de las CPLD/FPGA?

Como cambia el cuento...

Ya fuera coñas, me alegro que andes con estas cosas, estoy seguro que si todos nos pasamos a FPGA obtendremos resultados más rápidamente y con más garantías. Yo en cuanto acabe la mudanza, el ZDP-80 será mi último proyecto con lógica normal, me paso a las FPGA de cabeza.

[jepalza]

¿Joseba? ¿tú con FPGA? ¿El defensor de la lógica CMOS/TTL? ¿El anticristo de las CPLD/FPGA?.

uupss , mas pillao.

Lo tengo hace tiempo, pero lo callaba, por razones "de lógica TTL".

[DistWave]

La OLS por lo justita que es, es mas bien para divertirse programando, para aprender, vamos.

Vaya, y yo utilizandola como analizador lógico... Lo malo es que me cargué una de las entradas (le metí -12v sin querer, puse la sonda donde no era) pero cuando tenga un rato le echo un ojo!

[mcleod_ideafix]

Para modificar la ROM a gusto haz lo siguiente: créala usando el Core Generator. Para modificarla, abre con un editor de texto el fichero COE que le diste al Core Generator para inicializarla. El COE tiene esta pinta:

Código: Seleccionar todo

MEMORY_INITIALIZATION_RADIX=2;
MEMORY_INITIALIZATION_VECTOR=
11110011,
10101111,
00010001,
11111111,
...
...
...
10011001,
01000010,
00111100;


Esto por ejemplo son los primeros bytes y los últimos bytes de la ROM del Spectrum en formato COE. Como verás es muy sencillo: cada línea es una dirección de memoria. El contenido son los 8 bits, en binario, que hay dentro de esa dirección.

Para modificar la ROM, modifica este archivo, lo grabas, y dentro del ISE Webpack, coge y selecciona la ROM generada con el Core Generator (aparecerá con el resto de módulos de tu diseño, en la vista jerárquica de tu diseño). Verás que al seleccionarla aparecen unas opciones abajo (donde mismo aparecen las opciones de Sintetizar, Place & Route, Generate programming file, etc). Una de ellas es "Regenerate Core" que lo que hace es volver a recompilar la ROM con el nuevo COE que hayas puesto. Después de regenerarlo, vuelve a crear el fichero BIT de la forma en que ya sabes.




Otra forma de conseguir lo que quieres es usando un pequeño wrapper en Verilog que haga de "parcheador" de la memoria ROM. Algo como esto. Supongamos que la definición de tu ROM de 8K para el ZX81 tiene esta pinta:

Código: Seleccionar todo

module rom8k(
  input clk;
  input romcs;
  input [12 : 0] addr;
  output [7 : 0] dout
  );

En tu diseño, en lugar de usar este módulo, usaremos este otro, que por dentro usará a la ROM original cuando sea necesario, así:

Código: Seleccionar todo

module rom8k_parcheada (
  input clk;
  input romcs;
  input [12 : 0] addr;
  output [7 : 0] dout
  );

  wire [7:0] dout_original;

  rom8k rom_original (
    .clk(clk),
    .romcs(romcs),
    .addr(addr),
    .dout(dout_original)
    );

  assign dout = (romcs && addr==13'h0123)? 8'h01 :
                (romcs && addr==13'h4567)? 8'h23 :
                (romcs && addr==13'h89AB)? 8'h45 :
                (romcs && addr==13'hCDEF)? 8'h67 :
                dout_original;
endmodule

El funcionamiento es sencillo: la ROM original recibe todas las señales desde la ROM parcheada, pero el dato no lo vuelca al bus de datos externo, sino a un bus interno (dout_original). Usando un multiplexor, según el valor de la dirección (addr) presentamos en el bus de datos externo un valor, u otro. Esto es para poner datos diferentes en ciertas direcciones que nos interesen. Si la dirección no es ninguna de las "especiales", presentamos como dato lo que hubiera en el bus de datos interno (original).
Puedes poner tantas líneas del tipo (romcs && addr==DIRECCION_ESPECIAL) ? DATO_MODIFICADO : como quieras, pero cuantas más pongas, más espacio de lógica ocupas en la FPGA.

Este método tiene la ventaja de que no hay que abrir ningún fichero externo ni regenerar ningún core. Simplemente modificas el fuente en Verilog y vuelves a sintetizar. Su inconveniente es que generas un multiplexor con tantas entradas de 8 bits como posibles direcciones tengas, y eso consume CLB's de lógica.

[mentalthink]

Luego, Mentalthink también hizo alguna demo de algo sobre las VGA.

Me parece que te confundes Jepalza, porque básicamente no tengo apenas idea de Electrónica, lo único que si es cierto que he comentado cosillas del cacharro esté en que estáis intentando meter el spectrum, el Clon del Gameduino, pero para nada he hecho algo de ese calibre (ya me gustaría,ya...)

[jepalza]

Luego, Mentalthink también hizo alguna demo de algo sobre las VGA.
Me parece que te confundes Jepalza, porque básicamente no tengo apenas idea de Electrónica, lo único que si es cierto que he comentado cosillas del cacharro esté en que estáis intentando meter el spectrum, el Clon del Gameduino, pero para nada he hecho algo de ese calibre (ya me gustaría,ya...)

Tienes razón, lo dije de cabeza sin pensarlo, fué AntonioVillena, y se puede ver lo que hizo en SPECCY

(pero al menos has tenido un rato cortito de fama )

Vaya, y yo utilizandola como analizador lógico...

¿Es una analizador lógico? Ahora me entero ...
Siempre puedes volver atrás, y dejarla como analizador lógico de nuevo, cuando te aburras de jugar. Pero si es por jugar, ya te digo, que mejor una Papilio, por precio mas que nada, o la Gameduino, de la que ya se ha hablado en ESTE HILO, por que la OLS se queda muy justita, al no llevar RAM y solo "16 I/O+16 Input"


Mcleod_Ideafix: me gusta ese método de alterar el Core. El otro, el de modificar el .COE lo había encotnrado, pero no sabía cómo hacer que lo volviera a ver de nuevo con los cambios, eso de "regenerarla", ahora ya lo sé. Pruebo esas cosas esta tarde, y comento a ver que tal. Y las nuevas dudas que me surjan, como lo de enlazar un VHDL a un Verilog.

[DistWave]

Siempre puedes volver atrás, y dejarla como analizador lógico de nuevo, cuando te aburras de jugar. Pero si es por jugar, ya te digo, que mejor una Papilio, por precio mas que nada, o la Gameduino, de la que ya se ha hablado en ESTE HILO, por que la OLS se queda muy justita, al no llevar RAM y solo "16 I/O+16 Input"

Bueno, pero la OLS ya la tengo y ante tal descubrimiento me muero por meterle cositas, por sencillas que sean. Además ya llevo tiempo queriendo jugar con VHDL, que lo vi muy de refilon en la carrera... ¿Hay algun pack de desarrollo preparado para el OLS?