verilog rekensom

Hum, je voorbeeld steld niet veel voor.

probeer dit eens:

module rekensom
	(
	input			clk,
	input	reg	[3:0]	xp,yp,
	output 	reg	[4:0]	data
	);

always @(posedge clk)
begin
	data  <= ( 11 * yp) + xp;
end
endmodule

Zolang je constanten gaat gebruiken gaat de compiler trouwens die eerst zelf uitrekenen en er een nieuwe constante van maken. Wil je variabelen gebruiken dan moet je ze ook als variable aanbieden. Je schrijfwijze was trouwens totaal foutief. Als je dit compileert dan zal je zien dat hij idd LE's gaat gebruiken. Gebruik je enkel constanten in je bewerking dan is het resultaat een reeks uitgangen waarvan de bits 0 of 1 levels hebben.

bedankt voor je reactie maar dit is niet echt de bedoeling
dit heb ik bedacht om de simpele plot functie van picbasic na te doen in mijn fpga
deze rekensom bereken uit de x en y waarde welk geheugen bitje die 1 of 0 moet maken
en laat dat overeenkomende ledje aan gaan
maar nu maakt die alles 1

<wat> werkt er niet dan? wat voor foutmelding?

Hou je er wel rekening mee dat je met die simpele "*" zomaar een errrug groot block logica aan het neerleggen bent? Als je echt wilt vermenigvuldigen kun je het best een macrocell van de fpga gebruiken (instantieren dus, als die in je fpga zit natuurlijk), of je implementatie zo maken dat de multiply heel simpel wordt (bv alleen x2, 4, 8 etc).
Even goed nadenken over je implementatie dus.

Over je code: wat ik zou doen is de index eerst assignen naar een wire, buiten je always*. Die wire gebruik je dan in je assignment naar data[]. Voordeel hiervan is ook dat je in je simulatie netjes de index kunt zien, wat nu niet kan. Je weet nu alleen dat het "niet werkt", maar je hebt geen idee waar/wanneer/hoe/waardoor/etc.

Antwoord op je vraag hieronder: bedenk eens waar alle bits in data op staan. Dus niet alleen die je assigned hebt, maar alle andere. Ik vermoed dat er iets fout gaat bij de alleerste klokslag. Dan zijn x/y nog ongedefinieerd terwijl je ze al wel in de assignment naar data gebruikt.

[Bericht gewijzigd door flipflop op donderdag 13 augustus 2009 21:53:21 (16%)]

hij geeft geen foutmelding
maar mijn hele matrix gaat aan
en met degen zonder registers gaat alleen de goede aan
en waarom werkt die dan wel zonder register ???

wat ik nou raar vind als ik het zo doe doet die het wel :

reg [0:3] xp,yp;
wire [0:7] xy = (( 11 * yp ) + xp );

always @ (posedge clk_100ms)
begin
//////////////////// PLOT
	xp <= 4;
	yp <= 3;
        ///////////////////////////////////////////// cls
		data [110:120] <= 11'b00000000000;
		data [99:109]  <= 11'b00000000000;
		data [88:98]   <= 11'b00000000000;
		data [77:87]   <= 11'b00000000000;
		data [66:76]   <= 11'b00000000000;
		data [55:65]   <= 11'b00000000000;
		data [44:54]   <= 11'b00000000000;
		data [33:43]   <= 11'b00000000000;
		data [22:32]   <= 11'b00000000000;
		data [11:21]   <= 11'b00000000000;
		data [0:10]    <= 11'b00000000000;	
        /////////////////////////////////////////////
	data [xy] <= 1;
//////////////////// PLOT
end

[Bericht gewijzigd door Anoniem op donderdag 13 augustus 2009 22:07:34 (71%)]

En wat als je die assignments met 000000 weglaat?

dan gaat de hele matrix aan

Hmm, da's wel vreemd. Op zich assign je slechts 1 flipflop naar '1'. De andere die je niet "aanraakt" bij een klokslag zouden gewoon hun oude stand moeten houden (uit dus). Reset waardes zijn in de meeste fpga's '0', dus een reset is niet strikt nodig (al doe ik dat wel altijd, je voorkomt afhankelijkheid van het type/merk fpga).
Het komt denk ik neer op de definitie van de Verilog standaard over het assignen naar een array. Misschien moet je altijd het hele array assignen en krijg je undefined waardes als je dat niet doet. Op zich is je laatste oplossing niet zo verkeerd overigens. Als kun je ook gewoon zeggen data[120:0]<=0 of zelfs data<=0

ps, met een simpele simulatie had je het probleem al lang gevonden!

ja maar die hele simulatie lukt me nog niet (stom van me maar ik weet niet hoe simulatie werkt )
maar bedankt voor de hulp
initial data <= 0; werkt ook goed

[Bericht gewijzigd door Anoniem op donderdag 13 augustus 2009 22:56:38 (12%)]

gebruik je quartus?

Zo ja:

- klik op *new*
- selecteerd:
*- Verification/Debugging Files
**-Vector Waveform File

-dubbel klik op het linker gedeelte van het nieuwe scherm
-klik *node finder*
-selecteer je top-level signals
-selecteer de juiste *radix* (binair/numeric/hex etc)
-vervolgens kan je in het rechter gedeelte, per (input) lijn gegevens in voeren:

-rechtslik: value: het soort waarde

Wanneer je een "testbench" hebt "geschreven":
-ga naar project settings
-simulator settings
-simulation: Timing
-selecteer de zojuist gemaakte (en opgeslagen) vector wavefile
-boven in menu balk:
*-processing
*-generate functional simulation netlist

daarna kan je je testbench simuleren:
-processing
-start simulation

Als je geen quartus gebruikt, dan kan ik je niet helpen

Op 13 augustus 2009 22:25:03 schreef flipflop:
Hmm, da's wel vreemd. Op zich assign je slechts 1 flipflop naar '1'. De andere die je niet "aanraakt" bij een klokslag zouden gewoon hun oude stand moeten houden (uit dus). Reset waardes zijn in de meeste fpga's '0', dus een reset is niet strikt nodig (al doe ik dat wel altijd, je voorkomt afhankelijkheid van het type/merk fpga).

Ik zou zeggen: Als jij niet zegt wat er moet gebeuren, dan mag de compiler kiezen wat voor hem het makkelijkste is. Als jij zegt dat een bitje nooit 0 MOET worden, dan MAG ie altijd 1 zijn. Dus de compiler kiest de weg die het minste hardware kost: alle bitjes zijn permanent 1.

Als je specificeert dat het bij reset 0 moet worden, dan heeft de compiler een probleem en moet ie aan het werk...

Dat is dus niet zo. Als je in een geklokt proces een flipflop modeleert, dan hoef je niet bij elke klokslag een assignment te doen. Het houdt gewoon z'n oude waarde. Dus:

  always@ (posedge clk)
    if (pietje='1') begin
      out <= ~out;
    end;
  end

..is hetzelfde als:

  always@ (posedge clk)
    if (pietje='1') begin
      out <= ~out;
    end else
      out <= out;
  end

In het laatste geval assign je bij elke klokslag iets, maar omdat onder de else gewoon de oude waarde weer ingeklokt wordt mag je dat gerust weglaten. Ik heb hiet geen reset statement bij staan, wat op zich wel mooier is anders heb je een 'x' tot de eerste klokslag, wat dan weer ongewenst gedrag kan geven.

bedank voor alle hulp
ik ga trouwens dat boek van free ook bestellen (Programmeerbare Logica van 0 en 1 tot fpga)

het probleem met je bewerking is dat de synthesizer niet kan resolven hoe breed de uitkomst is.

bij het gebruik van constanten wordt dat , tot op zeker hoogte, wel gedaan.

eigenlijk moet je schrijven

reg data [7:0] [7:0];
wire calc [7:0];

always_comb begin
 calc = (( 8'd5 * 8'd11) + 8'd5);
end

always @ (posedge clk_100ms)
begin
	data [calc] <= 1;
end

je forceert nu een uitkomst op de juiste breedte.
als je met variabelen gaat werken heeft de compiler het moeilijk. zeker als je bron variabelen anders gedimensioneerd zijn dan je doel.

in jouw geval zou dit moeten werken :

wire calc [7:0];
reg [3:0] yp;
reg [7:0] xp;
always_comb begin
 calc = (4'd11 * yp) + xp;
end

daarmee forceer je een 4bit x 4 bit bewerking. ( 4x4 geeft een 8 bit uitkomst. daar tel je een 8 bit getal bij op.
de dimensies kloppen nu.

ik heb weer iets nieuws en leuks geleerd
de task maakt het een stuk minder ingewikkeld vind ik
nu lijk het echt op picbasic
mission accomplished
volgende missie de line functie

zie mijn code

always @ (posedge clk_100ms)
begin
	
plot (5,5,data);
	
end


task plot;

	input [0:3] x;
	input [0:3] y;
	output [0:120] data;

	data [( 11 * y ) + x ] <= 1;	

endtask

vraagje
is er ook een manier van simuleren waarin je ieder registertje van je code kan bekijken
en bij de simulatie wat voor value moet je een output geven ???
het lukt me nog heelemaal niet om te simuleren

[Bericht gewijzigd door Anoniem op zondag 23 augustus 2009 22:11:48 (15%)]

Huh? Wat vraag je nou precies?
In een simulatie kun je ELK signaal in je design bekijken. Je kunt overal bij, da's nou juist het mooie. Een output hoef je geen waarde te geven want je design doet dat zelf al. Inputs moet je wel waardes geven, een stimulus heet dat. Door je stimuli breng je je design in een "stand" waarvan je het gedrag wilt testen.
Bv je hebt een knipperlicht dat je uit kunt zetten door een enable signaal. Dan test je bv eerst het knipperen door enable op '1' te zetten (en kijkt of de uitgang knippert). Vervolgens zet je enable op '0' en controlleert of het knipperen ophoudt. Etc.

hij doet het niet
ik heb dit staan
http://www.uploadarchief.net/files/download/dadfga.jpg
maar hij doet dit
http://www.uploadarchief.net/files/download/adfga.jpg
maar ik heb precies gedaan wat u zei

_{Mod-edit: Posters zijn ongewenst}

[Bericht gewijzigd door Henry S. op dinsdag 25 augustus 2009 19:04:49 (19%)]

Heb je wel een testbench gemaakt? Een verilog file waar je je design in instantieerd, je stimuli genereert, en die verbindt met je design inputs? Post m eens.

@flipflop, dat hoeft niet, dat doet hij al d.m.v. die simulatie.vwf.

Dat is je testbench, echter enige nadeel daarvan is, is dat je er geen conditionele statements in kan maken bijvoorbeeld

Op 24 augustus 2009 22:00:14 schreef flipflop:
Heb je wel een testbench gemaakt? Een verilog file waar je je design in instantieerd, je stimuli genereert, en die verbindt met je design inputs? Post m eens.

ik begrijp u effen niet

nog een vraagje
ik heb deze code hij hoort het een keer te doen maar hij gaat oneindig door

repeat (1) begin
xp <= xp + 1;
plot (1,xp,5,data);
end

is repeat niet een vergelijking?

zo ja, dan is 1 altijd true

op internet stond dat die dat aantal keer bleef herhalen en dan stopte

nu ben ik weer een tijdje (~5 dagen) bezig met de line functie
maar hij doet het nog niet
na wanhopig zoek heb ik nog niks gevonden en van alles uitgeprobeerd

dit is de code

module matrix
	(
	input clk,clk_100ms,
	output reg [0:10] x,y
	);

reg [0:3] cnt;
reg [0:120] data;
reg [0:3] xp,yp;
reg db;

vertaal gedeelte 



always @ (posedge clk_100ms)
begin


line (1,2,1,10,9,data);

	
end


task plot;
	input bitje;
	input [0:3] x4;
	input [0:3] y4;
	inout [0:120] data;

	data [( 11 * y4 ) + x4 ] <= bitje;	

endtask

task line;
	input bitje;
	input [0:3] x1;
	input [0:3] y1;
	input [0:3] x2;
	input [0:3] y2;
	inout [0:120] data;
	reg [0:3] x3,y3;
	reg [0:3] cnt1,cnt2,cnt3;
	


	if (cnt1 != 1)
	begin
		x3 <= x1;
		y3 <= y1;
		cnt1 <= 1;
	end
	else if ( cnt2 != waarde2(waarde(x1,x2),waarde(y1,y2)))
	begin
		if (cnt3 != waarde2(waarde(x1,x2),waarde(y1,y2)))
		begin
			cnt3 <= cnt3 + 1;
			y3 <= y3 + 1;
			plot (bitje,x3,y3,data);
		end 
		else begin
			x3 <= x3 + 1;
			cnt3 <= 0;
			cnt1 <= 0;
			cnt2 <= cnt2 + 1;
			plot (bitje,x3,y3,data);
		end
	end
	else cnt2 <= 0;		
	
	
	
endtask

function [0:3] waarde;
input [0:3] x1,x2;

begin
	if (x1 >= x2)waarde = (x1 + 1) - (x2 + 1);
	else waarde = (x2 + 1) - (x1 + 1);
end
endfunction

function [0:3] waarde2;
input [0:3] x1,x2;

begin
	if (x1 >= x2)waarde2 = (x1 + 1) / (x2 + 1);
	else waarde2 = (x2 + 1) / (x1 + 1);
end
endfunction
	
initial 
begin
data <= 0;
end	

endmodule