Consulta sobre ISE Web Pack

[wilco2009]

Me estreno en el foro con una pregunta sobre el ISE Web Pack.

Por fin me he decidido a no hacer nada más hasta no aprender a manejar esta herramienta para usar CPLDs de Xilinx.

El hecho es que después de instalar la versión más moderna disponible de este software (v14.7), y después de meter algunas lineas de prueba y conseguir que compile el diseño, resulta que me da un error al intentar compilar las bibliotecas de simulación.

El error es el siguiente: ERROR:Compxlib - COMPXLIB[sim]: Unable to automatically find executables for simulator 'mti_se' from the following paths:

Yo suponía que automáticamente te instalaba un programa de simulación pero aparentemente no lo ha hecho ya que el mti_se no aparece en ninguna parte de mi disco duro

¿Es esto normal? ¿Acaso es que debería haber instalado un simulador de manualmente?

NOTA:
En Design properties, en la línea "Simulator", tengo ISim (VHDL/Verilog)
En el log de compilación aparece lo siguiente:

Signature:-
------------------------------------------------------------------------------
E:\Xilinx2\14.7\ISE_DS\ISE\bin\nt\unwrapped\compxlib.exe -s mti_se -l vhdl -arch cpld -lib unisim -lib simprim -lib coolrunner -intstyle ise
------------------------------------------------------------------------------
ERROR:Compxlib - COMPXLIB[sim]: Unable to automatically find executables for simulator 'mti_se' from the following paths:
E:\Xilinx2\14.7\ISE_DS\ISE\\lib\nt
E:\Xilinx2\14.7\ISE_DS\ISE\\bin\nt
E:\Xilinx2\14.7\ISE_DS\ISE\bin\nt
E:\Xilinx2\14.7\ISE_DS\ISE\lib\nt
E:\Xilinx2\14.7\ISE_DS\ISE\..\..\..\DocNav
E:\Xilinx2\14.7\ISE_DS\PlanAhead\bin
E:\Xilinx2\14.7\ISE_DS\EDK\bin\nt
E:\Xilinx2\14.7\ISE_DS\EDK\lib\nt
E:\Xilinx2\14.7\ISE_DS\EDK\gnu\microblaze\nt\bin
E:\Xilinx2\14.7\ISE_DS\EDK\gnu\powerpc-eabi\nt\bin
E:\Xilinx2\14.7\ISE_DS\EDK\gnuwin\bin
E:\Xilinx2\14.7\ISE_DS\EDK\gnu\arm\nt\bin
E:\Xilinx2\14.7\ISE_DS\EDK\gnu\microblaze\linux_toolchain\nt_be\bin
E:\Xilinx2\14.7\ISE_DS\EDK\gnu\microblaze\linux_toolchain\nt_le\bin
E:\Xilinx2\14.7\ISE_DS\common\bin\nt
E:\Xilinx2\14.7\ISE_DS\common\lib\nt
c:\Archivos de programa\Rockwell Software\RSCommon
C:\Archivos de programa\Archivos comunes\Siemens\Sqlany
C:\Archivos de programa\Siemens\Step7\S7bin
C:\ispLEVER_Classic1_7\ispcpld\bin
C:\ispLEVER_Classic1_7\ispFPGA\bin\nt
C:\ispLEVER_Classic1_7\active-hdl\BIN
C:\WINDOWS\system32
C:\WINDOWS
C:\WINDOWS\System32\Wbem
"C:\Archivos de programa\PKWARE\pkzipc"
C:\Wincupl\WINCUPL\EXE
C:\Wincupl\WINCUPL\FITTERS
C:\Modeltech_pe_edu_10.4a\win32pe_edu.
Simulator 'mti_se' is ignored.

Si selecciono "Process properties", en "Target Simulator" tengo seleccionado "Modelsim-SE VHDL

Gracias anticipadas.

[wilco2009]

Bueno, he conseguido que desaparezca el error instalando un simulador externo (el ModelSimPE) y cambiando la configuración, pero por lo que he podido ver después la simulación la realiza con su propio simulador interno, por lo que este error parecía intrascendente. ¿Es así, o realmente tenía importancia?

[mcleod_ideafix]

No sé cómo lo has hecho.... Yo nunca he usado ModelSIM, siempre iSim. Para trabajar con iSim (o con cualquier simulador), necesitas escribir un testbench, además, claro está, del módulo que pretendas probar.

Lo que preguntas es basicamente cuál es el flujo de trabajo en la herramienta de Xilinx. La respuesta a esto es muuuuy larga, así que mejor comenzar por algo más sencillo: entender qué es un diseño y qué es un testbench.

Vamos con un ejemplo trivial:

Supon que estás haciendo un módulo hardware para sumar dos números de un bit, o sea, un sumador. El módulo podría ser algo así:

Código: Seleccionar todo

module sumador (
  input wire a,
  input wire b,
  input wire cin,
  output wire o,
  output wire cout
  );

  assign o = a^b^cin;
  assign cout = a & b | a & cin | b & cin;
endmodule

Este es nuestro diseño. Aquello que más tarde queremos pasar a una CPLD o a una FPGA. Ahora, para simular este módulo, tenemos que escribir otro módulo que use a éste, dándole estímulos (señales), como si ese otro módulo fuera un contenedor para nuestro diseño. A este módulo que vamos a escribir se le llama testbench.

Desde el entorno de Xilinx, se puede facilitar un poco la creación de los testbench si al elegir un nuevo archivo usamos "Verilog test fixture" (o algo así). Nos pide que seleccionemos el módulo que pretendemos testear y nos crea un esqueleto de testbench para que nosotros sólo añadamos los estímulos. Yo aquí en este caso lo voy a crear de cero. Podría ser una cosa así:

Código: Seleccionar todo

module tb_sumador;
  reg a,b,cin;
  wire o,cout;

  sumador uut (a,b,cin,o,cout); // aqui instanciamos nuestro diseño

  initial begin  // y aqui comienzan los estimulos
    a = 0;
    b = 0;
    cin = 0;
    repeat (2) begin
      #1;
      repeat (2) begin
        #1;
        repeat (2) begin
          #1;
          b = ~b;
        end
        a = ~a;
      end
      cin = ~cin;
    end
    $finish;
  end
endmodule

En el ISE hay dos formas de trabajar: modo diseño y modo simulación. Desde el modo simulación podemos seleccionar este fichero donde hemos escrito el testbench y lanzarlo para que se simule con ISim (o el simulador que tengas definido). Verás una pantalla similar a un analizador lógico con las formas de onda de las entradas y salidas, y podrás comprobar por tí mismo si el circuito se comporta de forma adecuada.

Verilog incluye muchas construcciones algorítmicas, como bucles y demás, que pueden usarse en una simulación, para que sea el propio testbench el que compruebe si el módulo se comporta de forma correcta, en lugar de tener tú que inspeccionarlo todo con la vista. Por ejemplo, añadiendo unas líneas, podemos hacer que el testbench compruebe todos los casos posibles de este módulo:

Código: Seleccionar todo

module tb_sumador;
  reg a,b,cin;
  wire o,cout;
  
  reg [1:0] resul;
  wire o_esperada = resul[0];
  wire cout_esperado = resul[1];

  sumador uut (a,b,cin,o,cout); // aqui instanciamos nuestro diseño

  initial begin  // y aqui comienzan los estimulos
    a = 0;
    b = 0;
    cin = 0;
    repeat (2) begin
      #1;
      repeat (2) begin
        #1;
        repeat (2) begin
          $display ("Probando A = %d , B = %d , CIN = %d", a, b, cin);
          resul = a + b + cin;
          #1;          
          if (o != o_esperada || cout != cout_esperado) begin
            $display ("ERROR: Se calculo O = %d , COUT = %d y se esperaba O = %d , COUT = %d", 
                       o, cout, o_esperada, cout_esperado);
            $finish;
          end
          b = ~b;
        end
        a = ~a;
      end
      cin = ~cin;
    end
    $display ("TODO OK");
    $finish;
  end
endmodule

Normalmente, para probar alguna cosilla, no arranco todo el entorno de Xilinx. En lugar de eso, uso un editor/sintetizador/simulador online muy bueno, hospedado en http://www.edaplayground.com . Su uso es gratuito y puedes editar en una aplicación web tu diseño, testbench, simularlo, e incluso ver cómo queda sintetizado (en términos de puertas lógicas). Por ejemplo, éste quedaría así:

Este código que te he enseñado puedes verlo y cacharrear con él en este enlace:
http://www.edaplayground.com/x/Kis

NOTA: repito que éste es un ejemplo trivial. Cuando le coges algo de vicio al Verilog pronto te das cuenta de que el diseño anterior se podía haber escrito así:

Código: Seleccionar todo

module sumador (
  input wire a,
  input wire b,
  input wire cin,
  output wire o,
  output wire cout
  );

  assign {cout,o} = a + b + cin;
endmodule

Ya que se considera que la suma y la resta son operaciones lo suficientemente sencillas como para que el sintetizador sea capaz de inferir las puertas lógicas de las que están hechas. Es más: se prefiere este tipo de codificación a la anterior porque de esta otra forma, el sintetizador puede elegir si la suma la implementa con puertas lógicas sencillas, o la implementa con primitivas lógicas de más alto nivel que existan ya en la CPLD/FPGA que vas a usar (por ejemplo, las hay que tienen desplazadores de bits ya implementados, sumadores, multiplicadores, y cosas así).

[wilco2009]

Muchísimas gracias. Menudo pedazo de respuesta te has currado.

Ya estoy rompiendo mano con el ISE con un diseño sencillo que tenía medio preparado con una GAL, pero he pensado que era de una vez el momento de dar el salto.

El diseño es un interface que implementa las dos ROMs de un +2A/+3 y el paginado de estas. La idea es utilizarlo tanto en estos para sustituir su ROM de manera externa, como en el +2 gris o en el 48Kb, y de esa manera poder conectarles un interface de floppy o un interface IDE.
Aplicando lo aprendido con el superupgrade y sabiendo que las ROMs del +3 se cuelgan en un ordenador que no responda a las llamadas a los puertos $1FFD, $2FFD y $3FFD, he añadido también la decodificación de estos puertos para devolver $FF cuando no tengo conectado un controlador de disco.

En resumen, es básicamente una porción del superupgrade.

A ver si cojo soltura con el entorno y le echo un vistazo al código del zx-uno.

[mcleod_ideafix]

Aplicando lo aprendido con el superupgrade y sabiendo que las ROMs del +3 se cuelgan en un ordenador que no responda a las llamadas a los puertos $1FFD, $2FFD y $3FFD, he añadido también la decodificación de estos puertos para devolver $FF cuando no tengo conectado un controlador de disco.

Es curioso.... el ZX-Uno no decodifica los puertos $2FFD ni el $3FFD. De hecho esos puertos devuelven "bus flotante", y no he visto que se cuelgue ni nada la ROM del +3e para ZXMMC que le tengo puesta como opción.

Por cierto: hace ya casi 2 años empecé lo que sería un port de tu superupgrade para hacerlo todo metido en CPLD. Escribí varios módulos, y uno de ellos es el gestor de memoria, que incorpora algunas cosillas que comentamos hace tiempo, como por ejemplo forzar líneas de dirección de la CPU a 0 para implementar escrituras en direcciones que pueden estar en dos sitios a la vez. Quedó así:

Código: Seleccionar todo

module gestor_bancos (
    input wire clk,
    input wire rst_n,
    input wire [15:0] a,
    input wire [7:0] d,
    input wire mreq_n,
    input wire iorq_n,
    input wire rd_n,
    input wire wr_n,
    input wire romoe1,
    input wire romoe2,
    output wire romcs_n,
    output wire [1:0] rom_addr,
    output reg ramcs_n,
    output reg [2:0] ram_addr,
    output reg force_a15_zero
    );
    
    reg lockbit = 1'b0;

    reg [2:0] ram_bank = 3'b000;
    reg [1:0] rom_bank = 2'b00;
    assign rom_addr = rom_bank;

    wire acceso_7ffd = !iorq_n && !wr_n && !lockbit && a[0] && !a[1] && a[14] && !a[15];
    wire acceso_1ffd = !iorq_n && !wr_n && !lockbit && a[0] && !a[1] && a[12] && (a[15:13]==3'b000);
    
    // Registro 7FFD. Bits 0-2 = banco de RAM a mapear en C000. Bit 4 = bit bajo de selección de ROM
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            lockbit <= 1'b0;
            rom_bank[0] <= 1'b0;
            ram_bank <= 3'b000;
        end
        else begin
            if (acceso_7ffd) begin
                lockbit <= d[5];
                rom_bank[0] <= d[4];
                ram_bank <= d[2:0];
            end
        end
    end
    
    // Registro 1FFD. Bit 2 = bit alto de selección de la ROM
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            rom_bank[1] <= 1'b0;
        end
        else begin
            if (acceso_1ffd) begin
                rom_bank[1] <= d[2];
            end
        end
    end
    
    // Señal ROMCS_n para activar la EPROM de 64K
    wire romcs1 = !mreq_n && !rd_n && a[15:14]==2'b00 && !romoe1 && (rom_bank==2'b00 || rom_bank==2'b01);
    wire romcs2 = !mreq_n && !rd_n && a[15:14]==2'b00 && !romoe2 && (rom_bank==2'b10 || rom_bank==2'b11);
    assign romcs_n = (romcs1 || romcs2)? 1'b0 : 1'b1;

    // Se monitoriza si se está accediendo al banco 5 de RAM para escritura. Si es asi, se fuerza A15 a 0
    // para convertirlo en una escritura al intervalo 4000h - 7FFFh. Esta escritura será replicada en
    // el banco 5 de RAM.
    // Se describe el comportamiento de forma que force_a15_zero se sintetice como un latch
    always @* begin
        if (!rst_n) begin
            force_a15_zero = 1'b1;  // 1 = no se fuerza A15 a 0. 0 = se fuerza A15 a 0.
        end
        else begin
            if (!mreq_n && a[15:14]==2'b11 && !wr_n && ram_bank==3'b101 && force_a15_zero==1'b1) begin
                force_a15_zero = 1'b0;
            end
            if (mreq_n) begin
                force_a15_zero = 1'b1;  // cuando se termina el ciclo de memoria, se libera A15
            end
        end
    end
    
    // Manejo del chip de 128K de RAM.
    always @* begin
        ramcs_n = 1'b1;     // Señal CS del chip de RAM. Por defecto, deshabilitada
        ram_addr = 3'b000;  // Bits A16-A14 del chip de RAM. A13-A0 van al bus datos del Z80
        if (a[15:14]==2'b11 && !mreq_n) begin  // Un acceso a cualquiera de los bancos de RAM
            ram_addr = ram_bank;
            ramcs_n = 1'b0;
        end
        else if (a[15:14]==2'b01 && mreq_n && !wr_n) begin  // Si se detecta una escritura a 4000h-7FFFh
            ram_addr = 3'b101;                              // ... se replica en el banco 5
            ramcs_n = 1'b0;
        end
        else if (a[15:14]==2'b10 && !mreq_n) begin  // los accesos a 8000h-BFFFh van al banco 2
            ram_addr = 3'b010;
            ramcs_n = 1'b0;
        end
    end
endmodule

[wilco2009]

Muy interesante..... Material para estudiar.

Gracias.

[wilco2009]

Estoy ya manos a la obra aprendiendo a manejar el ISE, y como comentaba en mi mensaje anterior, como práctica me he cogido un diseño tengo preparado con una GAL.

El hecho es que he terminado el diseño utilizando un esquema de puertas lógicas y luego como práctica lo he reproducido en VHDL y ahora lo quiero hacer en Verilog.

Con VHDL más o menos ya lo tengo claro, el diseño me funciona bien (aparentemente), pero me encontrado alguna peguilla con Verilog.

El problema viene al intentar declarar una salida cuyo valor esté en alta impedancia a no ser que se cumpla determinada condición.
Como no tengo muy claro como hacer esto en Verilog he echado mano de la posibilidad que te da el ISE en el report de visualizar las ecuaciones lógicas tanto en VHDL como en Verilog, y la sintaxis que utiliza no la veo nada clara.

El código en VHDL es el siguiente:

Código: Seleccionar todo

	DATA_FF <= not nIORQ and not nRD and not A1 and A13 and not A14 and not A15; 
	
	D0 <= '1' when DATA_FF = '1' else 'Z'; 
 

O sea, si DATA_FF tiene nivel alto pone un 1 en D0, en caso contrario lo deja en alta impedancia.

La traducción que hace ISE de esta ecuación es la siguiente en Verilog:

Código: Seleccionar todo

_D0 (D0_I, 1'b1, 1'b0, 1'b0, 1'b0, 1'b1); 

Y esta (evidente) en VHDL:

Código: Seleccionar todo

D0_I <= '1'; 
     D0 <= D0_I when D0_OE = '1' else 'Z'; 
     D0_OE <= (A13 AND NOT nRD AND NOT nIORQ AND NOT A1 AND NOT A15 AND NOT A14); 

Total, que la ecuación de Verilog está en un formato que no entiendo y que tiene que estar mal porque se ha comido mi condición.

La pregunta es, ¿cómo se haría esto mismo en Verilog?

Gracias, y disculpa por la paliza que te estoy dando.


EDITO: Después de ver un poco más de documentación he visto como hacerlo, pero sigo sin entender la sintaxis que te muestra en las ecuaciones del report.

Mi solución es esta:

module plusexternalROMsVerilog(
input A1,
input A13,
input A14,
input A15,
input nRD,
input nIORQ,
inout D0
);

wire DATA_FF;

assign DATA_FF = ~nIORQ & ~nRD & ~A1 & A13 & ~A14 & ~A15;

assign D0 = DATA_FF? 1 : 1'bz;


endmodule

Y la ecuación lógica que muestra como resultado en el report es la misma que antes.

Código: Seleccionar todo

_D0 (D0_I, 1'b1, 1'b0, 1'b0, 1'b0, 1'b1); 

[wilco2009]

Por cierto: hace ya casi 2 años empecé lo que sería un port de tu superupgrade para hacerlo todo metido en CPLD. Escribí varios módulos, y uno de ellos es el gestor de memoria, que incorpora algunas cosillas que comentamos hace tiempo, como por ejemplo forzar líneas de dirección de la CPU a 0 para implementar escrituras en direcciones que pueden estar en dos sitios a la vez. Quedó así:

........

Por cierto, entiendo que en el módulo principal habría que hacer algo como esto....

Código: Seleccionar todo

	assign Addr = !force_a15_zero? 8'b0zzzzzzz:8'bzzzzzzzz;

¿no?

[mcleod_ideafix]

Por cierto, entiendo que en el módulo principal habría que hacer algo como esto....

Código: Seleccionar todo

	assign Addr = !force_a15_zero? 8'b0zzzzzzz:8'bzzzzzzzz;

¿no?

Pues tendría que mirarlo, pero me parece que la idea era sencillamente que desde la CPLD habría un pin de salida, que se conectaría a A15 y que lo forzaría a 0 cuando fuera necesario.

[wilco2009]

Por supuesto en mi mensaje había un error y donde quería digo assign Addr = !force_a15_zero? 8'b0zzzzzzz:8'bzzzzzzzz; quería decir assign Addr = !force_a15_zero? 16'b0zzzzzzzzzzzzzzz:16'bzzzzzzzzzzzzzzzz;

Por cierto, aquí está tu esquema original:



Y este es el enlace al post en retrowiki: http://www.retrowiki.es/fororw/viewtopi ... =60#p53416