Wat leren we vandaag ? Logica maken in CPLD/FPGA met SystemVerilog

Vooraleer we in de ontwikkelomgeving en taal duiken eerst even uitleggen wat een CPLD/FPGA is.

CPLD : Complex Programmable Logic Device.
Deze zijn een voortborduursel op de PLD circuits zoals de PAL en GAL. Zie het als een hoop PAL en GAL die ze aan elkaar geknoopt hebben en in een doos gestopt. Het is ook letterlijk dat.

Historie
--------------------------

Een PAL of GAL (Programmable Array Logic) is niks anders dan een wolk logica waar je de in en uitgangen via een programma aan elkaar knoopt. Sommige PALs zijn puur AND,OR,NOT poorten, andere hebben flipflops aan boord.

Die (primitieve) devices hadden 8 tot 10 ingangen en 8 tot 10 uitgangen. Intern zijn de uitgang signalen teruggekoppeld zodat je die kan herbruiken in vergelijkingen.

PAL werdt initieel ontwikkeld door MMI (Monolithic Memories). Die hebben een heel leuk databoek met tekeningetjes. http://www.bitsavers.org/components/mmi/_dataBooks/1983_MMI_PAL_Handbo…

Het eerste hoofdstuk legt in veel detail uit wat een PAL nu eigenlijk is.

De vraag naar die dingen had tot gevolg dat de "grote" siliciumboeren op de kar springen. TI, AMD en begonnen die dingen ook te maken.
De vraag naar meer logica en meer flipflops had het gevolg dat de hele grote begonnen mee te spelen : Intel.

Intel ontwikkelde de eerste CPLD : ipld600. Die was niks anders dan een paar PLD blokken aan elkaar gelijmd met wat extra verbindingsmogelijkheden.

Na een paar jaar verloor intel interesse en deed het een spin-off. dat werd Altera. ( wat ze later terug opkochten , en nu weer een spinoff van gedaan hebben. intel en zijn zottigheden)

De CPLD architectuur was nogal rigide en het gelimiteerd aantal verbindingen tussen de interne PLD blokken maakte dat het niet altijd mogelijk was om de devices volledig te benutten. Het was soms onmogelijk om een flipflop te bereiken simpelweg omdat er geen verbindingsdraden waren. Zie het als een gaatjesprint. Je moet je draadjes ook de gaatjes laten volgen. Als er geen gaatjes meer zijn heb je een probleem. Het aantal "gaatjes" in een CPLD is beperkt en de verbindingen blokkeren elkaar op den duur.

Tijd voor een archtictuur verandering. In plaats van grote "PLD" blokken met telkens 10 ingangen en 8 uitgangen : macrocellen. De basis is 1 of 2 flipflops met aan elke pin van de flipflop een kleine wolk logica ( maximum 4 signalen ) die je kan instellen. De flipflops zelf zijn complex. Dit zijn geen kleine RS of JK flipflops maar complexe cellen die synchroon en asynchroon kunnen werken. Je kan daar letterlijk elk type flipflop van maken. RS JK JKMS met synchrone en asynchrone rest, met of zonder prioriteit, met enables, disables.

Die macrocelletjes zijn relatief klein vergeleken met een PLD blok waar je 8 flipflops hebt met veel minder mogelijke instellingen. Maar terzelfdertijd zijn ze veel flexibeler. Maak daar nu een groot tapijt van die macrocellen en leg daar veel verbindingsdraden tussen en je krijgt een FPGA. Er zijn korte verbindingsdraadjes en ook heel lange. Er zijn rasternetwerken om globale signalen zoals een clock, output enable te verspreiden zonder dat je daar draadjes hoeft voor op te offeren.

Voor de gebruiker maakt het tegenwoordig niet veel meer uit. De tijd waar je zelf de prikkertjes ( de fusemap) moest met de hand aanmaken , of simpele logische vergelijkingen maken met programmas zoals Palasm , geschreven in fortran op een PDP11... zijn voltooid verleden stenen tijdperk tijd.

De moderne CPLD zijn niks anders dan verkapte FPGA met configuratie geheugen aan boord. Je weet het niet, maar eigenlijk zijn het veel meer FPGA architecturen dan de originiele CPLD architecturen.

Wat is Verilog ?

Verilog is een taal die in de jaren stillekes (1983) ontwikkeld is om logica mee te bouwen (in tegenstelling tot VHDL waar je ook een vijs of een ezel mee kan beschrijven. Door middel van een bibliotheek kan je VHDL gebruiken om logica te bouwen. Dat maakt het in mijn opinie onnodig complex en brengt te veel ballast mee. Andere discussie die we hier niet gaan voeren)

De taal heeft door de jaren verschillende revisies ondergaan (de meest recente versie is 2023).

je kan de historie hier lezen : https://en.wikipedia.org/wiki/Verilog

De eerste versies vergden nogal wat keyboard werk en waren deels gestructureerd zoals de C-taal. Je had header files en moest bepaalde dingen herhalen. Naar mate de projecten groter en groter werden begon dat een hindernis te worden. Logica wordt niet ontwikkled zoals software. Je moet een module ( 1 bron bestand) standalone kunnen testen. Je moet dat letterlijk uit ene project kunnen halen en synthetiseren zonder andere externe bestanden nodig te hebben. Grote projecten hebben enorme synthese tijdspannes. Uren tot dagen. Je moet in stukjes kunnen werken. een functieblok moet gemaakt kunnen worden zonder dat je dependencies hebt op het geheel.

De Verilog taal evolutie heeft daarop ingespeeld door al die "ballast" weg te werken. Het benodigde werk van de ontwikkelaar werdt eenvoudiger en er is minder tikwerk nodig wat leidt tot minder "fauten".

SystemVerilog bouwt daar op verder door abstractie toe te voegen en ingebouwde verificatie en een gans pak andere zaken.

Verilog is GEEN PROGRAMMEERTAAL ! het is een synthese taal.
We bouwen hardware. Geen programmas die sequentieel afgehandeld worden.

De Verilog taal beschrijft, textueel, de gewenste functionaliteit die dan vertaald wordt naar poorten en flipflops. Dit zijn geen instructies die door een processor uitgevoerd worden.

Een computerprogramma is eigenlijk half werk . je maakt een reeks instructies die dan door ene processor herhaald worden om een bepaalde functie uit te voeren.

Een verilog beschrijving doet alle werk vooraf en er is daar geen herhaling nodig "at runtime". er is helemaal geen runtime.

Een voorbeeld :
Maak een blok dat een 16 bit getal neemt van een 16 bit ingang , dat deelt door 2, en er dan 1 bij optelt. en naar buiten stuurt op een andere 16 bit poort

Een 8 bit microcontroller heeft daar werk mee.
- lees MSB in , lees LSB in. deel door twee (je kan right shiften maar je moet het laagste bit van het hoogste byte overzetten). tel er dan 1 bij op en stuur dat naar de uitgang.

move MSB x    // haal bovenste 8 bit op
move LSB y   // haal onderste 8 bit op
shift right LSB  // shuif de laagste bits 1 op naar rechts
if x.0 =1 then y.7 =1  // zet laagste bit van bovenste 8 bit over naar laagste 8 bit
y = y+1  // tel 1 op bij laagste 8 bit
if y=0 then x=x+1  // all laagste 8 bit nu nul is hebben we een overflow en moet het hoogste byte eentje bijtellen
move x MSB_OUT  // zend msb uit
move Y LSB_out // zend lsb uit

Er zijn meerdere oplossingen mogelijk en met wat kunst en vliegwerk , of een 16 bit cpu werkt het anders.
De 16 bit waardes worden ook niet synchroon opgehaald og uitgeschreven. als de waarde verandert tussen twee instructies heb je ene probleem.
De snelheid waarmee dit uitgevoerd wordt is gelimiteerd door de kloksnelheid van de processor , de lengte an het programma en hoe lang de instructies zelf duren.

Het zelfde werk met logica:

ingang [15:0] waarde  // we hebben 16 ingangen nodig (15 to 0) die wa beschouwen als "waarde"
uitgang [15:0] nieuwe_waarde // en 16 uitgangen nieuwe_waarde

uitgang[15:0] = {0,ingang[15:1]} + 16'd1

Dat gedoe met bitjes schuiven is in logica nergens voor nodig. Je smijt gewoon dat laagste bit weg. ( je werkt alleen met bits 15 tot 1. Bit nul is irellevant)

De logica daar voor nodig ? NIKS. NUL, NADA, ZERO . Dat zijn gewoon 15 draden ! geen AND, OR, NOT poortjes, geen flipflops, en vooral geen tijd . Alleen gelimiteerd door de snelheid van de electronen.

De constructie {0,ingang[15:1]} betekent : maak een 16 bit waarde aan , het hoogste bit is 0 en gevolgd door de volgende signalen in de gegeven volgorde (van 15 tot 1)

Tel dan bij die nieuwe constructie 1 op en stuur dat naar buiten. Een adder is een wolkje combinatorische logica.

Een ander voorbeeld : maak een programme wat een 8 bit getal inleest en de bits omdraait (lsb en msb swap)
Dat is flink wat werk in een computerprogramma.

In programmeerbare logica ?

uitgang[7:0] = ingang[0:7]

Benodigde logica ? NIKS. Alleen wat draden !

in werkelijkheid zal de synthesizer een foutmelding geven omdat het bit order in de vector (een waarde langer dan 1 bit is een vector. er zijn geen bytes, integers , signed of andere dingen. het is 1 bit of een array van bits met een gegeven lengte en orde: een vector) anders is.

je omzeilt dit door het op te breken in stukjes voor de synthesizer:

uitgang[7] = ingang[0]
uitgang[6] = ingang[1]
...
uitgang[0] = ingang[7]

Je kan dit ook in een lus doen.

for (i=0,i<8,i++) begin
    uitgang[i] = ingang[7-i]
end

Die lus wordt dan uitgevoerd tijdens de synthese en het resultaat is nog steeds draden !

Lussen in een synthesetaal worden gebruikt om logische functies te herhalen.

Dit geeft aan hoe krachtig een synthesetaal + programmerbare logica is in vergelijking met een programmeertaal en een processor.

Op zondag 9 november 2025 15:36:12 schreef free_electron:
De software is gratis : Altera Quartus 13.xx onder windows.

Link ?

software :

https://www.intel.com/content/www/us/en/software-kit/711791/intel-quar…

Het is een TARball, maar windows kan dat gewoon openen. Anders winzip of 7-zip.
let op : de file is groot (4.4 gigabyte) en de installatie nog veel groter.

Dit is professionele software waar je miljoenen gates kan mee aanmaken.

Op zondag 9 november 2025 16:55:23 schreef free_electron:
software :

https://www.intel.com/content/www/us/en/software-kit/711791/intel-quar…

Het is een TARball, maar windows kan dat gewoon openen. Anders winzip of 7-zip.
let op : de file is groot (4.4 gigabyte) en de installatie nog veel groter.

Dit is professionele software waar je miljoenen gates kan mee aanmaken.

Wat zijn de limitaties van de Web editie?
Heb je er een license file van Intel voor nodig of werkt het ook zonder license file?

Vooraleer we in de taal duiken zijn er een paar zaken die je moet begrijpen en die wat uitleg nodig hebben.

Combinatorische logica
--------------------------------------
Een funktie die kan beschreven worden met booleaanse logica. Niks anders dan een boel AND, OR en NOT poorten. Een XOR/XNOR functie kan gemaakt worden met AND en NOT poorten. Zelfs een OR kan je maken met AND en NOT poorten .

In een CPLD of FPGA zijn er niet echt "poorten". Het zijn eigenlijk niks meer dan ROM tabellen (waarheidstabellen). 4 ingangen per signaal. Een ROM op silicium is nu eenmaal veel kleiner dan een pak losse poorten met multiplexers.
Een synthesizer maakt dus eigenlijk geen echte logica aan maar maakt de waarheidstabellen die geladen moeten worden.
Als je klassieke logica maakt met poortjes (TTL of CMOS) dan ga je de waarheidstabel vereenvoudigen om zo min mogelijk poortjes nodig te hebben., In een CPLD of FPGA doen ze dat niet. Het werk stopt bij de waarheidstabel. Een waarheidstabel is niks anders dan een ROM.

Sequentiele logica (register logic)
-------------------------------------------------------
Hier gebeuren operaties onder controle van een clock. Telkens er een clockpuls is neemt het register (een ander woord voor geheugen : ene blok flipflops) de waarde aan zijn ingangen over, en zet die op zijn uitgangen.

In systemverilog is er een assignment operator. ( het = of <= teken ).
Je gaat in teksten termen zoals blocking en non-blocking tegenkomen maar dat is eigenlijk het varken een laagje verf geven of een bolhoed opzetten...

= is combinatorisch iets toekennen
<= is registered iets toekennen. 

Dat < teken betekent eigenlijk "clock", net zoals het symbooltje op een TTL teller clock ingang.
onthou dit :

= is een toekenning
<= is een geklokte toekenning

In traditionele verilog moet je daar mee opletten want er zijn nuances hoe het gebruikt wordt. Te moeilijk, en veel te veel valkuilen. Ik ga er niet op in. vergeet het, of lees er meer over als je grote complexe dingen gaat maken.

Systemverilog lost dit op door de boel iets anders te verpakken en "fauten" te vermijden.

Op zondag 9 november 2025 17:00:13 schreef Bobosje:
[...]

Wat zijn de limitaties van de Web editie?
Heb je er een license file van Intel voor nodig of werkt het ook zonder license file?

Geen licentie nodig. De web editie ondersteunt alleen bepaalde families en daar zitten flink jonges bij. Een Cyclone kan miljoenen gates bevatten.
Voor de hele grote heb je een licentie nodig alsook een licentie voor de simulator, maar dan ben je al in het vaarwater van chips met 600+ pinnen en BGA verpakking ...

Hoe mooi het hele FPGA gebeuren ook is.. Grootste nadeel aan dat hele Quartus vond ik, naast het feit dat het krankzinnig groot is, dat er bij elke nieuwe versie de oudere devices eruit gekieperd werden. (waar is al die ruimte dan toch voor nodig?) En je hebt er een flinke PC voor nodig.

Voor de oudere FPGA ontwikkelboardjes moest je gaan zoeken naar een oudere versie in de hoop dat die nog aan de praat te krijgen was. En de Linux ondersteuning verdween steeds meer.

Mogelijk een hele domme vraag. Kun je zo'n cpld/fpga meerdere keren "programmeren"?
Ik heb er iets van 10-15 jaar geleden wat mee willen spelen. Ik heb ergens nog zo'n ding (Max 5 ofzo) en een programmertje (bitblaster ofzo) Maar dat was toen nog een brug te ver. Ik wist toen te weinig van logische poorten. Mij laptop is waarschijnlijk niet snel genoeg maar ik vind het leuk je duidelijke uitleg te lezen.

De CPLd's zijn herprogrammerbaar. Is gewoon flash memory zoals een processor.

Quartus is groot door al de tools die het aan boord heeft. Schematic, verilog, vhdl, en de synthesizers voor al die verschillende chips. De oudere chips vliegen er uit omdat ze niet meer gemaakt worden. je kan oudere versies van quartus ( en zelfs max+ ) nog steeds downloaden en ze werken nog steeds. Linux .. tjah... aantal gebruikers is simpelweg te klein. De grote devices worden in de praktijk verwerkt met Synopsis en consoorten wat wel Linux tools zijn. Dus voor die devices wordt Quartus (frontend) toch niet gebruikt, alleen de mapper, en die is wel op Linux beschikbaar. Het Linux frontend van Quartus wordt slechts door een kleine groep gebruikt dus waarom zouden ze er tijd in steken ?
Hun einddoel is chips verkopen. Geen software tools.

Even nog iets meegeven : verwacht niet dat je van dit topic de volgende Jensen Huang of Elon Musk en trillionair wordt. Die kennis hou ik lekker voor me zelf . lol.

De mensen kunnen dat ook niet hoor. Dat zijn ganse teams.

De bedoeling is om CPLD en FPGA iets toegankelijker te maken voor de mensen. Al de nuances en complexe constructies die mogelijk zijn laat ik achterwege. Je kan daar zelf mee aan de slag later. Ik beperk tot een basis set waar je flink wat werk kan mee doen zonder te verstranden in complexe systemen. Het is niet de bedoeling om een nieuwe processor te maken , alhoewel dat vrij simpel is in verilog. ik heb het meerdere malen gedaan. De instructieset is niks anders dan een grote "select case" en je beschrijft voor elke instructie wat er moet gebeuren. je kan kleine snelle processortjes maken. Ik heb er ooit eentje gemaakt die een instructie set heeft die op basic lijkt.

De bedoeling is te tonen dat CPLD en FPGA niet moeilijk zijn. Het is zelfs simpeler dan een Arduino. Voor mij dan toch.

Al dat gepruts in C met duizenden files is voor mij niet van doen. Het zelfde kan ook gezegd worden van complexe Verilog projecten. Ik instantieer bijvoorbeeld nooit modules in andere modules. Ik gebruik het schema tool van quartus daarvoor. In mijn ontwerpen staat elke module eigen poten.
Als er koppeling nodig is tussen modules doe ik dat door middel van een schema. Je kan dat in verilog doen via een instantiering maar dat maak het compileren en simuleren alleen maar moeilijker.

Als je je functieblokken allemaal voorziet van een zelfde address, databus en read/write signalen is dat allemaal heel snel aan elkaar te knopen. ik leg dat later wel uit.

En we gaan verder :

een blok logica in Verilog is een module.

module teller
endmodule

Op zich doet dit natuurlijk niks.
We hebben eerst in en uitgangen nodig

module teller
(
   input logic clk,
   input logic reset,
   input logic [7:0] ingang,
   output logic nul,
   output reg [7:0] uitgang
);
endmodule

input en output spreken vanzelf.
logic betekent dat het om een combinatorisch (poortjes) signaal gaat.
reg betekent dat we daar flipflopjes willen hebben (een register)

Als je niks specifieert krijg je een 1-bit signaal. als je een array specifieert krijg je een vector.
[7:0] is een 8-bit vector van 7 naar 0 (MSB naar LSB)
je kan ook [0:7] specifieren. bit 0 is dan het MSB.

Het is af te raden om LSB-MSB arrays te maken. Het maakt voor de synthesizer niks uit maar kan heel verwarrend zijn. Ik heb het MSB nodig... is het 7 of 0 ? je moet het gaan zoeken in de definitie van het signaal of register. Als je bit order moet omdraaien : doe dat op het toplevel 1 keer.

de syntax is (input/output) (logic/reg) [vector] (naam/namen)
[vector] is optioneel. je kan een lijst van namen opgeven die allemaal het zelfde type zijn, gescheiden door commas. Spaart rammelwerk op het "keybroad"

module teller
(
   input logic clk, reset, load, enable,   // 4 signalen van 1 bit
   input logic [7:0] ingang,             // een vector
   output logic nul,
   output reg [7:0] uitgang
);
endmodule

als je van type wisselt moet je het specifieren.

dit werkt niet :

 input logic clk, reset, load, [7:0] ingang, enable

Tijd om een tellertje te maken

Opdracht :
Maak een teller die optelt als er een clockpuls komt.

module teller
(
   input logic clk, reset, load, enable, UPdown
   input logic [7:0] ingang,             
   output logic nul,
   output reg [7:0] uitgang
);

always_reg  @(posedge clk) begin
    uitgang <= uitgang+1
end

endmodule

We hebben onze signalen gedifineerd (maakt niks uit of we ze allemaal gebruiken of niet.)
noot : verilog is CASE SENSITIVE ! UPdown is niet het zelfde als upDOWN !

Aangezien we met registers gaan werken maken we een always_reg blok.

Noot : De oude verilog standaarden kennen dit niet. Er is alleen een "always" blok en de synthesizer kan niet uitvlooien wat er verwacht wordt. het is aan de schrijver om er zorg voor te dragen waar hij <= (clocked assignment) of = gebruikt ( zogenaamde blocking en niet-blocking). Vergeet dit. Het is verwarrend en ouwbollig en veroorzaakt frustratie als je nieuw bent. We gebruiken systemVerilog (of Verilog 2005. niet het zelfde maar syntactisch wel). Als je een boek pakt en ze gebruiken nog "always" in hun voorbeelden : smijt het weg, het is achterhaald. We maken ook geen flipflopjes meer met losse transistortjes. Je pakt een 74HCT74 (of nu een CPLD)

het @ statement defineert waarop het blok actie moet ondernemen. In ons geval : het "clk" signaal (een van onze ingangen)
aangezien we willen dat dit op de opgaande flank gebeurt : posedge.

always_reg @(posedge clk)

letterlijke vertaling:

altijd registertjes(always_reg) op (at) stijgende_flank (posedge) "clk"(ons signaal)

begin en end : wat er moet gebeuren. {} in 'c'. Verilog is meer pascal-achtig dan c.

Nieuwe opdracht : maak de teller zo dat hij op en af kan tellen onder controle van het UPdown signaal. 1 = op, 0 = af

module teller
(
   input logic clk, reset, load, enable, UPdown
   input logic [7:0] ingang,             
   output logic nul,
   output reg [7:0] uitgang
);

always_reg  @(posedge clk) begin
    if (UPdown ==1) begin
         uitgang <= uitgang+1;
   end
else begin
  uitgang <= uitgang-1;
end
end

endmodule

We evalueren het UPdown signaal door middel van een if-then-else statement.
== is "vergelijk" , net zoals in c

Je kan dit, net zoals in veel programmeertalen korter schrijven.

module teller
(
   input logic clk, reset, load, enable, UPdown
   input logic [7:0] ingang,             
   output logic nul,
   output reg [7:0] uitgang
);

always_reg  @(posedge clk) begin
   if (UPdown)  uitgang <= uitgang+1;
   else uitgang <= uitgang-1;
end

endmodule

Aangezien UPdown een 1 bit signaal is hoef je dat niet expliciet te vergelijken. Het statement activeert als UPdown hoog is. zie het zo :je test het signaal direct, in plaats van het resultaat van een vergelijking tussen het signaal en '1'. Voor de synthesizer maakt het niks uit, maar het spaart tikwerk en "fauten" tussen = en ==.

Aangezien we slechts 1 ding doen in dat "if" statement is er geen nood aan een begin-end block. Ditto voor de "else" clause.

noot : verilog kent de "ternary operator", net zoals in c. (het vraagteken). ik kan me daar nooit de syntax van herinneren, en gebruik het dan ook nooit.

tweede noot : ik spreek over verilog, maar ga er altijd vanuit dat ik minstens Verilog2005 of systemverilog bedoel.

De synthesizer zal nu waarschijnlijk een warning geven dat je een getal in een register zet dat niet het zelfde aantal bits heeft. Geen nood : het wordt afgesneden op de lengte van de vector.

Maar .... een getal wordt omgezet naar een 32 bit waarde die dan afgesneden wordt op de juiste lengte. Als je ooit een 64 bit ding gaat doen be je er aan voor de moeite . je gaat de synthesizer moeten expliciet opgeven hoeveel bits je wilt.

je doet dit door de lengte van de vector mee te geven

4'b1001  // 4 bit vector met binaire waarde 9 (1001)
4'd9    // 4 bit vector met decimale waarde 9
4'd22  // dit lukt niet. je kan 22 niet in 4 bits stoppen !
4'ha   // 4 bit hexadecimale waarde 'A'

je kan waardes leesbaar maken door middel van een underscore

32'hDEAD_BEEF
32'h01_C0FFEE
8'b0101_1010

dit werkt niet :

32'h_DEAD_BEEF
32'h0_DEAD_BEEF  // werkt wel

je kan een waarde niet beginnen met een underscore

[Bericht gewijzigd door free_electron op zondag 9 november 2025 18:44:22 (23%)]

Het valt niet mee om je bij te houden je typt sneller dan ik het kan lezen. .

input logic clk, reset, load, enable, UPdown

Zijn clk en reset gereserveerde signalen?
Daar bedoel ik mee of die dan ook fysiek aan de clk en reset pinnen van de CLPD hangen?

Waarom zie ik nergens hoe de signalen verbonden zitten aan fysieke pinnen?

Of loop ik op zaken vooruit en moet ik geduld hebben.

Nee, dat zijn geen gereserveerde namen waarmee de synthesiser vanzelf "standaard" dingen mee gaat doen.

Die module teller kan je vervolgens aanroepen en vertellen waar de clk en reset enz signalen aan moeten.

Als het je toplevel ding is, dan kan je aangeven dat zo'n signaal aan een pin-van-de-chip moet komen. Bijvoorbeeld dat uitgang aan pootjes x-y moet gaan komen.

Het TAALTJE verilog kent eigenlijk niets was over de mapping naar de chip gaat. Dat is iets wat je TOOL je aanbiedt.

Nieuwe opdracht :
Maak de teller zo dat hij niet alleen op en af kan tellen onder controle van het UPdown signaal. 1 = op, 0 = af, maar ook
- kan op nul gezet worden door middel van het reset signaal
- kan geladen worden door middel van het load signaal
- kan geactiveerd worden met het enable signaal.

We gaan prioriteiten moeten opleggen. Gaan we reset voorrang geven op load ? wat met enable ? heeft laden voorang op resetten of niet ? kunnen we resetten als we niet enabled zijn ?
Allemaal vraagtekens die een probleem worden om de if-then-else boom op te zetten. We moeten zien dat we alle mogelijke paden bewandelen anders is er het risico dat er een niet gedefineerde toestand is die ons later in de broek komt bijten. En als we later tot de ontdekking komen dat het laden voorrang moet hebben op het resetten moeten we gans die if-then-else soep weer aanpassen.

Er zijn andere mechanismen. Je kan die 4 controle signalen zien als een waarheidstabel. je kan een "case" statement uitvoeren op de 4 signalen en bepaalde combinaties gaan afdekken.

Maar.... er is een veel eenvoudiger manier. Scheduled logic. Dit is een term die je in de boekjes niet veel gaat tegenkomen. Ik weet maar 1 boek die het heel kort behandeld : "HDL chip design" door Douglas Smith.
Dit boek is uniek doordat het de constructies toont in verilog, vhdl en schema vorm. Linkerkant van een pagina is VHDL, rechterkant Verilog en eronder wat de synthesizer echt doet, en hoe het geminimaliseerd wordt. Dit boek ligt op haast elke ontwerpafdeling waar ze ICs maken. Het werd uitgedeeld door Synopsys op hun cursussen HDL en wordt aanzien als de "bijbel van Hardware Description Languages".

Het focust op synthetiseerbare constructies. Veel boeken beschrijven de taal maar niet de synthese met de taal. Je kan veel verilog en vhdl schrijven die niet synthetiseerbaar is naar logica. Je kan systemen modelleren en simuleren maar dat betekent niet dat ze synthetiseerbaar zijn naar poorten en flipflops!

Een ander boek is "Verilog HDL Synthesis" door J.Bhasker

Dit topic focuseert op synthetyseerbare verilog. Het doel is een CPLD of FPGA te laden met logica die we willen maken.

Het is daarom nodig om eerst te begrijpen hoe een synthesizer werkt. Hoe wordt dat kluwen van woorden omgezet naar poorten ? Op het eerste zicht lijkt het op magie. Alle moet tegelijk worden gedaan. een sequentiele lijst van instructies moet worden omgezet naar iets wat de ganse lijst terzelfdertijgd doet.

In de praktijk is het helemaal geen magie, maar een simpel mechanisme. Beide standaarden (Verilog HDL en die andere "VHDL" : very hard design language) definieren een clausule : logic shall be evaluated in the order it is written.

de logica wordt ge-evalueerd in de volgorde dat het geschreven is. Maar logica in een HDL is geen sequentieel programma zoals in een computer. HDL code wordt niet stap voor stap uitgevoerd "at-runtime" zoals een computer programma. De logica wordt aangemaakt in de volgorde dat het geschreven is. De logica zelf werkt allemaal "ter zelfder tijd". De aanmaak is sequentieel.

Wat bedoelen ze daar nu mee ? De kern is de manier waarop een synthesizer onze instructies omzet naar logica. Eenmaal je dit snapt is logica maken heel eenvoudig en heb je geen nood meer aan complex if then else constructies.

Op zondag 9 november 2025 18:48:00 schreef benleentje:
Het valt niet mee om je bij te houden je typt sneller dan ik het kan lezen. .

input logic clk, reset, load, enable, UPdown

Zijn clk en reset gereserveerde signalen?
Daar bedoel ik mee of die dan ook fysiek aan de clk en reset pinnen van de CLPD hangen?

Waarom zie ik nergens hoe de signalen verbonden zitten aan fysieke pinnen?

Of loop ik op zaken vooruit en moet ik geduld hebben.

er zijn geen gereserveerde signalen in verilog. ik noem de klok gewoon clk.
ik kon dat signaal evengoed als_benleentje_het_wil noemen

always_reg @(posedge als_benleentje_het_wil) ...

Waar we die signalen later aan gaan vastknopen maakt niks uit. Het is niet zoals op een processr waar de uart altijd op poot 2 en 3 zit en geen keuze hebt ... voor een CPLD en FPGA is elke pin een IO poot. Voor de synthesizer maakt het geen fluit uit. De pin mapper prikt dan de laatste draadjes tussen de fysieke pinnen en het binnenwerk. Er zijn bepaalde limitaties gegeven door de beschikbare draden binnenin. Maar de mappers zijn zo goed dat ze logica verplaatsen omde spaghetti te ontrafelen. ze houden zelfs rekening met interne delays en kunnen dat compenseren. Jekan opgeven in de mapping wat je maximum vertraging mag zijn tussen signalen. de synthesizer stop dan extra logica om delays te compenseren.

[Bericht gewijzigd door free_electron op zondag 9 november 2025 19:15:40 (33%)]

laatse post voor vandaag. ik moet nog mijn dakgoot schilderen ook

Hoe werkt een synthesizer nu eigenlijk. ?

laten we eerst eens die teller bekijken:

reg [7:0] counter;   // maak een 8 bit register.


always @(posedge clk) begin  // wanneer we een clock krijgen :

if (updown) counter <=counter +1 else counter <= counter -1;  // we gaan op of neer afhankelijk van het updown signaal
if (!enable) counter <=counter  // als we niet enabled zijn tellen we niet.. we blijven de huidige waarde houden.
if (load) counter <= parallel_in // als we moeten laden : haal data op
if (reset) counter <=0; // reset zet de teller op nul.

Vergeet even het ontbreken van if then else en de prioriteiten die we willen. Focus up wat er moet gebeuren. De volgorde is niet belangrijk nu.

we hebben 4 condities
- de teller telt (op of af under control van "updown")
- de teller is enabled of niet. (enable signaal)
- de teller word parallel geladen (load signaal)
- de teller wordt gereset (reset signaal)

hier is wat de synthesizer brouwt :

Op zondag 9 november 2025 17:47:19 schreef free_electron:
De CPLd's zijn herprogrammerbaar. Is gewoon flash memory zoals een processor.

je kan oudere versies van quartus ( en zelfs max+ ) nog steeds downloaden en ze werken nog steeds.

max+ schijnt van de Intel site verdwenen te zijn.

reg [7:0] counter;   // maak een 8 bit register.

De synthesizer maakt een 8 bit register aan met naam "counter". De naam doet er niet toe, het kon evengoed "frietketels" geweest zijn.

always @(posedge clk) begin

Hola. actie ! We gaan het CLK signaal aan die teller moeten hangen. Opnieuw CLk is gewoon een naam. Het kon even goed "als_we_frieten_gaan_bakken" zijn.

volgende tekeningetje :

if (updown) counter <=counter +1 else counter <= counter -1;

Als updown hoog is maak de nieuw waarde van "counter" eentje hoger, anders maak het eentje lager (noot : de syntax hier is niet helemaal correct maar het opzettelijk om het "lijn per lijn" te kunnen uitleggen)

De synthesizer neemt de waarde van de counter en plakt daar een +1 en -1 aan vast. Dit zijn gewoon twee combinatorische adders gemaakt met wat and en or poorten. Een multiplexer (dat parallelogrammetje met 0 en 1 er in) kan schakelen tussen de tak die +1 doet en de tak die -1 doet, onder controle van het updown signaal.

Dat symbooltje van een multiplexer toont de 2 paden en de 0 en 1 in het parallelogrammetje laat je zien voor welke logische waarde de tak actief is. Je kan dergelijk diagram direct uit Quartus halen. Er is een commando om de symbolische voorstelling te tonen van je verilog code.

volgende lijn :

if (!enable) counter <=counter

We stoppen een extra multiplexer tussen alle voorgaande logica en het register. deze staat onder controle van "enable". hij laat ofwel alle voorgaande definities passeren (het up/down statement), of laadt de huidige stand terug in het register. De huidige stand herladen doet niks. De flipflops veranderen niet.

if (load) counter <= parallel_in

Opnieuw een multiplexer die schakelt tussen al wat vooraf kwam en de nieuw conditie, onder controle van het "load" signaal. Als load hoog is gaan we bij de volgende clockpuls de waarde van data_in overnemen.

laatste lijn:

if (reset) counter <=0;

Opnieuw een mulitplexer blok wat schakelt tussen alles wat vooraf kwam, en de nieuwe opdracht.
als dat reset signaal actief is gaan we allemaal nullen op de teller zetten.

"De volgorde van de aangemaakte logica is identiek als de volgorde waarin ze geschreven is"
Daar is het algoritme wat een lijst van commando's vertaalt naar iets wat allemaal tegelijkertijd gebeurt. Dit is de motor van elke HDL synthesizer.

In ons voorbeeld was het 1 opdracht per lijn, maar het kunnen ook begin-end blokken zijn.

een multiplexer is een dom stuk logica . ingangen a en b , een controle signaal s en een uitgang :
s = (a * !s) + (b * s)
of logisch:
s = (a AND !s) OR (b AND s)

twee and poorten, een or en een inverter.

Je kan nu een tak nemen en de vergelijking direct opstellen. dat +1 signaal passeert alleen als UPDOWN,ENABLE hoog zijn en LOAD en reset laag.

Je kan dat in een karnaugh kaart gieten

welke signalen schakelen we ?
+1 , -1 , counter , data_in en '0'. Dat zijn er 5.
wie controleert ?

updown, enable,load,reset. Dat zijn er 4. je hebt dus een 4x8 karnaugh kaart nodig. vul in en minimaliseer. ( in de cpld of fpga gaan ze geneens minimaliseren. Ze laden gewoon die tabel en sturen daar fysieke multiplexers mee aan. De oude CPLDs en zeker de PAL en GAL hadden minimalisering nodig, maar een moderne is effectief opgebouwd uit blokken met tabellen die multiplexers sturen die aan flipflops en I/O hangen.

Je kan gans die boel met if then else beschrijven maar dat is moeilijk te volgen. Het is al helemaal een probleem als er morgen beslist wordt dat het laden van de teller voorrang moet hebben op de reset. Je moet gans die if-then else structuur omgooien.

Met scheduled logic :

reg [7:0] counter;   // maak een 8 bit register.
always @(posedge clk) begin  // wanneer we een clock krijgen :
if (updown) counter <=counter +1 else counter <= counter -1; 
if (!enable) counter <=counter  
if (reset) counter <=0;
if (load) counter <= parallel_in 
end

ik verwissel gewoon die laatste twee lijnen. Het laden heeft nu voorrang op alles wat vooraf kwam.
Die adders mogen staan dansen, de counter disabled, en de reset aan het hameren dat de teller op nul moet; het maakt allemaal niks uit. De laatste multiplexer staat op data_in en dus word data_in geladen op de stijgende flank!

Er zijn ook geen verborgen condities. in een if-then else boom bestaat het risico dat je een "else" pad niet definieert. het risico is dan dat de logica eender wat doet als die conditie ooit optreedt. Jamaar, die conditie kan nooit.. jaja... murphy....

Met scheduled logica zijn er geen onafgedekte paden. Er zijn geen zwevende condities. Alle mulitplexer ingangen hangen ergens aan vast. De volgorde is gekend ( de volgorde waarin het gescrheven is) en gans dat systeem is compleet voorspelbaar.

In Quartus kan je dat blok symthetiseren, daar automatisch een symbooltje van maken en dat mooi in een schema plaatsen en er de pinnetjes van je chip aan vast knopen. Je kan dan een tweede blokje maken en daar ook weer een symbooltje van maken en dat ook weer vastknopen.

Je kan dat aanknopen ook doen in verilog door een module te instantieren en de verbindingen te beschrijven. ( vergelijk het met een netlist in een schema/pcb programma ). Maar dat is ook weer een syntax op zich met de nodig valkuilen. Ik doe dat altijd met een schema, ook voor complexe projecten.

Je kan inverilog ook een simulatie model maken. je beschrijft dan stap per stap wat je ingangen zijn en je geeft op wat er van de uitgang verwacht wordt. de simulator kan het blok simuleren en vergelijken met wat er verwacht wordt. De simulator kan ook uitrekenen wat de delays zijn door al de bedrading in de CPLD/FPGA en je vertellen hoe hard je dat ding kan clocken. Dat kan allemaal in Verilog.

Ik doe dat met de waveform simulator. Veel van mijn logica simuleer ik nooit. De CPLD's zijn zo snel (5 nanoseconde of korter vergeleken met mijn systeem clock dat ik nooit tegen die limieten ga aanlopen.
Aangezien ik scheduled logic gebruik weet ik perfect wat het doet. er zijn geen verborgen condities.

Een blok peripherie maken voor een processor is een fluitje van een cent. data en address bus, read en write signaal en een clock.

In een volgende post zal ik een complexer blok uitleggen: een rotary encoder debouncen en uitlezen. de encoder stuurt rechtsreeks een teller( met programmeerbare limiet) aan. Als de tellerstand verandert wordt er een interrupt opgewekt.

Daar worden technieken zoals edge-detectionen state-machienes uitgelegd. Ook allemaal dingen waar je niet bang hoeft van te zijn. Is niks meer dan wat schuifregisters en comparators. Het klinkt allemaal indrukwekkend maar het stelt niks voor.

Op zondag 9 november 2025 20:10:48 schreef Bobosje:
[...]

max+ schijnt van de Intel site verdwenen te zijn.

max+ is heel oud.. meer dan 25 jaar ... archive.org heeft het vast wel nog.

https://archive.org/search?query=max+altera&and%5B%5D=mediatype%3A%22s…

Ze hebben zelfs nog de versie voor Solaris en DEC Alpha workstations. De solaris versie is de eerste die ik ooit gebruikt heb.

Die oude versies kennen trouwens geen systemverilog of verilog 2005.

een multiplexer is een dom stuk logica . ingangen a en b , een controle signaal s en een uitgang :
s = (a * !s) + (b * s)
of logisch:
s = (a AND !s) OR (b AND s)

Dat zal als logische formule wel kloppen. Maar het is toch niet erg als ik een multiplexer gewoon als een schakelaar zie.
In dit geval een 2 standen schakelaar en de bediening van de schakelaar gebeurt door s.

In dit geval een 2 standen schakelaar en de bediening van de schakelaar gebeurt door s.

Inderdaad. de nagel op de kop. Het is een tweestanden schakelaar die een of meerdere signalen kan schakelen.

er zijn multiplexers met bijvoorbeeld 4 of 8 ingangen die dan meerdere bits bevatten.

Denk aan de ics zoals 4051 4052 en 4053, maar dan voor veeeeeel kanalen.
De stuursignalen kiezen een van de ingangen en schakelen die naar de uitgang.