Looplicht VHDL

vhdl code:

library ieee;
use ieee.std_logic_1164.all;

entity klokdeler is
port(klokin 	  : in STD_LOGIC;
     klok2    : out STD_LOGIC;
	  klok5	   :out STD_LOGIC
  );
  
end entity klokdeler;



architecture behavourial of klokdeler is
	begin 
	process(klokin)
		variable input: integer range 0 to 32;
	
      if(rising_edge(klokin)) then
		input<=input+1;
  
			if(input='10000') then
			klok2 <= not klok2;
  
			elsif(input='20000') then
			klok5 <= not klok5;
			input<=0;
			end if
		
		end if

	end process
end architecture behavourial

Voor school dienen we een looplicht te maken op het board dat we gebruiken in de lessen. De frequentie moet in te stellen zijn met een switch tussen 2hz of 5hz. Geprobeerd aan de hand van de voorbeelden een stukje code te schrijven die de frequenties maakt op basis van de 50 MHz input klok....

Ik weet dat er nog een "denkfout" zit om de 2 frequenties te maken in het systeem... Ik moet voor elke frequentie apart het aantal klokpulsen tellen.

Waar ik al even op aan het zoeken ben zijn de syntax fouten die de compiler in ISE Webpack aangeeft

code:

Entity <klokdeler> compiled.
ERROR:HDLParsers:164 - "E:/Users/Eigenaar/Desktop/school/vhdl/labo 2/Looplicht/looplicht.vhd" Line 19. parse error, unexpected IF
ERROR:HDLParsers:410 - "E:/Users/Eigenaar/Desktop/school/vhdl/labo 2/Looplicht/looplicht.vhd" Line 27. Variable 'input' input is at left hand side of signal assignment statement.
ERROR:HDLParsers:164 - "E:/Users/Eigenaar/Desktop/school/vhdl/labo 2/Looplicht/looplicht.vhd" Line 28. parse error, unexpected IF, expecting SEMICOLON
--> 

Er is een hele hoop mis met je code....

Groot gedeelte is syntax, en het niet snappen van de taal.
Daarnaast kan je ondanks de foute syntax mer 10000 en 20000 nooit 2 en 5 Hz maken vanuit 50 MHz.

De foutmeldiingen van de tool is redelijk duidelijk. Je mist veel 'puntkommas en output mogen niet aan de rechterkant van een assignment staan. Daarnaast assign je een variable met := i.p.v. <=. Na de variable declaraties binnen het process moet je ook een 'begin' toevoegen.

Ik zal kijken of ik van het weekend een voorbeeldje kan plaatsen.

[Bericht gewijzigd door DigitalDesigned op 10 april 2015 20:52:36 (16%)]

Altijd bij de 1e fout beginnen. Er staat dat ie de if niet verwacht op die plek. Dat betekend dus dat daarvoor nog iets ontbreekt. Wat zou dat zijn?

PS: ik hamer altijd op nette code omdat dat overzicht schept. Jij gebruikt enorm diepe identation (inspringen). Ik gebruik altijd 2 spaties, dat is genoeg. [edit] oh wacht, dat is CO die er een rommeltje van maakt, copy in een editor zit er al beter uit maar nog niet ok).

[Bericht gewijzigd door flipflop op 10 april 2015 21:12:20 (48%)]

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein

Ik zou een module maken die een klok door "N" deelt.

Dan zou ik 50MHz door 5 miljoen delen om een 10Hz klok te maken.
Die zou ik dan met dezelfde module nog eens door 2 en nog eens door 5 delen. Dan heb ik twee klokken die op 5 resp. 2 Hz draaien.

four NANDS do make a NOR . Kijk ook eens in onze shop: http://www.bitwizard.nl/shop/

Ik zou in een FPGA helemaal geen klok delen. Alleen als de clk frequentie heel erg hoog is. Alles 1 clk houden is veel simpeler.
Maar goed, da's het probleem van de TS nu niet.

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein

@flipflop: Dan heb je zeker nooit meerdere ethernet poorten op een FPGA gehad :-)

Maar de suggestie van Rew is opzich prima: een generieke deelmodule, en die twee keer instantieren.

Als je dat goed doet dan blijft alles op een klok werken, het uitgangssignaal van je deelblok is gewoon een IO die op specifiek uitgetelde klokflanken veranderd. En dus volledig synchroon aan die ene klok.

Maargoed, dit is twee niveautjes verder dan het probleem van TS.

Op 11 april 2015 01:01:58 schreef rew:
Ik zou een module maken die een klok door "N" deelt.

Dan zou ik 50MHz door 5 miljoen delen om een 10Hz klok te maken.
Die zou ik dan met dezelfde module nog eens door 2 en nog eens door 5 delen. Dan heb ik twee klokken die op 5 resp. 2 Hz draaien.

Rew een stomme vraag (die bestaan dus wel degelijk) Als ik het modulair doe zoals jij voorstelt dan heb ik in hardware van de fpga twee delers gerealiseerd naar 2 Hz en 5 Hz . Twee bundels hardware dus gebruikt van het beschikbare arsenaal; en de onderlinge fase van die twee outputsignalen is een vraagteken. Lijkt mij.

Maak ik echter een deel gemeenschappelijk, dat de 50 MHz deelt naar het kleinste gemene veelvoud van de twee gewenste outputsignalen, dan vervallen die bezwaren.

Toch?

Hieronder Flipflop. Ja je begrijpt me verkeerd. Ik wil een keer delen van 50 Mhz naar 10 Hz en daar dan 2 delers achter zetten een naar 2 Hz en een naar 5 Hz. De faserelatie tussen de opflank van de 5 Hz en de opflank van de 2 Hz ligt dan veel strakker en grover gespatieerd qua discrete mogelijkheden.

Goed, ik weet er verder de ballen van, dus neem me mijn geraaskal niet kwalijk.

[Bericht gewijzigd door Dr Blan op 11 april 2015 14:01:32 (19%)]

Op 11 april 2015 13:35:59 schreef blurp:
@flipflop: Dan heb je zeker nooit meerdere ethernet poorten op een FPGA gehad :-)

Als je mijn post goed had gelezen, dan had je gezien dat er stond "zeker als de clk niet te hoog ligt". Bij ETH is de clkfreq. nogal hoog. Dan wordt het simpelweg onmogelijk om alles op die hoge clk te laten lopen.

Als je dat goed doet dan blijft alles op een klok werken

Dat is dus niet zo. Je krijgt 2 afgeleide klokken. De synthese moet er dan voor zorgen dat beide flanken op elkaar blijven liggen (als je dat vraagt via constraints). Dat is uiteraard alleen nodig als je tussen beide domeinen heen en weer gaat, maar goed, da's algemeen zo.

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein

Op 11 april 2015 13:51:42 schreef Dr Blan:
Maaak ik echter een deel gemeenschappelijk, dat de 50 MHz deelt naar het kleinste gemene veelvoud van de twee gewenste outputsignalen, dan vervallen die bezwaren.
Toch?

Ehm, misschien begrijp ik je verkeerd, maar ik denk dat het antwoord "nee" is. Die beide klokken komen altijd uit verschillende flip-flops. Immers, je moet voor de ene verder delen dan voor de andere.

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein

Op 11 april 2015 13:52:24 schreef flipflop:
Als je mijn post goed had gelezen, dan had je gezien dat er stond "zeker als de clk niet te hoog ligt". Bij ETH is de clkfreq. nogal hoog. Dan wordt het simpelweg onmogelijk om alles op die hoge clk te laten lopen.

Voor Gigabit is je klok in de FPGA over het algemen 125MHz. Dat is voor geen enkele moderne FPGA erg hoog. Verder hangt het uiteraard heel erg van de precieze situatie af.

Dat is dus niet zo. Je krijgt 2 afgeleide klokken. De synthese moet er dan voor zorgen dat beide flanken op elkaar blijven liggen (als je dat vraagt via constraints). Dat is uiteraard alleen nodig als je tussen beide domeinen heen en weer gaat, maar goed, da's algemeen zo.

Het is pas een klok als je hem als klok gebruikt.
TS wil een LED laten knipperen. Dat noem je geen klok, maar gewoon een output.

bij de if / elseif, de vergelijkwaarde niet tussen quote's, je geeft eerder aan dat het een integer is en nu vergelijk je met een string....
Bovendien: moet daar gaan dubbel = teken staan ?
ken het taaltje niet, maar in C bijv is de expressie (input=10000) atijd waar, want input 10000 maken lukt altijd.
wat je wil is testen of input 10000 is, en dan moet je (input == 10000) gebruiken.

stop het overmatig spatiegebruik !

Met wat ik voor het gemak "klokdeler" noem, bedoel ik een ding wat 1 cycle van de snelle klok hoog geeft, terwijl ie de rest van de tijd laag geeft. Alles blijft synchroon.

Deze module wordt dan DRIE keer ge-instantieerd. Een keer voor de deling naar 10Hz, en vervolgens twee keer voor het verder delen door 2 of 5.

Als de gekozen FPGA niet "op z'n sloffen" 50MHz haalt, kan je overwegen om een PLL te gebruiken om de boel wat langzamer te krijgen, of om een "deel-door-vier" module te maken, en de uitvoer daarvan stiekum als klok-voor-de-rest te gebruiken.

four NANDS do make a NOR . Kijk ook eens in onze shop: http://www.bitwizard.nl/shop/

Op 11 april 2015 17:41:26 schreef rew:
Deze module wordt dan DRIE keer ge-instantieerd. Een keer voor de deling naar 10Hz, en vervolgens twee keer voor het verder delen door 2 of 5.

"Premature optimization is the root of all evil" :-)

Ik zou er maar twee instantieren, en laat de tooling het maar oplossen/optimaliseren.

Tja, enerzijds heb je gelijk. Anderzijds, denk ik niet dat de hardware-compiler de gemeenschappelijke "deel-door-tien" gaat vinden in twee 24/25 bit deel-door best-veel.

four NANDS do make a NOR . Kijk ook eens in onze shop: http://www.bitwizard.nl/shop/

Dat klopt, en dat zou ik dan eigenlijk moeten uitproberen.

Aan de andere kant, een 25bits-deler kost in de praktijk maar zo weinig FPGA oppervlak dat (als het voor werk is) mijn uren meer kostten dan de bespaarde lutjes opleveren.

Wat dat betreft (en nu gaat het echt OT) gaat FPGA ontwikkeling heel erg dezelfde kant op als software: De FPGA/CPU is zo krachtig, dat dergelijke optimalisatie niet meer economisch verantwoord is.

Op 11 april 2015 16:37:16 schreef blurp:
Voor Gigabit is je klok in de FPGA over het algemen 125MHz. Dat is voor geen enkele moderne FPGA erg hoog.

Oh nee? Probeer jij maar eens een hele FPGA te vullen met logica die allemaal op 125MHz loopt. Succes.

Het is pas een klok als je hem als klok gebruikt.

Ja duh! Maar wat de TS daat gemaakt heeft is een klokdeler, en geen enable-deler zoals rew daar bedoelt (weet zo geen term daarvoor).
In geval van 50M system clock zou ik gewoon een stel van die enables maken en de logica allemaal klokken op die sys clk. In dat geval heb je aan constraints alleen maar een clk constraint en evt nog wat i/o constraints, al is die laatste meestal niet eens nodig.

Maar goed, waar ging de vraag ook weer over? :-)

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein

Op 11 april 2015 20:46:09 schreef blurp:
Dat klopt, en dat zou ik dan eigenlijk moeten uitproberen.

Ik had een oude versie van Quartus ooit hier, maar ik denk ik gebruik wat moderners. 5.2Gb download verder.... Ondertussen is ie twee keer gecrashed voordat ik bij het typen van verilog aangekomen was. Ik geef het op.

four NANDS do make a NOR . Kijk ook eens in onze shop: http://www.bitwizard.nl/shop/

Van de TS horen we trouwens verrassend weinig meer...

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein

Op 11 april 2015 21:49:59 schreef flipflop:
Oh nee? Probeer jij maar eens een hele FPGA te vullen met logica die allemaal op 125MHz loopt. Succes.

Eeh? Even ervan afgezien dat ik nooit alle lutjes gebruik is het geen probleem alles op 125MHz te laten lopen. BTDT, ook op 155.52 MHz.

Soms moest ik dan inderdaad wat complexere stukjes opdelen en er een extra flipflop tussen stoppen.

Precies. Het is natuurlijk helemaal afhankelijk van je stijl. Als je alles in geklokte processen zet krijg je zoveel FFs dat je de timing op 150Mc wel zult halen, maar als je wat zuiniger programmeert gaat dat niet zomaar meer goed. Die 150Mc is best hoog hoor, zeker als je wat grotere devices gebruikt. Stel een FF aan de ene kant heeft een verbinding met een FF helemaal aan de andere kant van de chip, da's nogal lastig in 2ns. System clocks worden over het algemeen lager gekozen, bv 30 or 50Mc en alleen een deel op een hogere clk (bv in geval van ETH of serdes io)

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein

Het nadeel van zo'n lage klok is dat je voor dezelfde bandbreedte dan veel meer logica nodig hebt.

Twee jaar geleden heb ik geprobeerd 40Gb op 16x250MHz te verwerken. Dat lukte (net) niet in een Virtex 7. Op 125MHz was het een eitje. Overigens liep die hele FPGA op 125MHz.