PicoBlaze en FPGA

[newells5]

Tengo que hacer un proyecto de fin de curso (es un modulo, no es carrera) bastante jodido y no se muy bien como empezar.

Consiste en implementar un microcontrolador en una FPGA, en la XCV50. He conseguido averiguar (que no es poco) que el nucelo que tenemos que emplear es el PiciBlaze. Si me podeis dar informacion o estructuras o algo de ese nucleo os lo agradeceria inmensamente.

Gracias de antemano

[antoniof]

Buenas.

Aqui te pongo un link bastante interesante del PicoBlaze:

http://wsdetcp.upct.es/Personal/JGarrigos/picoblaze/picoblaze.htm

Hay bastantes cosillas, hasta un entorno de desarrollo IDE, que te genera el programa en una ROM que luego incluyes en tu proyecto de VHDL.

La verdad este microprocesador para un "aqui te pillo qui te mato" esta muy bien.

Si necesitas algo más, porque a poco que le pidas, el picoblaze se queda corto, te recomiendo el microblaze y su entorno de desarrollo el EDK de xilinx que esta pero que muy bien.

Una pregunta, que tienes pensado hacer con este micro y con la Virtex?

[drines]

gracias por la ayuda,
de momento tenemos que investigar.
el programa no esta especificado todavia, pero es uno bastante sencillo
gracias

[newells5]

Ya tenemos algo de documentacion (drines es compañero mio), como databooks de picoblaze, instrucciones, algunos ejercicios...

En clase tenemos una tarjeta de FPGA"s basada en el XCV50, el PicoBlaze emplea un 10% de este chip. No sabemos si el MicroBlaze (del que tambien he encontrado algo) ocupará demasiado o no.

Pero vamos, resumiendo, la versión del profe es que si de esos 2 núcleos uno es barato nos quedemos con ese y si hay que pagar por los dos pues ya tomariamos alguna decisión.

antoniof, no sabes lo que te agradeceria si nos das algo más de información, alguna pista...  ALGO!!

gracias de nuevo

[newells5]

La finalidad real del proyecto es implementar el micro y despues crear un ejercicio sencillo, no se que decirte, el mítico "KIT", meter un número, que lo multiplique por "x" y lo saque en binario, no se, algo de eso. Pero una cosa sencilla.

El entorno de desarrollo EDK vale para el picoblaze?

[antoniof]

Bueno pues por la aplicación que me comentas, con el PicoBlaze teneis de sobra. Este micro es totalmente gratis, open source, open ip y todo de todo.

El MicroBlaze es de pago, no para utilización casera, ya que te bajas el EDK de la mula y aqui te viene y puedes utilizarlo y meterlo en un FPGA y hacer lo que os de la gana con el. Pero para fines lucrativos hay que pagar, ya que el código VHDL del mismo viene encriptado y para fabricarlo hay que comprarselo a xilinx.

El entorno EDK sólo sirve para el MicroBlaze y para el PowerPC, este útimo solo es sintetizable en FPGAS VirtexII en adelante. He estado mirando los recursos de la XCV50 y creo que el Microblaze cabe perfectamente en la placa y desde luego yo os podría ayudar bastante con este micro y el EDK. Pero si vuestro profesor dice que tiene que ser gratis, pues PicoBlaze al canto.

Yo con PicoBlaze no he trabajado nunca. Creo que con el entorno de desarrollo que os pase, es fácil desarrollar aplicaciones.

[newells5]

Muchas gracias tio!!  Esto es sin duda un pequeño paso para la humanidad pero un gran paso para mi!!

Ahora me voy a dedicar a buscar el codigo VHDL del picoblaze y a implementar y enredar toca

Si me surgen mas cosas raras escribire por aqui a ver si hay suerte y puedes solucionarme algo en el futuro...  o yo a ti!!   ^_^

[newells5]

si me pudieras decir el proceso que hay que seguir para implementar el micro, me explico...

he descargado de xilinx un archivo que se llama "xapp213.zip" en el que que me vienen varios archivos *.vhdl, lo que quiero saber es si estos archivos son los que hay que cargar en la FPGA.

tambien me gustaria saber como hay que hacer para programar, me refiero a si tengo que hacer un programa en ensamblador (o el lenguaje equivalente de xilnx para el picoblaze) en un software determinado y pasar esto al FLPG, es que no lo tengo demasiado claro

si por ejemplo me dijeses el proceso que sigues tu con el microblaze me seria de gran ayuda para guiarme

una y mil veces gracias!!

[antoniof]

Bueno.

Lo primero es hacer el programa que va a ejecutar el micro. Para ello abres el programa pBlazIDE.exe. Este programa se puede bajar de aqui:
http://wsdetcp.upct.es/Personal/JGarrigos/picoblaze/pBlazIDE36.zip
Una vez que lo tengas abierto, abre el archivo lo_prog.psm. Este programa de ejemplo, lo que hace es capturar el valor de un  dip switch y mostrarlo por dos displays de 7 segmentos. El como lo hace es cuestion de verse las instrucciones del micro, que podeis encontrar en este pdf

No se porque, pero el pBlazeIDE no me compila el programa del micro, con lo cual hay que utilizar el programa de MS-DOS que trae el xapp213.zip. Lo descomprimis, y veis que hay un programita que es el KCPSM.EXE. Bueno pues os abris una ventna de MS-DOS de windows, os colocais en la carpeta donde habeis descomprimido todo y ejecutais: KCPSM lo_prog.psm

Esto os genera el archivo LO_PROG.VHD, que es la memoria de programa del picoblaze:



El otro bloque del microblaze es el módulo kcpsm.vhd, donde está todo el core y la lógica del microprocesador, que también se incluye en el archivo xapp213.zip

Ahora queda lo más complicado y es hacer la lógica de conexión entre el core del picoblaze y, en este caso, los displays de 7 segmentos. Para ello, hay que hacer un módulo que lea el PORT_ID(dirección de entrada/salida), el READ_STROBE y el WRITE_STROBE y actue con los displays. Para que tengais una mejor idea de como hacerlo, leeros el pdf que os he puesto arriba que os aclara como funcionan los puertos del micro y que relación tienen con las instrucciones

Una vez que tengais este último módulo, junto con el core y la memoria de programa, los sintetizais todo y lo cargais en la FPGA, con el programa que utiliceis normalmente. Yo utilizo el xilinx ISE.

Estos serían los pasos a seguir para hacer vuestro trabajo. Lo más complicado por supuesto, es hacer la lógica de interfaz entre el core y los displays de 7 segmentos. Si teneis tiempo, os aconsejo que hagais este proyecto de ejemplo, ya que lo teneis todo hecho menos el módulo de interfaz. Este módulo os servirá en vuestro proyecto, ya que cambiarán poquisimas cosas y teneis la seguridad de que todo (programa, memoria, picoblaze, etc) funciona.

Después, para vuestro proyecto, sólo tendréis que cambiar el programa que ejecuta el micro y pocas cosas de la interfaz.

Para cualquier otra cosa, aqui estoy.

[newells5]

Ese interfaz del que hablas entre el Core y el display... te refieres al archivo UCF donde yo diga que me sake la señal para el display por los pines 10,11,12... por ejemplo?

Me creo que te refieras a eso, cuentame que estoy ansioso por dejarlo acabado.

Eres el facking crack antioniof!!

[antoniof]

El interfaz no es el UCF. Este archivo es el que conecta los pines externos de la FPGA al diseño.

Me refiero a un módulo VHDL que haga la funcion de puertos de entrada salida del micro. Como ves, el core ahora mismo es un microprocesador muy básico con un bus de direcciones (PORT_ID) un bus de datos de entrada (IN_PORT) y un bus de datos de salida (OUT_PORT), cada uno con sus respectivas señales de habilitacion. Con esto, lo único que se puede hacer es acceder a una memoria RAM externa. Debeis hacer los puertos de entrada salida, iguales a los de un PIC que escribas algo en un puerto de salida y se mantenga hasta que el micro vuelva a actualizarlo. No se si me explico. Si no, no podreis manejar, leds, dip switches displays, etc.

[newells5]

Buenas de nuevo.

Se nos ha presentado un nuevo problemilla, ya que tenemos el databook del PicoBlaze en ingles (como es logico) y nuestras traducciones dejan bastante que desear.

Si alguien tiene por ahi el manual este en castellano pues nos seria de gran ayuda.

antoniof no tengo ni la mas minima idea de como hacer esa interfaz, si me das alguna pista o alguna hecha ya de otro ejercicio, es que no tengo ni idea de VHDL, lo mas que he hecho en este lenguaje es modificar cosillas de algun contador y decodificador, pero ni idea de programar a pelo en VHDL.

Gracias.

[antoniof]

Bueno, con el manual en español, lo vais a tener un poco crudo. Estas cosas son asi.

En cuanto a la interfaz, quizas os meti demasido miedo, ya que es no es tan dificil, pero si no habeis echo ni visto ninguna comprendo que esteis perdidos. Cuando empece en este mundillo cualquier cosa se hacía cuesta arriba. Pues aqui os pongo una que he hecho.

La interfaz tiene 2 puertos uno de entrada "puerto_entrada" y otro de salida "puerto_salida". Ambos tienen una dirección parametrizable, es decir, por defecto les he puesto las direcciones que me a dado la gana (0x0A y 0x0B). Las podeis cambiar facilmente en la sentencia "generic". Básicamente, lo que hace el módulo es comparar la dirección que pone el micro en el bus PORT_ID, con las direcciones que se han definido con el "generic". Cuando coinciden y detectan una operación de lectura o escritura, leen el  dato del puerto de entrada o lo colocan en el de salida respectivamente.

A partir de éste módulo, podeis hacer lo que querais, como por ejemplo, un controlador de displays de 7 segmentos, un controlador de teclado, etc. Aunque con estos dos puertos teneis de sobra para hacer lo que me comentábais de leer un par de datos, sumarlos y sacarlos por el puerto de salida.

Codigo:-- Módulo que se comporta como un puerto de entrada y otro de salida para el PicoBlaze
-- Cuando el micro quiere escribir en el puerto de salida, coloca su dirección en PORT_ID
-- el dato en OUT_POTR y activa la señal WRITE_STROBE
-- Cuando el micro quiere leer del puerto de entrada, coloca su dirección en PORT_ID
-- activa la señal READ_STROBE y captura el dato del IN_PORT
-- La dirección de los puertos de entrada/salida es parametrizable

library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.STD_LOGIC_ARITH.ALL; 
use IEEE.STD_LOGIC_UNSIGNED.ALL; 

entity interface is 
-- Direcciones de los puertos
Generic ( ID_ENTRADA : std_logic_vector(7 downto 0) := X"0A";
          ID_SALIDA  : std_logic_vector(7 downto 0) := X"0B";
-- Señales
Port ( clk :in std_logic;
       reset : in std_logic;
       puerto_salida : out std_logic_vector(7 downto 0);
       puerto_entrada : in std_logic_vector(7 downto 0);
       IN_PORT : out std_logic_vector(7 downto 0);
       OUT_PORT : in std_logic_vector(7 downto 0);
       PORT_ID : in std_logic_vector(7 downto 0);
       WRITE_STROBE : in std_logic;
       READ_STROBE : in std_logic);
end entity interface; 

architecture Behavioral of interface is 

begin 

puertos : process (clk, reset) begin
if(reset = "1") then
  puerto_salida <= (others => "0");   --   Al inicio, el puerto de salida e cero.
elsif(clk"event and clk="1")then
  if(WRITE_STROBE = "1") then
    if(PORT_ID = ID_SALIDA) then
      puerto_salida <= OUT_PORT;      -- Se carga el puerto de salida
    end if;
  elsif(READ_STROBE = "1") then
    if(PORT_ID = ID_ENTRADA) then
      IN_PORT <= puerto_entrada;      -- Se lee el puerto de entrada
    else
      IN_PORT <= (others => "Z");   -- Si no corresponde con la netrad, se deja libre el puerto
    end if;
  end if;
end if; 
end process puertos; 

end Behavioral; 

[newells5]

muy buenos dias antoniof, ya lo tenemos todo hecho y no funciona, a ver si ves algun fallo en lo que hemos hecho.

No me deja adjuntar la imagen del esquematico que tenemos preparado por problemas de espacio, pero es un esquematico sencillo donde se pueden ver 3 bloques, el nucleo de picoblaze, el programa LO_PROG (el de 7 segmentos que nos dijiste) y el interfaze que tu mismo nos pasaste, con sus buses correspondientes conectados, eso si que sabemos hacerlo  :p

Hemos conectado buses y preparado los pines de entrada, salida y reloj (ignoramos el de interrupcion). Lo hemos sintetizado, implementado y mapeado, no da errores, lo hemos cargado en la tarjeta de FPGA"s que aqui usamos (que la ultima vez funcionaba) y no hace nada.

La conexion física de hardware que hemos hecho ha sido poner interruptores a los pines de entrada, de forma que le metemos 1"s o 0"s alternativamente y los pines de salida van conectados al display 7S.

A ver si ves algo mal. O todo, que tampoco me extrañaria...

Gracias de nuevo por tu atencion y ayuda

[antoniof]

La interfaz que os puse son simples puertos de entrada salida. Con esto no podreis controlar los displays de 7 segmentos, ya que el programa que esta ejecutando el picoblaze, es decir, el que compilasteis y que os generó la memoria LO_PROG, no esta echo para ese interfaz.

Lo más rápido que podeis hacer es un nuevo programa, que haga lo siguiente:

leer del puerto de entrada, es decir, de la dirección 0x0A y escribir el dato leído en el puerto de salida, es decir, la dirección 0x0B. Sería algo así:

start: INPUT s0, 0A              
          OUTPUT s0, 0B
          JUMP start

Cogeis este programa tan simple, generais la memoria y lo probais a ver que tal. Os debe copiar en el puerto de salida, lo que haya en el de entrada. Así vereis que algo funciona.