Hallo,

Ik probeer een vga monitor aan te sturen met mijn blue bird fpga bord, maar dit wilt niet echt lukken. Mijn monitor krijg ik wel zo ver dat hij mijn signaal herkend, alleen geeft hij aan dat hij de aspect ratio niet herkend.
Dus ik denk dat er iets mis is met de timing, maar na vanalles al geprobeerd te hebben ben ik ten einde raad.
Op de volgende sites heb ik informatie gelezen over het aansturen van monitoren over VGA en daarna ben ik helemaal van nul begonnen met het schrijven van code:
http://martin.hinner.info/vga/vga.html
http://www.epanorama.net/documents/pc/vga_timing.html
http://tinyvga.com/vga-timing/640x480@60Hz

Kan iemand mij vertellen waar het mogelijk fout kan zijn gegaan?
Het belangrijkste stuk van mijn code is als volgt (mijn pixelklok loopt op 25 MHz):


red <=  "11" when video = "11" else --rood alleen maximaal als het in beeld is
		"01";
blue <= "01";
green <= ('0',hsync xor vsync);
		
vsyncout <= vsync;
hsyncout <= hsync;

--instellen van alle horizontale klokken en timing momenten
process(pixelklok)
	variable count,lineklok2 : std_logic_vector(9 downto 0);
	variable hsync2, hfront, hvideo, hback : std_logic;
begin
	if(pixelklok'event and pixelklok = '0') then
		if(count = "1100100000") then --pixelklok na 800 resetten en front porch reset en set hsync2
			count := "0000000000";
			hfront := '0';
			hsync2 := '0';
				if(lineklok2 = "1000001101") then
					lineklok2 := "0000000000";
				else
					lineklok2 := lineklok2 + 1;
				end if;
		elsif(count = "0001100000") then -- reset hsync2 en set back porch na 96 klokpulsen
			hsync2 := '1';
			hback := '1';
			count := count + 1;
		elsif(count = "0010010000") then -- reset back porch en set hvideo na 144 klokpulsen
			hback := '0';
			hvideo := '1';
			count := count + 1;
		elsif(count = "1100010000") then -- reset hvideo en set front porch na 784 klokpulsen
			hvideo := '0';
			hfront := '1';
			count := count + 1;			
		else
			count := count + 1; -- optellen van count waarde
		end if;
	end if;
hsync <= hsync2;
lineklok <= lineklok2;
video(0) <= hvideo;
end process;

-- hier wordt de timing voor de verticale klok bepaald
process(lineklok)
	variable lineklok2 : std_logic_vector(9 downto 0);
	variable vsync2, vfront, vback, vvideo : std_logic;
begin 
lineklok2 := lineklok;
	if(lineklok2 = "1000001101") then -- overflow reset bij 525 en front porch reset en set vsync2
		lineklok2 := "0000000000";
		vfront := '0';
		vsync2 := '0';
	elsif(lineklok2 = "0000000010") then -- reset vsync2 en set back porch na 2 klokpulsen
		vsync2 := '1';
		vback := '1';
		lineklok2 := lineklok2 + 1;
	elsif(lineklok2 = "0000100011") then -- reset back porch en set vvideo na 35 klokpulsen
		lineklok2 := lineklok2 + 1;
		vback := '0';
		vvideo := '1';
	elsif(lineklok2 = "1000000011") then -- reset vvideo en set front porch na 515 klokpulsen
		vvideo := '0';
		vfront := '1';
		lineklok2 := lineklok2 + 1;
	else -- optellen van de lineklok
		lineklok2 := lineklok2 + 1;
	end if;
vsync <= vsync2;
video(1) <= vvideo;
end process;

Wat ik erg lelijk vind is dat je alleen variabelen gebruikt en geen signals. Ik vraag me zelfs af of je hiermee wel flipflops krijgt, wat je blijkbaar wilt gezien de constructie die je codeert.

Hoe zorg je ervoor dat beide processen gelijk blijven lopen. Horizontaal en verticaal hebben toch een bepaalde timing relatie en die zie ik niet terug in je code.

Ik gebruikt lineklok (een signal) die er voor moet zorgen dat hsync en vsync gelijk blijft lopen.
Maar ik dacht dat variabelen een soort van signals waren in een process. Dit omdat je in een process geen signals mag gebruiken omdat je pas aan het einde van een process zeker weet dat de juiste waarde in een signal staat, dit heb ik gelezen in mijn boek over VHDL (circuit design with VHDL van pedroni). Daarom zet ik onderaan mijn process dat de belangrijke variable omgezet moeten worden naar signals.
Maar wat je aanhaalt zou wel een logische verklaring zijn voor het feit dat mijn signalen wel herkend worden, maar dat mijn monitor geen verhouding tussen de 2 ziet.
Mag ik dan mijn variablen vervangen door signals, of wordt het dan alleen nog maar een groter probleem?

Even twee vier opmerkingen.

1) het feit dat je variabelen gebruikt is niet erg, maar gebruik sigmals wanneer je het signaal in meerdere processen wilt gebruiken.
Het feit dat aan het eind van het process pas zeker is dat de data gewijzigd is is volgens mij waar, maar is dat een probleem?
ik zou de variabelen die in beide processen nodig zijn gewoon veranderen in een signal.

2) ik heb zelf VGA code gemaakt, die even opgezocht en het grootste verschil is dat ik enkel data op de lijnen zet wanneer dit in beeld is (dus van H_sync 0 tot 800 en V_sync 0 tot 600). daarbuiten laat ik de data logisch 0.

3) waarom heb je de variabelen H_back, H_front en V back en V front? Wat wil je met deze signalen?

4) de manier waarop je je variabelen optelt zijn niet heel netjes. Ik zou op 1 plek de waardes optellen.

Als je er behoefte aan hebt kan ik mijn code online zetten, zodat je een beetje kunt vergelijken.

Hey bedankt jongens, ik heb zojuist alles in een process gezet en van lineklok, hsync en vsync signals gemaakt.
Terwijl ik daar mee bezig was heb ik nog een paar fouten uit mijn code gehaald, zo resette ik lineklok 2 keer en telde ik extra pulsen op in het onderste deel wat niet nodig is.
Na deze aanpassingen herkend mijn monitor de resolutie nu goed. Ik krijg alleen nog geen kleuren op mijn scherm op 2 groene lijnen bovenin mijn scherm na, maar daar zal ik zelf eerst over peinzen.

De variablen Hback/front en vback/vfront had ik aangemaakt omdat ik niet wist of ik deze nodig had. Daarom had ik ze voor de zekerheid erin gezet.
Het optellen van de variable lineklok heb ik ook gezien dat dat heel lelijk is, maar dat was een denkfout van mijn kant.
De optelling van count kan idd netter, bedankt voor die tip.

Nog even een paar opmerkingen, misschien wat algemeen maar toch:
Met variabelen is op zich niet echt iets mis, maar het duidt vaak op een software designer die hardware gaat maken. Die denken sequentieel, dus alles gebeurt na elkaar. Je moet in paralelle processen denken, en dan is het ok als het signal pas op het eind van het proces z'n nieuwe waarde krijgt. Dat is ook precies wat de hardware doet, dus het klopt precies.

Ik roep het wel vaker: maak een testbench en haal het zaakje door een simulator. Dan zie je zooooooooo veel meer. Je kunt precies zien wat alle signalen/variabelen doen op welk moment. Eenmaal in de FPGA blijft het gissen, en dus missen.

toevallig net dit jaar zoiets gemaakt op een FPGA tijdens labo op school... als je wil kan ik je wel een rar'tje bezorgen met een werkend voorbeeld. (denk niet dat ik de handleiding/cursus digitaal heb)

Bedankt voor de reacties. Ondertussen heb ik hem helemaal aan de praat gekregen en kan ik hem ook goed instellen.
Een heel aantal (simpele)programma's die ik voor mijn fpga gemaakt heb zijn allemaal parallel geschreven en dus ook met signals,
maar meestal werk ik met variablen in processen vanwege mijn veronderstelling dat dit echt noodzakelijk was.
Na jullie advies dat je ook gewoon signals kan gebruiken heb ik mijn code een beetje verbouwd en na een paar errors heb ik alles nu aan de praat gekregen.