[verilog] uitleg van code

beste heren,

ik ben weeer begonnen met verilog en cpld's (boek van free is bestld) maar nu ben ik wat simpele dingen aan het doen maar ik heb toch een vraag over een stukje code


reg [7:0] prescaler;
reg [7:0] pwm_waarde = 12;
reg [7:0] pwm_teller;

assign pwm_clk = prescaler[7];

always @ (posedge clk_50)           // delen de clock door 65536
begin
prescaler <= prescaler + 1;
end

de prescaler zou delen door 65536 echter zou ik zeggen dat hij maar deelt door 255 gezien het prescaler register maar 8 bit breed is(of zie ik iets over het hoofd.

het is ene simpel pwm generatortje en het doet zen werk maar ik snap de ballen van die prescaler.

de vraag is dus:
deelt de prescaler door 65536 en zo ja wat zie ik dan over hoofd?.

//edit: typo's gecorrigeerd

klopt.. delen door 256.

hoogste bit van 8 bit teller.

de redeering zal als volgt geweesst zijn : deel vooraf door 256.
de pwm zelf is nog eens een 8 bit teller.
dus de pwm zelf draait op 1 / 65535 van de hoofdclock.

de pwm wordt aangedreven door 1/256. het hoogste bit van de pwm draait dan op 1/65535 ...

tikvaut dus ...

euhm ja als je zo leest dan klopt het inderdaad wel dank je Free

nu toch wel een beetje de smaak te pakken dus nog maar wat vragen
ik heb het volgende stukje code gemaakt:


module Test
(
input clk_50,
input inp1,
input inp2,
input inp3,
input inp4,
output reg led ,
output reg led1,
output reg led2,
output reg led3,
output reg led4,
output reg led5,
output reg led6,
output reg led7
);
reg [1:0] leds;
reg [7:0] prescaler;
reg [15:0] Key_pre;
reg [7:0] pwm_waarde = 12;
reg [7:0] pwm_teller;

assign pwm_clk = prescaler[7];
assign key_clk = Key_pre[15];

always @ (posedge clk_50)           // delen de clock door 65536
begin
prescaler <= prescaler + 1;
end

always @(posedge pwm_clk)
begin
Key_pre <= Key_pre + 1;
end

always @(posedge key_clk)
begin
if ((inp1 == 0)) pwm_waarde <= pwm_waarde + 5;
if ((inp2 == 0)) pwm_waarde <= pwm_waarde - 5;
if ((inp3 == 0)) leds <= leds + 1;
if ((inp4 == 0)) leds <= leds - 1;
end

always @(posedge pwm_clk)
begin

  pwm_teller <= pwm_teller +1;
  if ((pwm_teller == 0) & (pwm_waarde > 0) & (leds == 1))led <= 0; // actief low, dus 0 sturen
  if (pwm_teller == pwm_waarde) led <= 1;            // 1 sturen = afleggen
  if ((pwm_teller == 0) & (pwm_waarde > 0) & (leds == 2))led1 <= 0;
  if (pwm_teller == pwm_waarde) led1 <= 1;  
led2 = 1;
led3 = 1;
led4 = 1;
led5 = 1;
led6 = 1;
led7 = 1;
end


endmodule

de werking is me volkomen duidelijk.

de vraag is eigenlijk of er volgens jullie nog fouten in zitten(of dat het beter/kleiner kan)

door middel van de 4 drukknoppen op de max2 nanoboard kan men het kanaal kiezen dat gepwmd wordt en de intensiteit.

Een ding: GEBRUIK MAAR EEN ENKEL CLOCK DOMEIN AUB! Je gaat hier rustig van het ene naar het andere over, en da's vragen om problemen. Zeker als je beginner bent. Dus, alle always@'s moeten dezelfde clock hebben. Hier een voorbeeldje:


module dcf77_2 (  input clk_50mhz,
                  output out );

  reg [25:0] divcntr 
  reg puls_1ms;

  always@ (posedge clk_50mhz)
    puls_1ms <= 0;
    if (divcntr = 50_000_000) begin
      puls_1ms <= 1;       //1ms tick maken in 50mhz domein
      divcntr <= 0;
    end else
      divcntr <= divcntr + 1;
  end
  
  always @ (posedge clk_50mhz)begin
    if (puls_1ms)
      counter <= counter + 1;  //incrementen op 1ms ticks
  end

  always @ (posedge clk_50mhz)begin
    out <= counter(0);        // en "legaal" gebruiken in 50mhz domein
  end

endmodule

het feit dat daar 2 clokdomeinen lopen is dat anders ofwel de pwm t langzaam gaat of wel de knoppen te snel

maar wat ik dan zou kunnen doen is gewoon een counter laten tellen en op overflow(of vaste waarde gewoon de knoppen uit laten lezen dus zo zeg maar:


always@ (posedge clk_50)
 if (counter != 24)
  begin
   counter <= counter +1
  end
 if (counter == 24)
  begin  
   counter <= 0
   if ((inp1 == 0)) pwm_waarde <= pwm_waarde + 5;
   if ((inp2 == 0)) pwm_waarde <= pwm_waarde - 5;
   if ((inp3 == 0)) leds <= leds + 1;
   if ((inp4 == 0)) leds <= leds - 1;
  end

Juist, zie mijn stukje code erboven. Het ene proces genereert een 1ms pulsje, maar is wel geclocked met de enkele clk. Een ander proces dat op dezelfde clk loopt, bekijkt dat pulsje en doet iets. Effectief heb je dus elke 1ms een activiteit terwijl alles toch in hetzelfde domein loopt.

In jouw voorbeeld kun je natuurlijk ook schrijven:
if (counter=24)
doe iets
else
doe iets anders
end if;

De tweede check op 24 is niet nodig.

oke thnx flipflop ik heb er nu dit van gebakken:

module Test
(
input clk_50,
input inp1,
input inp2,
input inp3,
input inp4,
output reg led ,
output reg led1,
output reg led2,
output reg led3,
output reg led4,
output reg led5,
output reg led6,
output reg led7
);
reg [1:0] leds;
reg [7:0] prescaler;
reg [23:0] counter;
reg [7:0] pwm_waarde = 12;
reg [7:0] pwm_teller;

assign pwm_clk = prescaler[7];

always @(posedge clk_50)
begin
prescaler <= prescaler + 1;
end

always @(posedge clk_50)
begin
 if (counter == 16777215)
  begin
   counter <= 0;
   if ((inp1 == 0)) pwm_waarde <= pwm_waarde + 5;
   if ((inp2 == 0)) pwm_waarde <= pwm_waarde - 5;
   if ((inp3 == 0)) leds <= leds + 1;
   if ((inp4 == 0)) leds <= leds - 1;
  end
 else
  begin
   counter <= counter + 1;
  end 
 end


always @(posedge pwm_clk)
begin
  pwm_teller <= pwm_teller +1;
  if ((pwm_teller == 0) & (pwm_waarde > 0) & (leds == 1))led <= 0; // actief low, dus 0 sturen
  if (pwm_teller == pwm_waarde) led <= 1;            // 1 sturen = afleggen
  if ((pwm_teller == 0) & (pwm_waarde > 0) & (leds == 2))led1 <= 0;
  if (pwm_teller == pwm_waarde) led1 <= 1;  
led2 = 1;
led3 = 1;
led4 = 1;
led5 = 1;
led6 = 1;
led7 = 1;
end

endmodule

Ik zie nog steeds 2 clkdomeinen. clk_50 en pwm_clk. In het pwm_clk domein gebruik je signalen uit het clk_50 domein (pwm_waarde). Niet fraai. Gaat misschien nog wel goed hier (teken de timing maar uit), maar ooit ga je nat hiermee.
Ik wil het je wel voorkouwen, maar ik heb liever dat je het zelf uitzoekt (eigenlijk heb ik je al een mooi stuk voorbeeldcode gegeven toch? Snap je die code?)

[Bericht gewijzigd door flipflop op (26%)]

flipflop je hebt gelijk
echter heb ik de code hier wel aangepast naar 1 domein.
pwm voorbeeld heb ik echt letterlijk een copy paste van inet afgehaald.

ik snap alleen niet helemaal uit waarom je niet met meerdere clockdomeinen zou werken?
het is ook niet mijn bedoeling dat je het allemaal voorkauwt daar ben ik hier niet voor.

[Bericht gewijzigd door timmie op (16%)]