Pong Porting. Autori: Alloni Fabio Alni Matteo Castiglioni William. Data: 23/3/2005. Versione: 1.2. Stato:Draft. Revisore: Marco D.

Transcript

1 Pong Porting Autori: Alloni Fabio Alni Matteo Castiglioni William Revisore: Marco D. Santambrogio Data: 23/3/2005 Versione: 1.2 Stato:Draft

2 Diffusione del documento Documento interno al laboratorio di Microarchitetture, Dipartimento di Elettronica e Informazione, Politecnico di Milano. 2

3 Revisioni Data Versione Stato Commento 20/2/ Draft Prima stesura del documento 23/3/ Draft Completamento documento dopo realizzazione pratica /05/ Draft Ristrutturazione del documento partendo da livelli descrittivi astratti e scendendo man mano nel dettaglio implementativo 3

4 Indice Indice 4 Introduzione al progetto 7 Il progetto originario 7 Breve descrizione della scheda XSV800 7 Dettagli implementativi 8 La scheda spartan 3 Starter 9 Differenze macrosopiche tra le 2 schede 10 Tools utilizzati 10 Porting a livello top 11 Architettura 11 Descrizione blocchi funzionali 11 Livello top 12 Listato VHDL 12 Indicazioni dei pin per file UCF 15 Porting VGA 16 Introduzione 16 Descrizione del dispositivo RAMDAC bt481a 16 Modulo Divisore 2 19 Listato VHDL 19 Simulazione 20 Modulo VGA Core 21 Versione 640 X 480 a 60 Hz (clock a 50 MHz) 22 Tempistiche 22 Distribuzione dei pixels 23 Listato VHDL 24 Simulazioni 27 Versione 800 X 600 a 72 Hz (clock a 50 MHz) 30 Tempistiche 30 Distribuzione dei pixels 31 Listato VHDL 31 4

5 Simulazioni 34 Modulo VGA versione 800 x Listato VHDL 38 Simulazione 42 Modulo VGA versione 640 x Simulazione 52 Porting display 7 segmenti e reset 61 Porting display 7 segmenti 61 Modulo SEG7 63 Listato VHDL 63 Simulazione 64 Modulo ScanDisplay 65 Listato VHDL 65 Simulazione 67 Porting reset 68 Porting Ps/2 e algoritmo gioco Pong 69 Porting Ps/2 69 Utilizzo della tastiera tramite protocollo PS/2 69 Descrizioni entity VHDL per l utilizzo della tastiera 70 Funzionamento algoritmo gioco Pong 74 Conclusioni e sviluppi futuri 77 Relazione personale Alloni Fabio 77 Relazione personale Alni Matteo 78 Relazione personale Castiglioni William 79 Sviluppo futuro modulo VGA e possibile uso in ambiente EDK 80 Sviluppo futuro ScanDisplay (modulo scandisplayedk) 81 Listato VHDL 82 Simulazione 85 File UCF 88 Possibile uso in ambiente EDK 89 Sviluppo futuro tastiera (modulo Ps_2_controller) 90 Possibile uso in ambiente EDK 91 5

6 Elenco immagini 92 Bibliografia 96 6

7 Introduzione al progetto Il progetto Pong Porting consiste inizialmente nell adattare un algoritmo esistente che realizza un implementazione del famoso gioco Pong, all hardware disponibile ai progettisti. Successivamente il suddetto algoritmo è stato ampliato e modificato aggiungendo nuove funzionalità che lo rendono più completo e adattabile. Il progetto originario Il progetto originario utilizzato come input per questo lavoro è stato realizzato dall Università di Trieste. La scheda sulla quale è stato deciso di implementarlo è la seguente: scheda XSV800 di XESS Corporation costruita attorno ad una FPGA Virtex XCV800-4-HQ240-C. Breve descrizione della scheda XSV800 La scheda XSV800 di XESS Corp. è una scheda di sviluppo basata sull FPGA Virtex XCV800-4-HQ240-C di Xilinx. La scheda dispone (vedi figura sottostante), oltre all FPGA, di due banchi di memoria da 1Mbyte ciascuno, una porta PS2 per il collegamento di una tastiera compatibile, una porta USB, un ingresso ed un uscita audio, una porta RJ45 associata ad un PHY Ethernet, una porta parallela IEEE1284, una porta seriale RS232, un entrata video PAL/NTSC (con connettore sia composito che S-Video), e una uscita VGA i cui segnali possono essere pilotati direttamente dalla FPGA o attraverso l ausilio di un RAMDAC (per la descrizione del RAMDAC, vedi descrizione VGA). Dispone inoltre di due display a sette segmenti, una barra di 10 led, una serie di 8 dipswitch e 4 pulsanti. Oltre alla FPGA, sulla scheda è presente anche un altro dispositivo programmabile: una CPLD XC95108 sempre di Xilinx. La CPLD è utilizzata principalmente per consentire la programmazione della FPGA attraverso la porta parallela, quella seriale, il connettore Xchecker di Xilinx, o la Flash Ram, in modo che la scheda possa essere utilizzata senza un computer host che la programmi ad ogni accensione. È presente altresì un generatore programmabile di clock da 100 MHz a 48.7KHz che pilota la FPGA. Il gioco Pong utilizza un clock da 50MHz. 7

8 Figura 1. scheda XSV800 Dettagli implementativi del progetto originario Il progetto originario è sostanzialmente diviso in tre grosse entità logiche; il gestore della tastiera, il gestore del gioco ed esecutore dell algoritmo, e il gestore dell uscita VGA. Attorno a queste tre grandi blocchi orbitano altri gestori di altre componenti. Alcuni esempi sono: il gestore dei display a 7 segmenti, il gestore degli switch, ecc. Non tutte le entità del progetto originario sono state riviste interamente; per alcune è stato necessario riprogettare interamente il codice, mentre per altre è bastato effettuare piccole modifiche. Per i dettagli si rimanda ai capitoli successivi. 8

9 La Scheda Spartan 3 Starter La scheda di realizzazione del progetto Pong Porting è la scheda Spartan 3 Starter (fig.2 ) fabbricata dalla Digilent. Essa è costruita attorno ad una FPGA Spartan3 XC3S200-FT256 prodotta dalla Xilinx. La suddetta scheda è composta inoltre da: Memoria Flash da 2Mbit (XCF02S) 8 switch 4 pulsanti 8 LED 4 display a sette segmenti pilotati da un unico bus con enable Porta seriale Porta VGA Porta PS2 Tre connettori di espansione da 40 pin Tre regolatori di tensione (3.3V, 2.5V, 1.2V) Connettore JTAG3 per la connessione con il PC. Figura 2. scheda Spartan 3 Starter 9

10 Differenze macroscopiche Dopo una prima grossolana analisi delle due schede risultano evidenti due differenze sostanziali inerenti all implementazione del progetto: l assenza sulla scheda Spartan 3 Starter del dispositivo RAMDAC e la differente gestione dei display a 7 segmenti. Questi due blocchi saranno oggetto di profonde modifiche. Per i dettagli si rimanda ai capitoli inerenti. Tools utilizzati ISE i (creazione di nuovi progetti, sinterizzazione, fino alla generazione del bit stream). ModelSim XE II 5.7g (simulazione dei singoli moduli sviluppati) 10

11 Porting a livello top Architettura A livello architetturale la soluzione proposta segue quella realizzata dall Università di Trieste con l aggiunta di un modulo dedicato alla gestione dei display 7 segmenti. Figura 3. Architettura progetto La figura precedente rappresenta una divisione schematica del problema risolto. Le descrizioni più dettagliate dei singoli blocchi avverrà nei capitoli seguenti. Descrizione blocchi funzionali TASTIERA: gestisce le comunicazioni con il bus PS/2 usato nell interfacciamento col la tastiera, legge i codici relativi ai tasti premuti e fornisce in uscita un impulso per indicare se il primo o il secondo giocatore vuole modificare la posizione della propria pad (alzarla, abbassarla) oppure se si vuole entrare o uscire dalla pausa. GESTORE GIOCO E ALGORITMO GIOCO: gestisce lo svolgimento del gioco, ponendo in uscita le posizioni delle 2 pad, quella della pallina e i punteggi dei 2 giocatori. VGA: si occupa della gestione dell uscita video VGA, generando i segnali di sincronismo (hsync, vsync) e i colori del pixel attuale (RGB) stampando a schermo le pad e la pallina in funzione della loro posizione letta in ingresso. SCANDISPLAY:gestisce la visualizzazione sui display 7 segmenti dei punteggi dei 2 giocatori 11

12 Livello Top A livello top cioè raggruppando i blocchi funzionali, il gioco ha la seguente struttura: Figura 4. modulo pong Seguirà una breve descrizione dei vari segnali rstn: reset del gioco (attivo basso) switchvelocita: regolatore velocità della pallina clk50mhz: clock di sistema ps2clk: segnale di sincronismo per l interfacciamento con la tastiera ps2data: segnale per il trasferimento dati con la tastiera rgb: colore del pixel che attualmente deve essere stampato a schermo hsync: segnale di sincronismo verticale utilizzato dal monitor vsync: segnale di sincronismo orizzontale utilizzato dal monitor enabledisp: indica quali display 7 segmenti attivare punteggio: indica qual è il punteggio da visualizzare Listato VHDL Segue il listato VHDL, per brevità sono state omesse le parti non modificate dalla versione originale: entity Pong is port ( -- clock e reset negativo clk50mhz: in STD_LOGIC; 12

13 rstn: in STD_LOGIC; -- segnali per il bus ps2 ps2data: inout STD_LOGIC; ps2clk: inout STD_LOGIC; -- display punti punteggio:out std_logic_vector(6 downto 0); --valore del punteggio enabledisp: out std_logic_vector(3 downto 0); --indica quale display accendere --hexouthi: out STD_LOGIC_VECTOR (6 downto 0); --hexoutlo: out STD_LOGIC_VECTOR (6 downto 0); -- dipswitch per scegliere la velocita' di gioco switchvelocita: in STD_LOGIC; rgb: out STD_LOGIC_VECTOR (2 downto 0); -- uscita VGA -- segnali che controllano la VGA --pixel: out STD_LOGIC_VECTOR (7 downto 0); -- RAMDAC pixel lines --blankn: out STD_LOGIC; -- RAMDAC blank signal --RDn: out STD_LOGIC; -- RAMDAC RDn connection --WRn: out STD_LOGIC; -- RAMDAC WRn connection --RAMDACD: inout STD_LOGIC_VECTOR (7 downto 0); -- RAMDAC data lines --RS: inout STD_LOGIC_VECTOR (2 downto 0); -- RAMDAC RS lines hsync: out STD_LOGIC; -- horizontal sync for monitor vsync: out STD_LOGIC -- vertical sync for monitor --triste: out STD_LOGIC; -- signal to tristate ethernet PHY --rramce: out STD_LOGIC; -- right ram chip enable --pixelclk: out STD_LOGIC; -- RAMDAC pixel clock ); end Pong; --pin230: out STD_LOGIC architecture Pong_arch of Pong is -- pin 230 della FPGA, da forzare a zero causa guasto -- si occupa di gestire la VGA, disegnando i pixel sullo schermo, e configurando il RAMDAC al reset component VGA is port ( clk: in STD_LOGIC; -- clock rstn: in STD_LOGIC; -- asynchronous active low reset reg_pos_sx: in STD_LOGIC_VECTOR(9 downto 0);-- posizione del centro della pad sx reg_pos_dx: in STD_LOGIC_VECTOR(9 downto 0);-- posizione del centro della pad dx pos_x_pallina: in STD_LOGIC_VECTOR(9 downto 0); -- posizione x del centro della pallina pos_y_pallina: in STD_LOGIC_VECTOR(9 downto 0);-- posizione y del centro della pallina rgb: out STD_LOGIC_VECTOR(2 downto 0); --uscita VGA hsync: out STD_LOGIC; -- horizontal sync for monitor vsync: out STD_LOGIC; -- vertical sync for monitor giocoattivo: in STD_LOGIC ); end component; 13

14 component scandisplay is port ( clk: in std_logic; punt1 : in std_logic_vector(6 downto 0); --punteggio 1UP punt2 : in std_logic_vector(6 downto 0); --punteggio 2UP punteggio : out std_logic_vector(6 downto 0); --punteggio da visualizzare enabledisp: out std_logic_vector(3 downto 0) --enable display 1 e 4 ); end component;.. --SEGNALI AGGIUNTI: signal hexouthi:std_logic_vector (6 downto 0); signal hexoutlo:std_logic_vector (6 downto 0); signal resetn: std_logic; begin video: VGA port map ( clk => clk50mhz, rstn => resetn, reg_pos_sx => pos_sx, -- bus proveniente da gestoregioco/algoritmipong reg_pos_dx => pos_dx, -- bus proveniente da gestoregioco/algoritmipong pos_x_pallina => xpall, -- bus proveniente da gestoregioco/algoritmipong pos_y_pallina => ypall, -- bus proveniente da gestoregioco/algoritmipong rgb=>rgb, --pixel =>pixel, -- ai piedini dell'fpga per comandare il RAMDAC --blankn =>blankn, --RDn =>rdn, --WRn =>wrn, --RAMDACD =>ramdacd, --RS =>rs, hsync =>hsync, vsync =>vsync, --triste =>triste, --rramce =>rramce, --pixelclk => pixelclk, giocoattivo => abilitagioco -- e' not (giocoinpausa) con giocoinpausa segnale controllato da FSMgioco. );. scandisp: scandisplay port map ( clk => clk50mhz, punt1 => hexoutlo, 14

15 punt2 => hexouthi, punteggio => punteggio, enabledisp => enabledisp ); resetn<=not rstn; abilitagioco <= not giocoinpausa; end Pong_arch; Indicazione dei pin per file UCF Infine controllando il datasheet della Spartan3 sono stati identificati i pin della FPGA che devono usati dalla logica del gioco, creando il corrispettivo file UCF: porta I/O PONG punteggio<6> punteggio<5> punteggio<4> punteggio<3> punteggio<2> punteggio<1> punteggio<0> enabledisp<3> enabledisp<2> enabledisp<1> enabledisp<0> switchvelocita Rstn rgb<2> rgb<1> rgb<0> Hsync Vsync ps2data ps2clk clk50mhz Pin Spartan3 E14 G13 N15 P15 R16 F13 N16 E13 F14 G14 D14 F12 M13 R12 T12 R11 R9 T10 M13 M16 T9 15

16 Porting VGA Introduzione Uno dei moduli principali del videogame, data l importanza che riveste l utilizzo del monitor, è sicuramente quello che gestisce l uscita VGA. Una parte importante e difficoltosa del progetto è stata, infatti, il porting proprio di questi file sia per la complessità degli stessi, che per la diversità delle due schede. La scheda originaria, per la quale era stata scritta la versione di partenza del videogioco (scheda XSV800 di XESS corp. basata sull FPGA Virtex XCV800-4-HQ240-C) utilizzava come ausilio all uscita VGA un dispositivo RAMDAC assente sulla scheda scheda Spartan-3 Starter di Digilent basata sull FPGA Xilinx Spartan3 XC3S200-FT256. Descrizione del dispositivo RAMDAC bt481a Il dispositivo RAMDAC è un convertitore digitale-analogico che viene utilizzato per migliorare le prestazioni video delle schede che lo utilizzano. In particolare questo dispositivo è in grado di aumentare notevolmente il numero dei colori visualizzabili e contribuisce ad evitare sfarfallamenti dell immagine grazie ad alcune funzioni di sincronismo che il convertitore offre. In particolare può essere utilizzato in due modalità differenti. Nella prima modalità (detta palette ), i segnali del colore sono generati a partire da un indice che seleziona il colore con cui rappresentare il pixel attuale da una tabella interna in cui sono contenuti i valori delle componenti rosso, verde e blu di 256 colori impostabili. Nella seconda modalità (detta true color ), le componenti del colore vengono passate direttamente dall esterno, e questo rende possibile la generazione di uno qualunque dei colori possibili per ogni pixel. I colori possibili possono essere , o a seconda del numero di bit per canale che si sceglie (rispettivamente 8:8:8, 5:6:5 o 5:5:5). Per il progetto dell originario gioco Pong, è stata utilizzata la modalità palette in quanto bastavano pochi colori. Per programmare i registri della palette e i registri di configurazione, si utilizza il bus composto da RS, D, RD, WD. RD e WR devono essere asseriti per leggere o scrivere sul registro specificato dalle linee RS; il dato da trasferire (sia in lettura che scrittura) si trova sulle linee D. Per caricare la palette, si impostano le linee RS al valore 001 ( comanda la palette ) e poi sul bus D si pongono in sequenza l indice del colore della palette da modificare, la componente rossa, quella verde e quella blu. Alla fine dei quattro cicli di scrittura, il colore all indice specificato viene modificato e inoltre l indice stesso viene incrementato internamente al valore successivo, in modo da poter subito caricare le componenti del colore successivo. 16

17 Figura 5. Struttura interna del RAMDAC Il dispositivo RAMDAC, una volta programmato, si occupa quindi di riconoscere l indirizzo di un colore e di generare il valore analogico dei tre segnali RGB. Non avendo a disposizione un convertitore digitale analogico sulla scheda Spartan 3, i segnali rgb devono quindi essere trattati come dei segnali digitali, riducendo il numero dei colori a 2 3 cioè 8. Tabella dei colori 17

18 Bisogna quindi sincronizzare manualmente la logica che decide il colore pixel per pixel con i segnali di sincronismo orizzontale e verticale e portare in uscita al monitor i valori descritti in tabella in base al colore scelto. Come questo sincronismo è stato realizzato e altro ancora sarà oggetto di questo capitolo. Verrà ora fornita una descrizione dettagliata delle entità inerenti. 18

19 Modulo Divisore 2 L entità divisore_2 è un blocco utilizzato all interno del sistema che governa l uscita VGA per diminuire la frequenza del ciclo di clock. Più precisamente l entità in questione è utilizzata per rallentare il ciclo di clock del 100%, raddoppiandone quindi il periodo. Il suo inserimento è stato reso necessario per semplificare i calcoli relativi alla durata dei segnali di sincronismo orizzontale e sincronismo verticale dell entità VGAcore della sola versione 640 x 480. Figura 6. Modulo Divisore 2 Come si può facilmente intuire l entità ha due ingressi e un uscita. Descrizione degli ingressi: - clkin; ciclo di clock in ingresso a 50 mhz; - rstn; segnale di reset attivo basso; Descrizione dell uscite; - clkout; ciclo di clock in uscita 25 mhz; Listato VHDL library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_unsigned.all; -- divisore di clock per 2 entity Divisore2 is port ( clkin: in STD_LOGIC; -- clock di ingresso, es 50mhz clkout: out STD_LOGIC; -- clock di uscita: -> 25 mhz rstn: in STD_LOGIC-- reset (negativo) ); end Divisore2; architecture Divisore2_arch of Divisore2 is signal stato: STD_LOGIC:='0'; 19

20 -- funzionamento: ogni colpo di clock, inverte l'uscita clkout, che e' collegata al segnale interno "stato" begin process (clkin) begin if clkin'event and clkin = '1' then if rstn = '0' then stato <= '0'; else stato <= not(stato); end if; end if; clkout <= stato; end process; end Divisore2_arch; Simulazione Figura 7. Simulazione del blocco Divisore_2 20

21 Modulo VGA Core L entità VGAcore è un modulo inserito nella complessa architettura utilizzata per la gestione dell uscita VGA. Il compito principale di questa importante entità è quello di generare i segnali di sincronismo orizzontale e sincronismo verticale che vengono mandati direttamente in ingresso al monitor. Un altro compito molto importante attribuito a questo modulo è quello di generare delle tempistiche utilizzabili all interno dell entità di livello superiore per sapere quale pixel in quel preciso momento sarà acceso sul monitor. Dato che questa entità è la responsabile di tutte le tempistiche dell uscita video, è facile intuire che da questa entità dipenderanno quindi sia la risoluzione dello schermo che la velocità di aggiornamento dell immagine (refresh). Il videogame è stato realizzato in due differenti modalità: 1) 800 x 600 a 72 Hz: modalità derivata dal pong originario; 2) 640 x 480 a 60 Hz: modalità completamente nuova scritta a partire dai valori del datasheet della scheda Spartan III. In entrambi i casi la struttura del modulo (di seguito descritta) è comunque molto simile. Descrizione modulo: Il modulo a 2 ingressi e 6 uscite. Ingeressi: - clock: ciclo di clock in ingresso a 50 MHz. Nella versione 800x600 coincide con in clock operativo, mentre nella versione 640x480 il periodo del segnale viene raddoppiato (divisore_2). - reset: segnale di reset attivo basso. Uscite: - hloc: vettore che porta in uscita la codifica binaria della coordinata orizzontale del pixel attivo. - vloc: vettore che porta in uscita la codifica binaria della coordinata verticale del pixel attivo. - enable: segnale che indica al modulo di livello superiore (valore 1) se il pixel corrente è all interno del campo di risoluzione. 0 altrimenti. - latch: segnale utilizzata per verifiche e test. Non collegato. - hsyncb: segnale di sincronismo orizzontale. - vsyncb: segnale di sincronismo verticale. 21

22 Figura 8. Blocco VGA Core Versione 640x480 a 60 Hz (clock a 25 MHz) Tempistiche Figura 9. Timing risoluzione 640 x

23 Distribuzione dei pixels Figura 10. Visualizzazione dei pixel su monitor (versione 640 x 480) 23

24 Listato VHDL library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_unsigned.all; entity VGAcore is generic ( H_SIZE : integer := 640; -- horizontal size of input image, MAX 800 V_SIZE : integer := vertical size of input image, MAX 600 ); port ( reset: in std_logic; -- asynchronous active low reset clock: in std_logic; -- clock hsyncb: buffer std_logic; -- horizontal (line) sync vsyncb: out std_logic; -- vertical (frame) sync latch: out STD_LOGIC; -- latches new RGB value ); end VGAcore; enable: out STD_LOGIC; -- enable/ground RGB output lines hloc: out std_logic_vector(9 downto 0); -- horizontal address to be decoded for video RAM vloc: out std_logic_vector(9 downto 0) -- vertical address to be decoded for video RAM architecture VGAcore_arch of VGAcore is component Divisore2 port ( clkin: in STD_LOGIC; clkout: out STD_LOGIC; rstn: in STD_LOGIC ); end component; -- horizontal timing signals constant H_PIXELS: INTEGER:= H_SIZE - 1; constant H_FRONTPORCH: INTEGER:= 16; constant H_SYNCTIME: INTEGER:= 96; constant H_BACKPORCH: INTEGER:= 48; constant H_PERIOD: INTEGER:= H_SYNCTIME + H_PIXELS + H_FRONTPORCH + H_BACKPORCH; -- vertical timing signals constant V_LINES: INTEGER:= V_SIZE - 1; constant V_FRONTPORCH: INTEGER:= 10; constant V_SYNCTIME: INTEGER:= 2; 24

25 constant V_BACKPORCH: INTEGER:= 29; constant V_PERIOD: INTEGER:= V_SYNCTIME + V_LINES + V_FRONTPORCH + V_BACKPORCH; signal hcnt: std_logic_vector(10 downto 0); -- horizontal pixel counter signal vcnt: std_logic_vector(9 downto 0); -- vertical line counter signal clock25mhz: STD_LOGIC; begin divisoreclock: Divisore2 port map ( clkin => clock, -- collega il clock a 50mhz entrante al divisore di clock clkout => clock25mhz, -- in uscita ho il clock a 25 mhz che controlla tutto il resto rstn => reset ); -- control the reset, increment and overflow of the horizontal pixel count A: process(clock25mhz, reset) begin -- reset asynchronously clears horizontal counter if reset = '0' then hcnt <= (others => '0'); -- horiz. counter increments on rising edge of dot clock elsif (clock25mhz'event and clock25mhz = '1') then -- horiz. counter restarts after the horizontal period (set by the constants) if hcnt < H_PERIOD then hcnt <= hcnt + 1; else hcnt <= (others => '0'); end if; end if; end process; -- control the reset, increment and overflow of the vertical line counter after every horizontal line B: process(hsyncb, reset) begin -- reset asynchronously clears line counter if reset='0' then vcnt <= (others => '0'); -- vert. line counter increments after every horiz. line elsif (hsyncb'event and hsyncb = '1') then 25

26 -- vert. line counter rolls-over after the set number of lines (set by the constants) if vcnt < V_PERIOD then vcnt <= vcnt + 1; else vcnt <= (others => '0'); end if; end if; end process; -- set the horizontal sync high time and low time according to the constants C: process(clock25mhz, reset) begin -- reset asynchronously sets horizontal sync to inactive if reset = '0' then hsyncb <= '1'; -- horizontal sync is recomputed on the rising edge of every dot clock elsif (clock25mhz'event and clock25mhz = '1') then -- horiz. sync is low in this interval to signal start of a new line if (hcnt >= (H_FRONTPORCH + H_PIXELS) and hcnt < (H_PIXELS + H_FRONTPORCH + H_SYNCTIME)) then hsyncb <= '0'; else hsyncb <= '1'; end if; end if; end process; -- set the vertical sync high time and low time according to the constants D: process(hsyncb, reset) begin -- reset asynchronously sets vertical sync to inactive if reset = '0' then vsyncb <= '1'; -- vertical sync is recomputed at the end of every line of pixels elsif (hsyncb'event and hsyncb = '1') then -- vert. sync is low in this interval to signal start of a new frame if (vcnt >= (V_LINES + V_FRONTPORCH) and vcnt < (V_LINES + V_FRONTPORCH + V_SYNCTIME)) then vsyncb <= '0'; else vsyncb <= '1'; end if; end if; end process; -- whether it should latch the current data or not -- (always with a 50MHz clock - blanking is handled on the RAMDAC by asserting a signal) 26

27 latch <= NOT reset; -- asserts the blaking signal (active low) E: process (clock25mhz) begin if clock25mhz'event and clock25mhz = '1' then -- if we are outside the visible range on the screen then tell the RAMDAC to blank -- in this section by putting enable low if (hcnt >= H_PIXELS and hcnt < H_PERIOD) or (vcnt > V_LINES and vcnt <= V_PERIOD) then enable <= '0'; else enable <= '1'; end if; end if; end process; H: hloc <= hcnt(9 downto 0); vloc <= vcnt(9 downto 0); end VGAcore_arch; Simulazioni 1. Fronte di salita del segnale hsyncb della riga 6 => avviene ancora all interno dei colpi di clock di riga 5, esattamente al colpo di clock = (display time + front porch + sync time) = 752. Contemporaneamente viene incrementato il contatore di riga. Ovviamente il segnale enable è basso perché si tratta di un pixel fuori risoluzione. Figura 11. Simulazione fronte di salita di hsyncb versione 640 x Fronte di discesa del segnale hsyncb della riga 9 => avviene esattamente al colpo di clock = (display time + front porch) = 656 di riga 9. Ovviamente il segnale enable è basso perché si tratta di un pixel fuori risoluzione. 27

28 Figura 12. Simulazione fronte di discesa di hsyncb versione 640 x Fronte di salita del segnale vsyncb della seconda schermata. Avviene ancora all interno della prima schermata, esattamente alla riga = (480 + front porch + sync time) = 492, in contemporanea al fronte di salita del segnale hsyncb => pixel 752. Ovviamente il segnale enable è basso perché si tratta di un pixel fuori risoluzione. Figura 13. Simulazione fronte di salita di vsyncb versione 640 x Fronte di discesa del segnale vsyncb della seconda schermata. Avviene ancora all interno della seconda schermata, esattamente alla riga = (480 + front porch) = 490, in contemporanea al fronte di salita del segnale hsyncb => pixel 752. Ovviamente il segnale enable è basso perché si tratta di un pixel fuori risoluzione. Figura 14. Simulazione fronte di discesa di hsyncb versione 640 x

29 5. Fronte di salita del segnale enable; primo pixel valido (0,0) della seconda schermata. Figura 15. Simulazione fronte di salita di enable versione 640 x Fronte di discesa del segnale enable; ultimo pixel valido (479,639) della seconda schermata. Figura 16. Simulazione fronte di discesa di enable versione 640 x

30 Versione 800x600 a 72 Hz (clock a 50 MHz) Tempistiche Figura 17. Timing versione 800 x

31 Distribuzione dei pixels Listato VHDL library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_unsigned.all; Figura 18. Visualizzazione dei pixel su monitor (versione 800 x 600) entity VGAcore is generic ( H_SIZE : integer := 800; -- horizontal size of input image, MAX 800 V_SIZE : integer := vertical size of input image, MAX 600 ); port ( reset: in std_logic; -- asynchronous active low reset 31

32 clock: in std_logic; -- clock hsyncb: buffer std_logic; -- horizontal (line) sync vsyncb: out std_logic; -- vertical (frame) sync latch: out STD_LOGIC; -- latches new RGB value enable: out STD_LOGIC; -- enable/ground RGB output lines hloc: out std_logic_vector(9 downto 0); -- horizontal address to be decoded video RAM vloc: out std_logic_vector(9 downto 0) -- vertical address to be decoded for video RAM ); end VGAcore; architecture VGAcore_arch of VGAcore is -- horizontal timing signals constant H_PIXELS: INTEGER:= H_SIZE-1; constant H_FRONTPORCH: INTEGER:= 56 + (800 - H_SIZE) / 2; constant H_SYNCTIME: INTEGER:= 120; constant H_BACKPORCH: INTEGER:= 63 + (800 - H_PIXELS) / 2; constant H_PERIOD: INTEGER:= H_SYNCTIME + H_PIXELS + H_FRONTPORCH + H_BACKPORCH; -- vertical timing signals constant V_LINES: INTEGER:= V_SIZE-1; constant V_FRONTPORCH: INTEGER:= 37 + (600 - V_SIZE) / 2; constant V_SYNCTIME: INTEGER:= 6; constant V_BACKPORCH: INTEGER:= 23 + (600 - V_SIZE) / 2; constant V_PERIOD: INTEGER:= V_SYNCTIME + V_LINES + V_FRONTPORCH + V_BACKPORCH; signal hcnt: std_logic_vector(10 downto 0); signal vcnt: std_logic_vector(9 downto 0); -- horizontal pixel counter -- vertical line counter begin -- control the reset, increment and overflow of the horizontal pixel count A: process(clock, reset) begin -- reset asynchronously clears horizontal counter if reset = '0' then hcnt <= (others => '0'); -- horiz. counter increments on rising edge of dot clock elsif (clock'event and clock = '1') then -- horiz. counter restarts after the horizontal period (set by the constants) if hcnt < H_PERIOD then hcnt <= hcnt + 1; else hcnt <= (others => '0'); 32

33 end if; end if; end process; -- control the reset, increment and overflow of the vertical line counter after every horizontal line B: process(hsyncb, reset) begin -- reset asynchronously clears line counter if reset='0' then vcnt <= (others => '0'); -- vert. line counter increments after every horiz. line elsif (hsyncb'event and hsyncb = '1') then -- vert. line counter rolls-over after the set number of lines (set by the constants) if vcnt < V_PERIOD then vcnt <= vcnt + 1; else vcnt <= (others => '0'); end if; end if; end process; -- set the horizontal sync high time and low time according to the constants C: process(clock, reset) begin -- reset asynchronously sets horizontal sync to inactive if reset = '0' then hsyncb <= '1'; -- horizontal sync is recomputed on the rising edge of every dot clock elsif (clock'event and clock = '1') then -- horiz. sync is low in this interval to signal start of a new line if (hcnt >= (H_FRONTPORCH + H_PIXELS) and hcnt < (H_PIXELS + H_FRONTPORCH + H_SYNCTIME)) then hsyncb <= '0'; else hsyncb <= '1'; end if; end if; end process; -- set the vertical sync high time and low time according to the constants D: process(hsyncb, reset) begin -- reset asynchronously sets vertical sync to inactive if reset = '0' then vsyncb <= '1'; -- vertical sync is recomputed at the end of every line of pixels elsif (hsyncb'event and hsyncb = '1') then 33

34 -- vert. sync is low in this interval to signal start of a new frame if (vcnt >= (V_LINES + V_FRONTPORCH) and vcnt < (V_LINES + V_FRONTPORCH + V_SYNCTIME)) then vsyncb <= '0'; else vsyncb <= '1'; end if; end if; end process; latch <= NOT reset; -- asserts the blaking signal (active low) E: process (clock) begin if clock'event and clock = '1' then if (hcnt >= H_PIXELS and hcnt < H_PERIOD) or (vcnt > V_LINES and vcnt <= V_PERIOD) then enable <= '0'; else enable <= '1'; end if; end if; end process; H: hloc <= hcnt(9 downto 0); vloc <= vcnt(9 downto 0); end VGAcore_arch; Simulazioni 1. Fronte di salita del segnale hsyncb della riga 15 => avviene ancora all interno dei colpi di clock di riga 14, esattamente al colpo di clock = (display time + front porch + sync time) = 976. Contemporaneamente viene incrementato il contatore di riga. Ovviamente il segnale enable è basso perché si tratta di un pixel fuori risoluzione. Figura 19. Simulazione fronte di salita di hsyncb versione 800 x

35 2. Fronte di discesa del segnale hsyncb della riga 18 => avviene esattamente al colpo di clock = (display time + front porch) = 856 di riga 18. Ovviamente il segnale enable è basso perché si tratta di un pixel fuori risoluzione. Figura 20. Simulazione fronte di discesa di hsyncb versione 800 x Fronte di salita del segnale vsyncb della seconda schermata. Avviene ancora all interno della prima schermata, esattamente alla riga = (600 + front porch + sync time) = 643, in contemporanea al fronte di salita del segnale hsyncb => pixel 976. Ovviamente il segnale enable è basso perché si tratta di un pixel fuori risoluzione. Figura 21. Simulazione fronte di salita di vsyncb versione 800 x Fronte di discesa del segnale vsyncb della seconda schermata. Avviene ancora all interno della seconda schermata, esattamente alla riga = (600 + front porch) = 637, in contemporanea al fronte di salita del segnale hsyncb => pixel 976. Ovviamente il segnale enable è basso perché si tratta di un pixel fuori risoluzione. Figura 22. Simulazione fronte di discesa di hsyncb versione 800 x

36 5. Fronte di salita del segnale enable; primo pixel valido (0,0) della seconda schermata. Figura 23. Simulazione fronte di salita di enable versione 800 x 600 Attenzione: I valori che compaiono in hloc (11,12,13, ) sono dovuti al fatto che hloc è un vettore di 10 bit, mentre hcnt è un vettore di 11 bit. Questo perché hloc è il segnale che deve portare il valore del pixel corrente all entità VGA che a sua volta sceglie il colore del pixel. I valori per quali l enable è basso non hanno quindi significato per l entità VGA, che in ogni caso li trascura. 6. Fronte di discesa del segnale enable; ultimo pixel valido (599,799) della seconda schermata. Figura 24. Simulazione fronte di discesa di enable versione 800 x

37 Modulo VGA versione 800 x 600 L entità VGA è il modulo di livello superiore per quanto riguarda la gestione dell uscita VGA. Il compito unico svolto da questa entità è di decidere, pixel per pixel, il colore da portare in uscita. Questa scelta è resa possibile grazie alle informazioni che arrivano all entità direttamente dai moduli della logica del gioco. Nonostante il gioco sia stato prodotto in due versioni differenti (640x480 e 800x600) le differenze in questo modulo sono minime in quanto tutte le tempistiche sono gestite dal modulo VGAcore. Descrizione dell entità Entità con 7 ingressi e 3 uscite; Ingressi: Figura 25. modulo VGA versione 800 x pos_x_pallina: vettore che porta in ingresso la coordinata x del pixel centrale della pallina; - pos_y_pallina: vettore che porta in ingresso la coordinata y del pixel centrale della pallina; - reg_pos_sx: vettore che porta in ingresso il punto medio del pad di sinistra; - reg_pos_dx: vettore che porta in ingresso il punto medio del pad di destra; - giocoattivo: segnale che indica se il gioco si trova nello stato di pausa o nello stato di gioco; 37

38 - clk: ciclo di clock del sistema a 50 mhz; - rstn: segnale di reset attivo basso. Uscite: - rgb: vettore che porta al monitor i valori dei singoli segnali r (red), g (green), b (blue); - hsync: segnale di sincronismo orizzontale; - vsync: segnale di sincronismo verticale. Codice vhdl (riportato per semplicità solo il codice della versione 800x600) library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_unsigned.all; use IEEE.std_logic_arith.all; entity VGA is port ( clk: in STD_LOGIC; rstn: in STD_LOGIC; -- clock -- asynchronous active low reset reg_pos_sx: in STD_LOGIC_VECTOR(9 downto 0); -- posizione del centro della pad sx reg_pos_dx: in STD_LOGIC_VECTOR(9 downto 0); -- posizione del centro della pad dx pos_x_pallina: in STD_LOGIC_VECTOR(9 downto 0); -- posizione x del centro della pallina pos_y_pallina: in STD_LOGIC_VECTOR(9 downto 0); -- posizione y del centro della pallina rgb: out STD_LOGIC_VECTOR (2 downto 0); hsync: out STD_LOGIC; vsync: out STD_LOGIC; giocoattivo: in STD_LOGIC ); end VGA; -- uscita VGA -- horizontal sync for monitor -- vertical sync for monitor architecture VGA_arch of VGA is -- control VGA signals component VGAcore generic ( H_SIZE : integer; -- horizontal size of input image, MAX 800 V_SIZE : integer -- vertical size of input image, MAX 600 ); 38

39 port ( ); end component; reset: in std_logic; -- asynchronous active low reset clock: in std_logic; -- clock hsyncb: buffer std_logic; -- horizontal (line) sync vsyncb: out std_logic; -- vertical (frame) sync latch: out STD_LOGIC; -- latches new RGB value enable: out STD_LOGIC; -- enable/ground RGB output lines hloc: out std_logic_vector(9 downto 0); -- horizontal address to be decoded for video RAM vloc: out std_logic_vector(9 downto 0) -- vertical address to be decoded for video RAM signal hsyncint : STD_LOGIC; signal vsyncint : STD_LOGIC; signal hloc : std_logic_vector(9 downto 0); signal vloc : std_logic_vector(9 downto 0); -- horizontal location of each pixel -- vertical location of each pixel signal pixelvalido: STD_LOGIC; -- INIZIO AGGIUNTE -- costanti dei colori (indice nella palette) constant NERO: STD_LOGIC_VECTOR (2 downto 0) :="000"; constant BLU: STD_LOGIC_VECTOR (2 downto 0) :="001"; constant VERDE: STD_LOGIC_VECTOR (2 downto 0) :="010"; constant CELESTE: STD_LOGIC_VECTOR (2 downto 0) :="011"; constant ROSSO: STD_LOGIC_VECTOR (2 downto 0) := "100"; constant VIOLA: STD_LOGIC_VECTOR (2 downto 0) := "101"; constant GIALLO: STD_LOGIC_VECTOR (2 downto 0) := "110"; constant BIANCO: STD_LOGIC_VECTOR (2 downto 0) := "111"; -- costanti delle dimensioni della pallina e delle pad: devono essere uguali a quelle definite in algoritmipong.vhd constant SEMILUNGPAD: INTEGER := 40; -- meta' della lunghezza della pad constant DISTPADDALBORDO: INTEGER := 16; -- quanto le due pad distanto dal bordo sx o dx constant LARGPAD: INTEGER := 16; -- quanto e' larga (spessore) la pad constant SEMILATOPALLINA: INTEGER := 8; -- semi lato della pallina constant DISTCONFINEDALBORDO: INTEGER := 16; -- quanto i bordi del campo in alto e in basso distano dal bordo superiore e inferiore dello schermo constant LARGCONFINE: INTEGER := 16; -- quanto sono larghi i bordi del campo 39

40 -- funzione che ritorna un booleano -- ritorna vero se il pixel che devo dipingere (determinato da (hloc,vloc)) appartiene alla pad -- questa funzione controlla solo le coordinate verticali, per le coord orizzontali il controllo avviene esternamente alla funziona -- (la coord orizzontale determina quale pad sto disegnando) function intervallo_verticale_pad (vloc: STD_LOGIC_VECTOR (9 downto 0); pos: STD_LOGIC_VECTOR (9 downto 0)) return BOOLEAN is variable sopra: STD_LOGIC_VECTOR(9 downto 0); variable sotto: STD_LOGIC_VECTOR(9 downto 0); begin sopra := pos - SEMILUNGPAD; -- bordo superiore della pad sotto := pos + SEMILUNGPAD; -- bordo inferiore della pad end; if vloc >= sopra and vloc <= sotto then return true; else return false; end if; -- funzione che ritorna un booleano -- ritorna vero se il pixel che devo dipingere (determinato da (hloc,vloc)) appartiene alla pallina function regione_pallina(vloc: STD_LOGIC_VECTOR (9 downto 0); hloc: STD_LOGIC_VECTOR (9 downto 0); pos_x_pallina: STD_LOGIC_VECTOR (9 downto 0); pos_y_pallina: STD_LOGIC_VECTOR (9 downto 0)) return BOOLEAN is variable latosopra: STD_LOGIC_VECTOR(9 downto 0); variable latosotto: STD_LOGIC_VECTOR(9 downto 0); variable latosx: STD_LOGIC_VECTOR(9 downto 0); variable latodx: STD_LOGIC_VECTOR(9 downto 0); begin latosx := pos_x_pallina - SEMILATOPALLINA; latodx := pos_x_pallina + SEMILATOPALLINA; latosopra := pos_y_pallina - SEMILATOPALLINA; latosotto := pos_y_pallina + SEMILATOPALLINA; then end; if vloc >= latosopra and vloc <= latosotto and hloc >= latosx and hloc <= latodx return true; else return false; end if; -- FINE AGGIUNTE 40

41 begin -- VGA controller cycler : VGAcore generic map ( H_SIZE => 800, V_SIZE => 600 ) port map( reset => rstn, clock => clk, hsyncb => hsyncint, vsyncb => vsyncint, latch => open, enable => pixelvalido, hloc => hloc, vloc => vloc ); -- PARTE MODIFICATA -- disegna i limiti del campo, la pallina e le pad nelle posizioni date da reg_pos_sx, reg_pos_dx, pos_x_pallina, pos_y_pallina process (vloc, hloc) begin -- disegna la palla prima di tutto: facendo cosi' la palla e' "sopra" tutto il resto (linee di confine e pad) -- la logica del gioco fa in modo comunque che essa non venga mai disegnata sopra le linee e le pad -- (in pratica le coordinate della palla non possono mai uscire dalla regione rettangolare delimitata dai confini e dalle pad if pixelvalido='1' then if (regione_pallina(vloc, hloc, pos_x_pallina, pos_y_pallina)) then rgb <= BIANCO; else -- se questo pixel non deve essere colorato di bianco perche' e' un pixel occupato dalla pallina, controlla gli altri casi... if (vloc >= DISTCONFINEDALBORDO-1 and vloc <= DISTCONFINEDALBORDO+LARGCONFINE-1) or (vloc >= (600- (DISTCONFINEDALBORDO+LARGCONFINE-1)) and vloc <= (600- DISTCONFINEDALBORDO-1)) then rgb <= GIALLO; -- disegna i limiti del campo, su cui la palla rimbalza 41

42 elsif vloc > (DISTCONFINEDALBORDO+LARGCONFINE-1) and vloc < (600-(DISTCONFINEDALBORDO+LARGCONFINE)-1) then -- altrimenti, se siamo nel centro del campo da gioco if hloc >= DISTPADDALBORDO-1 and hloc <= (DISTPADDALBORDO+LARGPAD-1) and intervallo_verticale_pad(vloc, reg_pos_sx) then -- disegna pad di sinistra rgb <= ROSSO; elsif hloc >= (800- (DISTPADDALBORDO+LARGPAD)-1) and hloc <= (800-DISTPADDALBORDO-1) and intervallo_verticale_pad(vloc, reg_pos_dx) then -- disegna pad di destra rgb <= VERDE; else if giocoattivo = '1' then -- se in questo momento sto giocando, lo sfondo allora e' di colore nero rgb <= NERO; else -- altrimenti se sono in pausa lo sfondo e' di colore viola rgb <= VIOLA; end if; end if; else if giocoattivo = '1' then -- se in questo momento sto giocando, lo sfondo allora e' di colore nero rgb <= NERO; else -- altrimenti se sono in pausa lo sfondo e' di colore viola rgb <= VIOLA; end if; end if; end if; end if; end process; -- FINE PARTE MODIFICATA -- pass the outputs out hsync <= hsyncint; vsync <= vsyncint; end VGA_arch; Simulazione Per simulare il blocco VGA abbiamo fissato le posizioni dei 2 pad e della pallina con i seguenti valori: Altezza pad di sinistra = 100 ( ) Altezza pad di destra = 200 ( ) Pallina 200, 300 ( , ) 42

43 Nel file VGA.vhd sono stati mantenuti i valori della distanze dai bordi, della semilunghezza dei 2 pad e del semilato della pallina impostati sulla scheda XSV. I bordi superiori e inferiori distano 16 pixel dal bordo superiore e inferiore dello schermo, come i 2 pad dal bordo destro e sinistro dello schermo, entrambi i pad sono lunghi 80 pixel e larghi 16, la pallina contiene tutti i pixel che hanno una distanza di 8 pixel dalla posizione corrente del centro della pallina. A schermo dovrebbe essere visualizzato se il gioco è attivo (segnale giocoattivo= 1 ): Figura 26. schermata test con gioco attivo versione 800 x

44 altrimenti se il gioco è in pausa (giocoattivo= 0 ): Figura 27. schermata test con gioco in pausa versione 800 x 600 Sono stati quindi scelti 3 valori di test per tutti i possibili colori che possono essere visualizzati andando a prendere anche i casi limiti che corrispondono al primo e all ultimo pixel dei pad e della pallina. Segue la tabella con i valori di test e le relative simulazioni. VALORI DI TEST hloc vloc Colore RGB (binario) RGB (decimale) giocoattivo 0 15 Giallo Giallo Giallo Rosso Rosso Rosso Bianco Bianco Bianco Verde Verde Verde Nero

45 Nero Nero Viola Viola Viola Premessa: tutte le simulazioni sono state eseguite ponendo il segnale di reset rstn attivo per disattivare di fatto il reset del gioco. Figura 28. hloc=0 vloc=15 -> RGB=6 (giallo) versione 800 x 600 Figura 29. hloc=79 vloc=15 -> RGB=6 (giallo) versione 800 x

46 Figura 30. hloc=300 vloc=583 -> RGB=6 (giallo) versione 800 x 600 Figura 31. hloc=15 vloc=60 -> RGB=4 (rosso) versione 800 x 600 Figura 32. hloc=23 vloc=100 -> RGB=4 (rosso) versione 800 x

47 Figura 33. hloc=31 vloc=140 -> RGB=4 (rosso) versione 800 x 600 Figura 34. hloc=192 vloc=292 -> RGB=7 (bianco) versione 800 x 600 Figura 35. hloc=200 vloc=300 -> RGB=7 (bianco) versione 800 x

48 Figura 36. hloc=208 vloc=308 -> RGB=7 (bianco) versione 800 x 600 Figura 37. hloc=783 vloc=160 -> RGB=2 (verde) versione 800 x 600 Figura 38. hloc=775 vloc=200 -> RGB=2 (verde) versione 800 x

49 Figura 39. hloc=767 vloc=240 -> RGB=2 (verde) versione 800 x 600 Figura 40. hloc=250 vloc=40 -> RGB=0 (nero) giocoattivo= 1 versione 800 x 600 Figura 41. hloc=300 vloc=200 -> RGB=0 (nero) giocoattivo= 1 versione 800 x

50 Figura 42. hloc=500 vloc=412 -> RGB=0 (nero) giocoattivo= 1 versione 800 x 600 Figura 43. hloc=250 vloc=40 -> RGB=5 (viola) giocoattivo= 0 versione 800 x 600 Figura 44. hloc=300 vloc=200 -> RGB=5 (viola) giocoattivo= 0 versione 800 x

51 Figura 45. hloc=500 vloc=412 -> RGB=5 (viola) giocoattivo= 0 versione 800 x

52 Modulo VGA versione 640 x 480 Simulazione Per simulare il blocco VGA abbiamo fissato le posizioni dei 2 pad e della pallina con i seguenti valori: Altezza pad di sinistra = 100 ( ) Altezza pad di destra = 200 ( ) Pallina 200, 300 ( , ) Nel file VGA.vhd sono stati modificati i valori della distanze dai bordi, della semilunghezza dei 2 pad e del semilato della pallina, ridimensionando il tutto alla nuova risoluzione di 640 x 480, infatti i precedenti valori erano stati calcolati sulla risoluzione di 800 X 600. Procedendo quindi a una riduzione del 20% su tutte le dimensioni risulta ora che i bordi superiori e inferiori distano 13 dal bordo superiore e inferiore dello schermo, come i 2 pad dal bordo destro e sinistro dello schermo, entrambi i pad sono lunghi 64 pixel e larghi 13, la pallina contiene tutti i pixel che hanno una distanza di 6 pixel dalla posizione corrente del centro della pallina. A schermo dovrebbe essere visualizzato se il gioco è attivo (segnale giocoattivo= 1 ): Figura 46. schermata test con gioco attivo versione 640 x

53 altrimenti se il gioco è in pausa (giocoattivo= 0 ): Figura 47. schermata test con gioco in pausa versione 640 x

54 Sono stati quindi scelti 3 valori di test per tutti i possibili colori che possono essere visualizzati andando a prendere anche i casi limiti che corrispondono al primo e all ultimo pixel dei pad e della pallina. Segue la tabella con i valori di test e le relative simulazioni. VALORI DI TEST hloc vloc Colore RGB (binario) RGB (decimale) giocoattivo 0 12 Giallo Giallo Giallo Rosso Rosso Rosso Bianco Bianco Bianco Verde Verde Verde Nero Nero Nero Viola Viola Viola Premessa: tutte le simulazioni sono state eseguite ponendo il segnale di reset rstn attivo per disattivare di fatto il reset del gioco. Figura 48. hloc=0 vloc=12 -> RGB=6 (giallo) versione 640 x

55 Figura 49. hloc=79 vloc=12 -> RGB=6 (giallo) versione 640 x 480 Figura 50. hloc=300 vloc=466 -> RGB=6 (giallo) versione 640 x 480 Figura 51. hloc=12 vloc=68 -> RGB=4 (rosso) versione 640 x

56 Figura 52. hloc=19 vloc=100 -> RGB=4 (rosso) versione 640 x 480 Figura 53. hloc=25 vloc=132 -> RGB=4 (rosso) versione 640 x 480 Figura 54. hloc=194 vloc=294 -> RGB=7 (bianco) versione 640 x

57 Figura 55. hloc=200 vloc=300 -> RGB=7 (bianco) versione 640 x 480 Figura 56. hloc=206 vloc=306 -> RGB=7 (bianco) versione 640 x 480 Figura 57. hloc=626 vloc=168 -> RGB=2 (verde) versione 640 x

58 Figura 58. hloc=620 vloc=200 -> RGB=2 (verde) versione 640 x 480 Figura 59. hloc=613 vloc=232 -> RGB=2 (verde) versione 640 x 480 Figura 60. hloc=250 vloc=40 -> RGB=0 (nero) giocoattivo= 1 versione 640 x

59 Figura 61. hloc=300 vloc=200 -> RGB=0 (nero) giocoattivo= 1 versione 640 x 480 Figura 62. hloc=500 vloc=412 -> RGB=0 (nero) giocoattivo= 1 versione 640 x 480 Figura 63. hloc=250 vloc=40 -> RGB=5 (viola) giocoattivo= 0 versione 640 x

60 Figura 64. hloc=300 vloc=200 -> RGB=5 (viola) giocoattivo= 0 versione 640 x 480 Figura 65. hloc=500 vloc=412 -> RGB=5 (viola) giocoattivo= 0 versione 640 x

61 Porting display 7 segmenti e reset Porting display 7 segmenti Un altro problema riscontrato nella fase di porting sulla Spartan3 è stato la gestione dei 4 display a 7 segmenti. Mentre la XSV usata dall Università di Trieste ha 2 display 7 segmenti sulla scheda, la Spartan3 ne ha 4 e sua una logica di uso molto più complessa. Visto che ogni display ha bisogno di 8 ingressi (se si comprende il decimal point DP), cioè 8 pin della FPGA, questo implicherebbe uno spreco di 32 segnali non utilizzabili ad altri scopi, per questo la Spartan3 usa solo un bus per pilotare i 7 segmenti e gestisce i 4 display attraverso 4 segnali di enable (abilitazione) come descritto nel datasheet della scheda: Figura 66. disposizione dei display 7 segmenti sulla scheda della Spartan 3 Per poter stampare un simbolo su uno dei display è necessario forzare a 0 il segnali di abilitazione in questo caso AN3 e scrivere sul bus che pilota i segmenti la lettera da visualizzare, questo però limita l uso di un display per volta infatti appena il segnali di enable ritorna allo stato logico alto il display si spegne. Un altra caratteristica che differenzia l interfaccia della Spartan3 dalla XSV è l uso di display a 7 segmenti ad anodo comune cioè per accendere un segmento è necessario mettere sulla corrispondente linea di comando un livello logico basso mentre nel caso della XSV essendo il display a catodo comune per accendere un segmento bisognava forzare la corrispondente linea di comando con un livello logico alto. Qui di seguito sono riportati i valori da fornire alle linee di comando per visualizzare le cifre esadecimali (da 0 a 9 e da A a F). Carattere A B C D E F G

62 A B C D E F

63 Modulo Seg7 Per risolvere questo problema è stato necessario modificare il file seg7.vhd che rappresenta un decoder per display 7 segmenti assegnando in uscita i valori riportati in tabella. Listato VHDL Figura 67. modulo seg7 -- seg7.vhd -- entity che pilota un display a sette segmenti a partire da un valore binario su 4 bit library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_unsigned.all; entity seg7 is port ( binary: in STD_LOGIC_VECTOR (3 downto 0); -- valore da 0 a 15 in binario da visualizzare hex: out STD_LOGIC_VECTOR (6 downto 0) bus di 7 linee che comanda il display a 7 segmenti --rispettivamente i segmenti a,b,c,d,e,f,g ); end seg7; architecture seg7_arch of seg7 is begin process (binary) begin CASE binary is WHEN "0000"=> hex <= " "; -- codifica il valore 0 WHEN "0001"=> hex <= " "; -- codifica il valore 1 WHEN "0010"=> hex <= " "; -- codifica il valore 2 WHEN "0011"=> hex <= " "; -- codifica il valore 3 WHEN "0100"=> hex <= " "; -- codifica il valore 4 WHEN "0101"=> hex <= " "; -- codifica il valore 5 WHEN "0110"=> hex <= " "; -- codifica il valore 6 WHEN "0111"=> hex <= " "; -- codifica il valore 7 WHEN "1000"=> hex <= " "; -- codifica il valore 8 WHEN "1001"=> hex <= " "; -- codifica il valore 9 WHEN "1010"=> hex <= " "; -- codifica il valore A WHEN "1011"=> hex <= " "; -- codifica il valore B WHEN "1100"=> hex <= " "; -- codifica il valore C

64 WHEN "1101"=> hex <= " "; -- codifica il valore D WHEN "1110"=> hex <= " "; -- codifica il valore E WHEN "1111"=> hex <= " "; -- codifica il valore F WHEN others => hex <= " "; end CASE; end process; end seg7_arch; Simulazione Per controllare la correttezza degli assegnamenti è stata eseguita una simulazione con ModelSIM: Figura 68. Simulazione modulo seg7 In questi casi per riuscire in una simulazione esaustiva cioè che controlli tutti i possibili valori di binary è comodo impostare il bit più significativo come clock con periodo che sia un multiplo di una potenza del 2 e fare in modo che il bit successivo abbia periodo pari alla metà del precedente, così si riesce a simulare tutte le combinazioni che vanno da 0000 a Come si può notare tutti gli assegnamenti vengono eseguiti correttamente ogni volta che binary cambia di valore. 64

65 Modulo ScanDisplay Per risolvere il problema dell uso contemporaneo di 2 display 7 segmenti per visualizzare i punteggi dei 2 giocatori è stata creata una entity che scandisce in uscita i 2 punteggi alternandoli con una frequenza pari a 1 Mhz, visualizzandoli prima sul primo display a 7 segmenti e poi sul secondo e così via. Abbiamo usato una frequenza di 1 Mhz perché provando con una frequenza superiore (per esempio il clock di sistema 50 Mhz) i segmenti dei display non facevano in tempo a spegnersi completamente rimanendo in uno stato intermedio e non permettendo la corretta visualizzazione del punteggio. Il principio di funzionamento della logica è che l occhio umano non riesce a distinguere 2 fotogrammi con una frequenza di refresh maggiore di 20 Hz quindi sembrerà che i due punteggi siano visualizzati nello stesso instante di tempo. Il modulo VHDL creato è una banale macchina a stati finiti che alterna il valore in uscita abilitando ogni volta solo uno dei 2 display: S0 enabledisp<="1110"; punteggio<=punt1; S3 enabledisp<="111"; punteggio<=" "; S1 enabledisp<="1111"; punteggio<=" "; S2 enabledisp<="0111"; punteggio<=punt2; Figura 69. diagramma di stato di scandisplay Il modulo così creato ha la seguente struttura: Listato VHDL library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; Figura 70. modulo scandisplay 65

66 use IEEE.STD_LOGIC_UNSIGNED.ALL; entity scandisplay is Port ( clk : in std_logic; punt1 : in std_logic_vector(6 downto 0); punt2 : in std_logic_vector(6 downto 0); --punteggio 1UP --punteggio 2UP --punteggio da visualizzare punteggio : out std_logic_vector(6 downto 0); enabledisp: out std_logic_vector(3 downto 0)); --enable display 1 e 4 end scandisplay; architecture scandisplay_arch of scandisplay is component Divisore50 is port ( clkin: in STD_LOGIC; -- clock di ingresso, es 50mhz clkout: out STD_LOGIC; -- clock di uscita: -> 1 mhz rstn: in STD_LOGIC-- reset (negativo) ); end component; type stato is (S0,S1,S2,S3); signal s: stato :=S0; --S0 è lo stato iniziale signal next_s: stato; signal clk1mhz: std_logic; signal semprealto: std_logic; del divisore50; --segnale che non attiva mai il reset begin divisoreclock: Divisore50 port map ( clkin => clk, -- collega il clock a 50mhz entrante al divisore di clock clkout => clk1mhz, -- in uscita ho il clock a 1 mhz che controlla tutto il resto rstn => semprealto ); PROCESS (clk1mhz, next_s) BEGIN IF clk1mhz='1' AND clk1mhz'event THEN del clock cambia stato s <= next_s; END IF; END PROCESS; --ogni fronte di salita PROCESS (s) BEGIN CASE s IS WHEN S0 => enabledisp<="1110"; punteggio<=punt1; 66

67 END CASE; END PROCESS; semprealto<='1'; end scandisplay_arch; Simulazione next_s<=s1; WHEN S1 => enabledisp<="1111"; punteggio<=" "; next_s<=s2; WHEN S2 => enabledisp<="0111"; punteggio<=punt2; next_s<=s3; WHEN S3 => enabledisp<="1111"; punteggio<=" "; next_s<=s0; Figura 71. Simulazione modulo scandisplay Come si può notare lo stato iniziale è S0 e ad ogni fronte di salita di clk lo stato cambia seguendo il diagramma degli stati fino a ritornare in S0. Quando lo stato presente è S1 viene posto in uscita punt1 ( , punteggio di destra) e abilitando enabledisp<0> cioè il quarto display a 7 segmenti, altrimenti viene abilitato il primo display (enabledisp<3>) e in uscita viene messo punt2 ( , punteggio di sinistra). 67

68 Porting reset Un ultima differenza tra la Spartan3 e la XSV sono i push-button. Uno di essi viene usato dal la logica come reset asincrono attivo basso infatti come si può vedere dalla schematica della XSV (scheda di Trieste) in condizioni normali i pin della FPGA collegati ai push-button sono forzati a livello logico alto tramite dei resistori di pullup mentre passano a livello logico basso se e solo se vengono premuti i bottoni. Figura 72. Schematica di utilizzo dei push-button sulla scheda XSV Per risolvere questo ultimo problema visto che la logica originaria era stata interamente pensata con un reset attivo basso è stato necessario introdurre un inverter prima di fornire il segnale di reset a tutti i moduli che lo usano, in questo modo il reset risulterà ancora attivo basso. 68

69 Porting Ps/2 e algoritmo gioco Pong Porting PS/2 Utilizzo della tastiera tramite protocollo PS/2 Il protocollo PS2 prevede la presenza di due soli segnali: uno è il comune segnale di clock mentre il secondo è dedicato alla trasmissione dei dati vera e propria. Il bus PS2 si interfaccia direttamente alla FPGA tramite i pin M15 per ps2data e M16 per ps2clk ed è ovviamente sincrono (data la presenza del clock) e bidirezionale. Il flusso dati è composto da pacchetti di 11 bit strutturati nel seguente modo: un bit è detto di start ed è posto fisso a 0; seguono 8 bit di dato, inviati a partire dal bit meno significativo; un bit per il controllo della parità (parità dispari); un bit di stop che segna la fine della comunicazione (anch esso posto fisso a 1). Ovviamente la sequenza di 8 bit inviata dalla tastiera all FPGA non è nient altro che la codifica del tasto premuto. Figura 73. Protocollo PS/2 Se è la tastiera a voler effettuare l invio dei dati, inizia la trasmissione esclusivamente se il segnale di clock è alto, ponendo i bit sul segnale DATA; la lettura avviene invece sul fronte di discesa. Se invece è la FPGA a voler effettuare la comunicazione con la tastiera, il clock viene posto basso per 100 µs, in questo modo viene inibita la possibilità di inviare dati da parte della tastiera. Quindi si abbassa la linea DATA, mentre il clock torna a livello alto. In questa situazione, la tastiera si rende conto che ci si trova nella situazione in cui è l FPGA a voler comunicare, e inizia la generazione del clock; la tastiera registra il dato sul fronte di salita. Sempre nell ambito della comunicazione FPGA -> tastiera, dopo l invio dell ultimo bit di stop da parte dell FPGA, la tastiera attende il successivo fronte di salita del clock per inviare all FPGA un bit a 0 (acknowledge). 69

70 Figura 74. Arbitraggio bus PS/2 Nel caso del gioco del Pong, si è utilizzata la tastiera per comandare il moto verticale delle pad; a questo proposito il movimento è stato implementato attivando la ripetizione sulla tastiera cioè ad ogni pressione corrisponde un singolo movimento del pad. Descrizioni entità VHDL per l utilizzo della tastiera GestioneTastieraPong Questa entity si occupa di ricevere il clock di 50 MHz (clk50 MHz) che dividerà poi per 50 per ottenere il clock a 1 MHz, valore utilizzato da tutte le altre entità per la gestione della tastiera, riceve inoltre i codici dei tasti premuti e riconosce se essi sono quelli per il controllo del pad: pl1su -> A, pl1giu -> Z, pl2su -> K, pl2giu -> M o P (tasto per la pausa). Inoltre, in caso di reset invia dei byte alla tastiera per la sua configurazione. L architecture dell entity (GestioneTastieraPong_arch) collega tra loro le varie entità preposte all utilizzo della tastiera: Divisore50, ps2keyboard_pong, RiconosciTasti, delayresettast, delay131ms, configtastiera, riconoscifrontesalita. divisore50 Riceve in ingresso un clock di 50 MHz (clkin) e ne produce in output uno da 1 MHz (clkout). In sostanza, ogni 25 colpi di clock, inverte l'uscita clkout, producendo in tal modo il valore di clock in output di 1 MHz. delay131ms Genera un ritardo di cicli di clock (corrisponde a circa 131 ms se si considera una frequenza di clock a 1 MHz). Questo ritardo è utilizzato per fare in modo che la tastiera abbia modo di completare l esecuzione del comando inviatole prima di spedirgliene un altro. 70

71 Configtastiera Entità che nella prima fase di accensione del gioco invia alla tastiera i byte per configurarla. Per prima cosa bisogna porre il byte da inviare sulla linea byte e porre a livello logico basso il segnale send dell entity ps2keyboard_pong. Dopo ogni invio viene attivato un timer (delay131ms) per dar tempo alla tastiera di ricevere il comando tranne nell invio del primo byte che richiede un tempo di elaborazione della tastiera più lungo (circa mezzo secondo) che è implementato dalla entity deleyresettast Alla tastiera vengono inviati i seguenti byte: 0XFF per il reset della tastiera 0XF0 per impostare lo scancode set cioè l insieme di byte associati alla pressione di un tasto 0X03 scancode set da impostare 0XF3 imposta la velocità della ripetizione 0X00 massima velocità di ripetizione (distacco tra 2 ripetizioni minimo) delayresettast Utilizzato per aspettare che la tastiera completi le procedure di self-test dopo il reset prima di spedire altri comandi. Il ritardo è più lungo di delay131ms, perché non si deve aspettare solo il completamento dell'esecuzione di un comando ma anche il self-test della tastiera. Riconoscitasti Entity che riconosce i tasti premuti e genera un impulso sui 5 diversi segnali ( pl1su, pl1giu, pl2su, pl2giu, pausa). Guarda il byte presente su charin e attiva la linea se il valore su charin è lo scancode del tasto corrispondente. La linea viene attivata solo per un colpo di clock. I codici scancode sono i seguenti: " " => tasto A " " => tasto Z " " => tasto K " " => tasto M " " => tasto P riconoscifrontedisalita Entità che rappresenta un riconoscitore di fronti di salita. L uscita di questo modulo è sempre a livello logico basso tranne nel caso in cui il segnale d ingresso ha una transizione da livello logico basso a livello logico alto 71

72 ps2keyboard_pong Figura 75. FSM riconoscifrontesalita Come la precedente GestioneTastieraPong, è una entity che si occupa di collegare tra loro varie sotto-entitity, in particolare: clockpause, counter8, devsync, parity, ps2dcdr, siposhiftreg, pisoshiftreg. La relazione tra le entità è schematizzata nel grafico seguente: Figura 76. struttura interna modulo ps2keyboard_pong 72

73 Clockpause Entity che crea un ritardo di 64 ms paria 64 periodi di clock se il clock ha frequenza di 1 MHz, viene usato da ps2dcdr.vhd per gestire l arbitraggio del bus PS/2. I segnali start e done servono rispettivamente a far partire il timer e a indicare il fine conteggio counter8 Contatore modulo 8 usato da ps2dcdr.vhd per contare i byte ricevuti e quelli da inviare Devsync Entity che riconosce i fronti di discesa di ps2clk attivando il segnale d uscita sync che verrà poi utilizzato dal modulo ps2dcdr per aggangiarsi al segnale ps2data e leggere i vari bit sul bus PS/2. Parity Entity che calcola il bit di parità (parità dispari), viene usata sia per calcolare il bit di parità del byte da inviare che verrà poi accodato al byte ma anche per verificare che il bit di parità ricevuto dalla tastiera coincida con quello calcolato da questo modulo, se così non fosse questo indicherebbe un errore nella trasmissione sul bus. ps2dcdr Entity che gestisce il bus PS/2, ricevendo/inviando i byte sul bus, controllando la parità Siposhiftreg Registo SIPO (Serial Input Parallel Output) usato per assemblare, il byte ricevuto dalla tastiera a partire dai singoli bit ricevuti Pisoshiftreg Registro PISO (Parallel Input Serial Output) usato per inviare sul bus i singoli bit a partire dal byte da inviare. 73

74 Funzionamento Algoritmo gioco Pong Non avendo modificato i file relativi all algoritmo, verranno qui di seguito descritti per far capire all utente il funzionamento. Il gioco vero e proprio è governato da 2 moduli VHDL, algoritmipong che gestisce le collisioni e genera valori casuali e la macchina a stati finiti che gestisce le varie fasi del gioco: algoritmipong Le funzioni di questo modulo sono: gestire la velocità della pallina a seconda della posizione dello switch SW0 muovere le 2 pad leggendo i comandi provenienti dalla tastiera gestire le collisioni tra la pallina e le pad e tra la pallina e i bordi verticali ed orizzontali capire quando un giocatore ha fatto punto, incrementandone il relativo punteggio gestire in modo casuale il moto della pallina Questo modulo ha al suo interno 5 process: PROCESS 1: muove le pad leggendo in ingresso gli impulsi di incremento e decremento (plxsu, PlXgiu, dove x è 1 o 2) e incrementando la posizione in modo che la pad possa essere visualizzata correttamente dal modulo VGA. PROCESS 2: rappresenta un divisore che divide il clock di sistema 50 Mhz di un milione circa di volte al fine di generare il clock per incrementare/decrementare le coordinate della pallina a seconda della velocità scelta tramite lo switch SW0 PROCESS 3: incrementa le posizioni della pallina a seconda della modalità di gioco, se siamo in modalità facile, l incremento è di 2 pixel, 4 se siamo in modalità difficile. Gli angoli di riflessione in caso di collisioni sono pari a 0, 22,5, 45 e 67,5 gradi. PROCESS 4: rivela le collisioni tra la pallina e le pad oppure tra pallina e il bordo, nel primo caso viene generato un valore casuale che determina l angolo di riflessione mentre nel secondo viene solamente invertita la direzione verticale della pallina Infine se la pallina tocca il bordo destro/sinistro viene abilitato il segnale vincedx/vincesx che incrementerà il valore del punteggio corrente PROCESS 5: contatore a 32 bit utilizzato per generare la logica che genera valori pseudocasuali Fsmgioco Al reset la macchina parte dallo stato Inizio, che resetta l'entity algoritmipong (ponendo a livello logico basso l uscita resetgioco) e da cui esce solo quando viene asserito il segnale configtastierafinita che indica che il completamento della configurazione della tastiera (il segnale e' generato dall'entity GestioneTastieraPong). Si passa quindi allo stato Waste, dove viene tolta la condizione di reset, e quindi allo stato StandBy,che pone l'uscita giocoinpausa a 1, quindi ponendo il gioco in pausa. Dallo stato 74

75 StandBy si esce e si passa allo stato Gioco quando l'utente preme in tasto della pausa (condizione premutopausa='1'). Lo stato Gioco e' quello in cui l'entity algoritmipong accetta gli input dell'utente e muove le pad e la pallina e rileva le collisioni della pallina con i bordi campo, i bordi schermo e le pad. Dallo stato Gioco si può andare o nello stato Pausa, quando l'utente preme il tasto della pausa (stato nel quale la linea giocoinpausa viene nuovamente asserita, inibendo quindi i movimenti di pad e pallina; si torna in Gioco quando viene di nuovo premuto il tasto pausa), oppure si procede verso i due stati PuntiDX o PuntiSX quando l'entity riconosce l'arrivo della pallina ad uno dei bordi destro o sinistro dello schermo (segnale VinceDX o VinceSX asserito). Nei due stati PuntiDX e PuntiSX il gioco viene fermato (giocoinpausa <= 1) e i segnali incpuntidx e incpuntisx (a seconda del caso) vengono posti a 1 per un ciclo di clock (il segnale viene asserito nello stato PuntoDX o PuntoSX, a seconda del caso, e viene tolta l'asserzione negli stati WasteDX e WasteSX). Indipendentemente da chi realizza il punto, si passa nello stato NuovaPartita, dove viene resettata l'entity algoritmipong (le pad e la pallina vengono poste nuovamente al centro) e qui, dopo aver tolto l'asserzione per il reset nello stato Waste2, si ritorna nello stato StandBy. Segue diagramma degli stati della FSM gioco Pong 75

76 Figura 77. FSM gioco Pong 76

77 Conclusioni e sviluppi futuri Per concludere seguiranno le conclusioni dei membri del gruppo sottoforma di relazioni personali nonché gli sviluppi futuri dei moduli principalmente modificati all interno del progetto. RELAZIONE PERSONALE ALLONI FABIO Contributo: Il mio contributo nel gruppo si è concentrato principalmente sul porting dell uscita VGA di entrambe le versioni (640x480 a 60 Hz e 800x600 a 72 Hz) per quanto riguarda tutti gli aspetti della realizzazione. Il primo passo è infatti stato uno studio della versione precedente a livello software, seguito poi da una serie di realizzazioni di più soluzioni delle varie entità (entità divisore2, entità VGAcore, entità VGA). Infine sono state effettuate molte simulazioni sia attraverso l uso di strumenti software (modelsim), che attraverso l utilizzo vero e proprio della scheda. Conoscenze Acquisite: Le mie conoscenze acquisite in questo progetto sono veramente considerevoli, in quanto si trattava della mia prima esperienza nell ambito della progettazione hardware. Ho quindi imparato a conoscere sia le parti di incontro tra le due progettazioni (parti algoritmiche e procedurali), sia le parti di diversità (realizzazioni di tempistiche e concetto di segnale). Ho, inoltre, imparato a utilizzare gli strumenti di sviluppo ISE e ModelSim utilizzati per realizzare l intero progetto. Non era la prima volta, invece, che lavoravo in gruppo. Ho quindi trovato modo di migliorare anche sotto questo aspetto. Commenti sul lavoro: Il carico di lavoro mi è sembrato abbastanza proporzionato ai crediti assegnati per questo progetto, anche se ha richiesto da parte mia un impegno di tempo non indifferente. Per il resto, questa nuova esperienza è stata abbastanza interessanti e ritengo che potrà essermi utile anche in futuro. Non ho particolari segnalazioni da fare per quanto riguarda gli strumenti utilizzati in quanto la mia mancanza di esperienza non me lo consente. 77

78 RELAZIONE PERSONALE ALNI MATTEO Contributo: Nel porting del gioco del pong da Virtex a Spartan 3 mi sono occupato della gestione della tastiera e del protocollo PS2, verificando che l utilizzo di una diversa scheda non comportasse modifiche alle entity del progetto originale. Ho creato poi un modulo ps_2_controller aggiuntivo che permetta il riutilizzo del blocco tastiera per usi futuri, e una User Guide con le istruzioni per la programmazione della Spartan3 e i comandi utilizzati nel gioco. Conoscenze Acquisite: Tramite questo progetto ho avuto modo di conoscere gli ambienti di sviluppo e di simulazione ModelSIM e ISE, approfondendo inoltre la conoscenza del linguaggio VHDL introdotto nel corso. Il progetto è stato molto utile anche per apprendere le nozioni base della programmazione hardware. Commenti sul lavoro: Dal momento che il progetto assegnato prevedeva un interfacciamento tra Evaluation board e PC, è stato molto interessante comprendere il funzionamento dei protocolli PS2 e VGA, che non erano mai stati trattati in alcun corso del Politecnico. L aiuto che ci è stato offerto e le strutture che sono state messe a disposizione (tutor, laboratorio di microarchitetture, software EDK, ISE e ModelSIM) ci hanno permesso di svolgere un buon lavoro. 78

79 RELAZIONE PERSONALE CASTIGLIONI WILLIAM Contributo: Mi sono da subito interessato della problematica di porting hardware cioè dopo una prima comparazione tra l hardware delle 2 schede (spartan 3 e XSV) mi sono concentrato nell adattare la logica sviluppata per la scheda XSV, in particolare sull uso dei display 7 segmenti, dei push button e degli switch sulla scheda della Spartan 3. Ho anche contribuito alla realizzazione e simulazione delle versioni 800 x 600 e 640 x 480 e infine mi sono concentrato sulla generalizzazione dei blocchi con particolare attenzione al blocco ScanDisplayEDK. Conoscenze Acquisite: Ho imparato a utilizzare gli strumenti di sviluppo ISE e ModelSim, creando nuovi progetti e simulandoli. Ho inoltre migliorato il mio adattamento in un gruppo di lavoro abbastanza grande ( 3 persone) e ho acquisito una maggiore esperienza sia nell uso del VHDL sia per quanto riguarda le problematiche relative al porting, quindi al riadattamento di soluzioni sia software come il VHDL che hardware Commenti sul lavoro: Il lavoro visto anche il carico di studi previsto per il periodo è stato molto buono se si pensa che siamo riusciti nell arco di un mese circa a terminare il porting a simularlo e a provarlo in laboratorio. Anche se ai primi inizi del lavoro abbiamo riscontrato qualche problema di comunicazione e coordinamento all interno del gruppo con le settimane abbiamo acquisito una certa autonomia sia a livello individuale che a livello di gruppo. Per quanto riguarda gli strumenti di sviluppo utilizzati mentre per ISE non ho niente da segnalare se non che è un ottimo ambiente di sviluppo integrato per ModelSim viste anche delle mie esperienze di uso di altri simulatori, l ho trovato a volte un pò troppo macchinoso soprattutto perché ti obbliga a utilizzare come tipo di segnali dei clock che permettono di simulare eventi periodici ma non sporadici se non costringendo a estenuanti calcoli di ritardi e periodi. Per quanto riguarda la velocità di simulazione posso dire visti gli ultimi incrementi di memoria RAM degli attuali pc che è molto veloce rispetto all uso che facevo di simulatori VHDL circa 4 anni fa. 79

80 Sviluppo futuro modulo VGA e possibile uso in ambiente EDK Non esiste un modo generale per adattare l attuale modulo VGA a eventuali utilizzi futuri, per questo motivo seguirà una breve spiegazione su cosa andrebbe modificato dell attuale file VGA.vhd per poterlo riusare anche in ottica interfacciamento con il microprocessore MicroBlaze. Una volta scelta la risoluzione che si vuole utilizzare per l applicazione basterà modificare le porte d ingresso al modulo VGA a seconda della specifica applicazione, in questo progetto servivano le coordinate della pallina e dei 2 pad ma in un applicazione generica potrebbero servire informazioni diverse. Una volta definita l interfaccia all ingresso del modulo VGA ( potrebbero anche essere vettori lunghezza n), bisognerà collegarla al microprocessore in modo che questo riesca a forzare i valori dei diversi ingressi. Infine nel file VGA.vhd l unica cosa che va modificata è il seguente process: process (vloc, hloc) begin if (pixelvalido= 1) then.. rgb<=..;.. end if; end process; Questo process non fa altro che in base al pixel che attualmente deve essere stampato a schermo se è all interno della risoluzione (pixelvalido= 1 ), controllare gli ingressi al modulo VGA e assegnare il corrispettivo colore del pixel su RGB tramite costanti definite all interno del file vhd Segue una bozza di interfacciamento del blocco generalizzato con il microprocessore MicroBlaze. Figura 78. Possibile interfacciamento modulo VGA con MicroBlaze 80

81 Sviluppo futuro ScanDisplay (modulo ScanDisplayEDK) Per generalizzare un uso futuro dei display 7 segmenti è stato modificato il blocco ScanDisplay chiamandolo ScanDisplayEDK. Esso legge in ingresso 4 valori da 0 a 15 e i rispettivi 4 decimal point (DP1, DP2, DP3, DP4) e li converte automaticamente in modo da essere visualizzati sui 4 display a 7 segmenti. E stato modificato il diagramma degli stati che ora risulta: S0 enabledisp<="0111"; valore<=disp1; dp<=dp1; S1 enabledisp<="1111"; valore<=" "; dp<='1'; S7 enabledisp<="1111"; valore<=" "; dp<='1'; S2 enabledisp<="1011"; valore<=disp2; dp<=dp2; S6 enabledisp<="1110"; valore<=disp4; dp<=dp4; S5 enabledisp<="1111"; valore<=" "; dp<='1'; S4 enabledisp<="1101"; valore<=disp3; dp<=dp3; S3 enabledisp<="1111"; valore<=" "; dp<='1'; Figura 79. Diagramma degli stati di ScanDisplayEDK 81

82 Figura 80. Modulo ScanDisplayEDK Listato VHDL Segue il listato VHDL, che evidenza la presenza del divisore50 (sempre attivo) per ottenere una frequenza di refresh dei display 7 segmenti pari a 1 MHz e di 4 decoder (seg7) che decodificano il valore in ingresso impostando i bit per accendere/spegnere i vari segmenti library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity scandisplayedk is Port ( clk : in std_logic; disp1,disp2,disp3,disp4 : in std_logic_vector(3 downto 0); --valori da visualizzare dp1,dp2,dp3,dp4: in std_logic; --DP da visualizzare valore : out std_logic_vector(6 downto 0); --valore attualmente visualizzato dp: out std_logic; -- DP attualmente visualizzato enabledisp: out std_logic_vector(3 downto 0)); --enable display end scandisplayedk; 82

83 architecture scandisplayedk_arch of scandisplayedk is component Divisore50 is port ( clkin: in STD_LOGIC; -- clock di ingresso, es 50mhz clkout: out STD_LOGIC; -- clock di uscita: -> 1 mhz rstn: in STD_LOGIC-- reset (negativo) ); end component; component seg7 is port ( binary: in STD_LOGIC_VECTOR (3 downto 0); -- valore da 0 a 15 in binario da visualizzare hex: out STD_LOGIC_VECTOR (6 downto 0) ); end component; bus di 7 linee che comanda il display a 7 segmenti -- rispettivamente i segmenti a,b,c,d,e,f,g type stato is (S0,S1,S2,S3,s4,s5,s6,s7); signal s: stato :=S0; --S0 è lo stato iniziale signal next_s: stato; signal clk1mhz: std_logic; signal disp1hex, disp2hex, disp3hex, disp4hex: std_logic_vector( 6 downto 0); signal semprealto: std_logic; --segnale che non attiva mai il reset del divisore50; begin divisoreclock: Divisore50 port map ( clkin => clk, -- collega il clock a 50mhz entrante al divisore di clock clkout => clk1mhz, -- in uscita ho il clock a 1 mhz che controlla tutto il resto rstn => semprealto ); decoder1: seg7 port map ( binary => disp1, hex => disp1hex ); decoder2: seg7 port map ( binary => disp2, hex => disp2hex ); decoder3: seg7 port map

84 ( ); binary =>disp3, hex => disp3hex decoder4: seg7 port map ( binary =>disp4, hex => disp4hex ); PROCESS (clk1mhz, next_s) BEGIN IF clk1mhz='1' AND clk1mhz'event THEN s <= next_s; END IF; END PROCESS; --ogni fronte di salita del clock cambia stato PROCESS (s) BEGIN CASE s IS WHEN S0 => enabledisp<="0111"; valore<=disp1hex; dp<=dp1; next_s<=s1; WHEN S1 => enabledisp<="1111"; valore<=" "; dp<='1'; next_s<=s2; WHEN S2 => enabledisp<="1011"; valore<=disp2hex; dp<=dp2; next_s<=s3; WHEN S3 => enabledisp<="1111"; valore<=" "; dp<='1'; next_s<=s4; WHEN S4 => enabledisp<="1101"; valore<=disp3hex; dp<=dp3; next_s<=s5; WHEN S5 => enabledisp<="1111"; valore<=" "; dp<='1'; 84

85 next_s<=s6; WHEN S6 => enabledisp<="1110"; valore<=disp4hex; dp<=dp4; next_s<=s7; WHEN S7 => enabledisp<="1111"; valore<=" "; dp<='1'; next_s<=s0; END CASE; END PROCESS; semprealto<='1'; end scandisplayedk_arch; Simulazione Il modulo infine è stato simulato mettendo sui 4 ingressi rispettivamente 1100 (C), 0001 (1), 1010 (A), 0000 (0) che come si può vedere dalla figura 81 vengono correttamente convertiti nei corrispettivi bit per accendere/spegnere i segmenti ( per C, per 1, per A e per 0), infine questi valori vengono portati in uscita su valore come dal diagramma degli stati di figura 71. Figura 81. Simulazione del blocco ScanDisplayEDK 85

86 Segue cosa viene effettivamente visualizzato sui display: Figura 82. Visualizzazione dello stato S0 Figura 83. Visualizzazione dello stato S1 Figura 84. Visualizzazione dello stato S2 86

87 Figura 85. Visualizzazione dello stato S3 Figura 86. Visualizzazione dello stato S4 Figura 87. Visualizzazione dello stato S5 87

88 Figura 88. Visualizzazione dello stato S6 Figura 89. Visualizzazione dello stato S7 E stato infine creato un piccolo file di test che usa solamente clk come ingresso e all interno della sezione architecture forza i segnali Disp e DP come descritto nella simulazione. File UCF Segue il contenuto del file con le costrizioni sui pin della FPGA Spartan3: Net clk50mhz LOC=T9;2; Net enabledisp<0> LOC=D14; Net enabledisp<1> LOC=G14; Net enabledisp<2> LOC=F14; Net enabledisp<3> LOC=E13; Net valore<0> LOC=N16; Net valore<1> LOC=F13; Net valore<2> LOC=R16; Net valore<3> LOC=P15; Net valore<4> LOC=N15; Net valore<5> LOC=G13; 88