CID Problema in verilog

[caddyct]

Problema 2: Sa se proiecteze un circuit care calculeaza M = 2^(2*N) pentru N un numar reprezentat pe 4 biti.

 

Am inceput cu circuit de shift-are.Dar nu stiu cum sa mai continui.

Am scris si in Xilinx codul si am obtinut urmatoarea schema in urma sintezi:

 

 

 

codul este

 

module shifter( DI, sel, SO ); input  [4] DI; input  [1] sel; output [4] SO; reg[4] SO;   always @(DI or sel)   begin     case (sel)       2'b00   : SO <= DI;       2'b01   : SO <= DI << 1;       2'b10   : SO <= DI << 2;       default : SO <= DI << 3;     endcase   end endmodule

Aveti vreo idee sau o sugestie cum as putea continua sau rezolva aceasta problema?

[cirip]

Salut,Ceva este in neregula. 2^(2*N)=4^N (Sper ca nu am uitat operatiile cu puteri). Daca N e reprezentat pe 4 biti, atunci N maxim este 15, iar 4^N=1.073.741.824=0x4000 0000, care se reprezinta pe 32 de biti. Deci rezultatul nu are cum sa fie pe 5 biti. Prin urmare in loc de S[4] cred ca mai degraba ar fi S[31].Cred ca circuitul se poate sintetiza combinational cu o bucla for, dar mi-e lene sa ma gandesc acum Poate mai incolo, daca nu te ajuta altcineva sau daca nu il rezolvi singur.

[caddyct]

4 la puterea N ( pe 4 biti ) care poate lua valoarea maxima 15 deci noi trebuie sa afisam numarul 4^15=2^30 adica un numar pe 30 biti.sau cum ai zis tu.oricum vor trebui 32 de biti.dar nu stiu cum sa fac asta in Verilog.ma gandisem la o bucla dar nu stiu.am sa mai incerc.

[EmyRulz]

O sugesie.... 2 la orice putere in binar are o forma foarte simpla si anume 1 si un nr de zerouri egal cu puterea. Deci tu trebuie sa pui in registrul tau 1 pe bitul 2*N+1 si restul 0.

[caddyct]

//modulul de logical shifter e creat prin instantierea unui MUX 4:1 //out ar trebuii sa fie [31] module Shifter(output [3] out ,                    input [3] in ,                    input [1] shiftDim);mux4_4 shiftMux(.out(out ),                       .in0(in ),                       .in1({in[2], 1'b0}),                       .in2({in[1], 2'b0}),                       .in3({in[0] , 3'b0}),                       .sel(shiftDim ));endmodulemodule mux4_4(output [3] out,                    input [3] in0, in1, in2, in3,                    input [1] sel); // 4MUX_2wire[3] out1, out0; mux2_4 mux(out, out0, out1, sel[1]), mux1(out1, in2, in3, sel[0]), mux0(out0, in0, in1, sel[0]); endmodule//am folosit acest modul cu parametri pt a defini  MUX de n-biti//In loc de n=4 ar trebuii sa pun 8?Caz in care o sa fi si input [7] in0,in1module mux2_4 #(parameter n = 4)(output [n-1:0] out,                                               input [n-1:0] in0, in1,                                               input sel);                                                assign out = sel ? in1 : in0; endmodule

Idei?

[cirip]

Idei?

Una singura. Simuleaza-l si vezi daca face ce trebuie! Imagineaza cateva cazuri pe care le calculezi de mana, simuleaza si vezi daca ajunge la rezultatul corect. E greu sa prinzi gainile prin simpla inspectie a codului. Eu oricum nu inteleg cum poti sa folosesti un MUX. Ai un numar de 4 biti la intrare si o iesire pe 31 de biti. Asta suna mai degraba a demux.Asa, ciobaneste poti sa faci cu 16 declaratii case (de la 0 la 15), dar probabil ca exista si optiuni mai elegante.

[caddyct]

in al 2 - lea cod n-am folosit un sg mux.am folosit mai multe.in mod normal ar trebuii sa fie 32 de MUX - celule elementare de 4:1,iesirile fiind astfel de 1 bit fiecare.si sa insirui 32 de mux-uri asa e cam aiurea.trebuie sa gasesc o metoda mai eficienta pentru calculul respectiv.ce e in cod e pentru un modul de shiftare cu intrare de [3] si iesire [3]

[cirip]

M-ai provocat Am vrut sa vad daca imi mai amintesc ...

Pe baza sugestiei lui EmyRulz, a iesit foarte simplu si compact. E mai stufos modulul de test decat shifterul pr zis. Uite aici:

 

//Sa se proiecteze un circuit care calculeaza M = 2^(2*N) pentru N un numar reprezentat pe 4 bitimodule shifter1(N_in1, M_out1);input [3] N_in1;output [31] M_out1;	assign M_out1 = 1<<(2*N_in1);endmodule//=====================================// Modulul care incapsuleaza shifterul si stimulii//=====================================module test_module();reg [3] N;wire [31] M;// Monitorizare semnale N si M//=====================================initial	$monitor($time, " N= %h,  M= %h", N, M);// Generare stimuli//=====================================initialbegin	N = 4'h0;#10	N = 4'h1;#10	N = 4'h2;#10	N = 4'h3;#10	N = 4'h4;#10	N = 4'h5;#10	N = 4'h6;#10	N = 4'h7;#10	N = 4'h7;#10	N = 4'hF;#10	N = 4'hE;#10	N = 4'hD;#10	N = 4'hC;#10	N = 4'hB;#10	N = 4'hA;#10	N = 4'h8;#10	N = 4'h4;		// inca doua asa la shto#10	N = 4'hC;#10	$finish;		// Hai, gata, valea!end//=====================================// Instantierea shifterului in modulul de testshifter1 sh1(N, M);// Declaratia de sfarsit a modulului de testendmodule

Si rezultatul simularii:

                   0 N= 0,  M= 00000001                  10 N= 1,  M= 00000004                  20 N= 2,  M= 00000010                  30 N= 3,  M= 00000040                  40 N= 4,  M= 00000100                  50 N= 5,  M= 00000400                  60 N= 6,  M= 00001000                  70 N= 7,  M= 00004000                  90 N= f,  M= 40000000                 100 N= e,  M= 10000000                 110 N= d,  M= 04000000                 120 N= c,  M= 01000000                 130 N= b,  M= 00400000                 140 N= a,  M= 00100000                 150 N= 8,  M= 00010000                 160 N= 4,  M= 00000100                 170 N= c,  M= 01000000	80 State changes on observable nets.	Simulation stopped at the end of time 180.Ready:

Cred ca se poate face si cu always @(N_in1).

 

Bafta!

[caddyct]

Multumesc cirip pentru ajutorul acordat.

Am sa il introduc in Modelsim impreuna cu benchtest-ul sa obtin si formele de unda.

Iar din Xilinx sa ii fac sinteza si de asemenea sa obtin si schema RTL.

 

Inainte sa-mi raspunzi tu mai citisem cartea de cid (noi facem cid + curs de verilog la cursul de cid) si m-am gandit ca ar fi mers si asa:

 

module dmux #(parameter inDim = n)(input [inDim - 1:0] sel ,                                                          input enable,                                                          output [(1 << inDim) - 1:0] out );assign out = enable << sel;// assign notOut = ~({15'b0, ~notEnable} << sel);  (varianta din poza)endmodule

 

unde ar fi 4 in cazul meu.

Dar raspunsul tau pare mai bun decat la ce m-am gandit eu.