Registro Serie Parallelo

[SalvoPappa]

Cioa a tutti,
vi posto il codice di un registro Serie Parallelo:

Code: Select all

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
ENTITY RegistroSerieParallelo IS

--Entità bit

PORT(    d: IN std_logic ;
         q0,q1,q2: INOUT std_logic ;
         clk, reset: IN std_logic;
         q3: OUT std_logic);
END RegistroSerieParallelo;
ARCHITECTURE struct OF RegistroSerieParallelo IS
BEGIN
  comb: PROCESS (clk,reset)
     BEGIN
         IF rising_edge(clk) THEN
         IF(reset='1') THEN
            q0<='0';             --Inizializzazione bit
            q1<='0';
            q2<='0';
            q3<='0';
         ELSE   
            q0<= d;
            q1<=q0;
            q2<=q1;
            q3<=q2;
         END IF;   
      END IF;   
     END PROCESS;
END struct;

La compilazione non mi ha dato nessun problema; quindi il mio prossimo passo sarebbe stato la simulazione, ma non riesco a capire come fare.

Grazie per l'aiuto.

[Leonardo]

Salve,
Utilizza l'ambiente di sviluppo Quartus di Altera in abbinata a ModelSim o altri software?

[deluca]

Ben arrivato SalvoPappa!!

Quando dici: "ma non riesco a capire come fare"......

Stai usando Quartus II?... hai installato Modelsim?

Ci sarebbero altri software e simulatori più semplici,
ma se vuoi approcciare agli FPGA Altera allora il consiglio è Quartus + Modelsim anche nelle versioni Free

[SalvoPappa]

Ciao a tutti,
io utilizzo sia il Quartus II che il ModelSim; ho trovato una guida, come avete scritto in alcuni post precedenti e la sto seguendo. Quindi sono riuscito a risolvere i problemi iniziali che avevo riscontrato.

Avrei un altra domanda:
Quali progetti potrei fare per aver una maggiore dimistichezza con questi sistemi?

Grazie a tutti

[Leonardo]

Per iniziare i "classici": decoder, multiplexer, sommatori, moltiplicatori, modulo da Hex a display 7 segmenti, flip-flop di vari tipi, registri a scorrimento, modulo ram, semplici FSM per generare pattern, etc..

Alcune idee di esercizi più strutturati:
- ALU senza e con pipeline
- Modulo UART
- Modulo di Debouncing
- Modulo VGA

Ciao

[SalvoPappa]

Ciao Leonardo,
ho provato a concentrarmi su un ALU senza pipeline a 8 bit, ho compilato tutto senza nessun errore; dopo di chè volevo simularlo con ModelSim, pensavo di aver risolto il mio problemino, ma in relatà:
-ho verificato che all'avvio della simulazione nel menù Tools / Options / General / EDA Tool Option nel campo ModelSim-Altera è impostato il percorso corretto del programma (ad esempio C:\altera\13.0\modelsim_ase\win32aloem) ;

-appena clicco sul tasto della Simulazione RTL mi spunta questo problema(vedi allegato).

Qualche idea?

Grazie

[Leonardo]

Prova ad aggiungere la slash finale al percorso, ad esempio: C:\altera\13.1\modelsim_ase\win32aloem\

Ciao

[legacy]

ALU con pipeline ? Mi sono perso qualcosa ?

CPU con o senza pipeline, dove la mettere la pipeline in una ALU ?

[deluca]

Benissimo SP,
vedo che stai facendo progressi,

perchè non postare il codice della tua ALU nel forum?

quali istruzioni hai pensato di implementare?

[Leonardo]

@legacy: In letteratura sono stati descritti modelli di ALU Floating Point con pipeline dove ad esempio per eseguire una addizione vengono svolte le seguenti operazioni: zero check, align, add_sub, normalize

A livello didattico un semplice esercizio potrebbe essere l'implementazione di un'ALU "originale" con una pipeline (quindi sincrona) per certe operazioni come ad esempio x^4 facilmente suddivisibili.

[legacy]

Le features elencate valgono per il floating point, ovvero per una FPU, non centrano assolutamente NULLA con una ALU, che e' logico matematica-integer e che pertanto non ha nulla a che fare con il pipelining per il motivo che non porta alcun vantaggio, cosa che invece c'e' in una FPU.

[Leonardo]

@legacy: se vuoi approfondire, l'articolo a cui mi riferivo è intitolato "Pipeline Floating Point ALU Design with VHDL".

Nell'esempio che proponevo (x^4) la soluzione era abbastanza semplice:


Sincrona si riferiva al fatto che la ALU era sincrona ad un segnale di clock per temporizzare le due diverse fasi
Originale si riferiva invece alla atipicità dell'istruzione, in genere non presente in una classica ALU. Utile sicuramente a livello didattico per capire meglio le pipeline.

Nota: Ovviamente non tutte le istruzioni di una ALU sono implementabili con pipeline

[legacy]

Puo' essere interessante descrivere una ALU dove la moltiplicazione e la divisione/modulo resto ad N stadi paralleli, questo non e' pipelining, pero' risulta molto interessante e ben + facile da capire, metabolizzare e realizzare: nel caso consiglio di scrivere il tutto prima in software, giusto per toccare con mano l'algoritmo che, nel caso della divisione, a gran sorpresa, e' … quello insegnato alle elementari per la divisione a più cifre

[legacy]

@legacy: se vuoi approfondire, l'articolo a cui mi riferivo è intitolato "Pipeline Floating Point ALU Design with VHDL".

A me frega zero che tizio ignoto scrive "cavolaggini" nel titolo: se l'accrocchio fa floating point si deve chiamare floating point unit aka FPU e non ALU, per ALU si intente "coso che fa operazioni Aritmetiche Logiche" (1), i due oggetti hanno non solo funzioni diversi ma anche criteri di progetto diversi, se si mischiano le cose non si capisce più nulla


(1) la ALU, tra la varie faccende, manipola il registro.PC - ne consegue che -> la parte Aritmetica deve essere integer, altrimenti i salti, condizionati o incondizionati (che sono unsigned integer op), come li fai ?

[deluca]

Scusate ragazzi,
vi inviterei ad abbassare un pò i toni, non mi piacerebbe che questo forum diventasse un ring....

[SalvoPappa]

Ciao a tutti,
posto di seguito il codice utilizzato per lo sviluppo dell'ALU.
Accetto qualsiasi tipo di consiglio, non sono molto ferrato; quindi se posso migliorare sia il codice che il mio modo di approcciarmi, dite pure.
Ho rilevato una solo problema, cioè quello di incrementare o decrementare un array di bit.

Vi ringrazio anticipatamente.

Code: Select all

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity ALU is
port (
    signal clk   : in  std_logic;
    signal aout  : in  std_logic_vector(7 downto 0);
    signal bout  : in  std_logic_vector(7 downto 0);
    signal y     : out std_logic_vector(7 downto 0);
    signal op    : in  std_logic_vector(3  downto 0);
    signal cout  : out std_logic;
    signal flag  : out std_logic);
end ALU;

ARCHITECTURE behavioral of ALU is

component MuxA is
port(
    signal a     : in  std_logic_vector(7 downto 0);
    signal na    : in  std_logic_vector(7 downto 0);
    signal op    : in  std_logic_vector(3  downto 0);
    signal clk   : in  std_logic;
    signal aout  : out std_logic_vector(7 downto 0));

end component MuxA;

component MuxB is
port  (
    signal b     : in  std_logic_vector(7 downto 0);
    signal nb    : in  std_logic_vector(7 downto 0);
    signal op    : in  std_logic_vector(3  downto 0);
    signal clk   : in  std_logic;
    signal bout  : out  std_logic_vector(7 downto 0));

end component MuxB;

   type op_type is (op_add, op_sub, op_aincr, op_adecr, op_bincr, op_bdecr, op_atras, op_btras, op_anot, op_bnot, op_and, op_or, op_a_and_nb, op_a_xor_nb, op_a_nor_nb, op_n_a_xor_b, op_nop);
   signal enum_op : op_type;
   signal reg       : std_logic_vector(8 downto 0);
   
begin

 process(op)
   begin
      case op is
      when "0000" => enum_op <= op_add;
      when "0001" => enum_op <= op_sub;
      when "0010" => enum_op <= op_aincr;
      when "0011" => enum_op <= op_adecr;
      when "0100" => enum_op <= op_bincr;
      when "0101" => enum_op <= op_bdecr;
      when "0110" => enum_op <= op_atras;
      when "0111" => enum_op <= op_btras;
      when "1000" => enum_op <= op_anot;
      when "1001" => enum_op <= op_bnot;
      when "1010" => enum_op <= op_and;
      when "1011" => enum_op <= op_or;
      when "1100" => enum_op <= op_a_and_nb;
      when "1110" => enum_op <= op_a_xor_nb;
      when "1101" => enum_op <= op_a_nor_nb;
      when "1111" => enum_op <= op_n_a_xor_b;
      when others => enum_op <= op_nop;
      end case;
   end process;

   process(clk)
   begin
      if rising_edge(clk) then
            flag <= '0';
         case enum_op is           
         when op_add       =>
            reg <= std_logic_vector((unsigned("0" & aout) + unsigned(bout)));
         when op_sub       =>
            if(aout >= bout) then
               reg <= std_logic_vector(unsigned("0" & aout) - unsigned(bout));
               flag <= '0';
            else
               reg <= std_logic_vector(unsigned("0" & bout) - unsigned(aout));
               flag <= '1';
            end if;
         when op_aincr     =>   reg <= '0' & (aout SRL "00000001");
         when op_adecr     =>   reg <= '0' & (aout - "00000001");
         when op_bincr     =>   reg <= '0' & (bout + '00000001');   
         when op_bdecr     =>   reg <= '0' & (bout - '00000001');
         when op_atras     =>   reg <= '0' & aout;
         when op_btras     =>   reg <= '0' & bout;
         when op_anot      =>   reg <= '0' & not aout;
         when op_bnot      =>   reg <= '0' & not bout;
         when op_and       =>   reg <= '0' & (aout and bout);
         when op_or        =>   reg <= '0' & aout or bout;
         when op_a_and_nb  =>   reg <= '0' & (aout and not bout);
         when op_a_xor_nb  =>   reg <= '0' & (aout xor not bout);
         when op_a_nor_nb  =>   reg <= '0' & (aout or not bout);
         when op_n_a_xor_b =>   reg <= '0' & (not(aout xor bout));
         when op_nop       =>   reg <= "000000000";
                    
      end case;
      end if;
   end process;

   y <= reg(7 downto 0);
   cout <= reg(8);

end ARCHITECTURE;


[deluca]

@salvopappa,
Vedo che hai fatto un passetto in avanti.... anzi di più, specialmente calcolando il breve tempo da quando hai iniziato.
Buona la struttura del codice e il fatto che hai pensato di poter negare gli operandi prima di iniettarli sulla alu per aumentare le operazioni disponibili.

L'idea di partire subito con una ALU è azzardata, ma a questo punto, visto il risultato, potresti passare alla implementazione di una CPU completa.

(@legacy)
contento? Ho rimosso "microcodice" così evitiamo di confondere salvoP ok?

Stiamo in ascolto.....