Upravljanje Mešalicom Za Beton U Vhdl-u

ELEKTRONSKI FAKULTET U NIŠU Katedra za ELEKTRONIKU Predmet: PROJEKTOVANJE VLSI

SEMINARSKI RAD

Profesor: Prof.dr. MilunkaDamnjanović Student: Negovan Stanković Broj indeksa: 9793

1.PROJEKTNI ZADATAK

Projektovati integrisani sistem čija je funkcija upravljanje mešalicom za beton. Mešalici su dostupna tri tipa peska (različite granulacije), cementni prah i voda. Zapreminski odnos komponenata u smeši za beton može se zadati spolja kao celobrojni umnožak zapremine osnovnog kontejnera koji se nalazi na otvoru za točenje sastojaka betona. Kapacitet mešalice je maksimalno 50 jedinica peska i cementa plus odgovarajuća količina vode. Mešalica prvo uzima pesak i cement, pa posle mešanja u trajanju od 1 min, uzme vodu i sve meša još 5 minuta. Posle toga, beton je spreman, ali ako nije pritisnuto dugme za točenje betona, nastavlja sa mešanjem sve dok sedugme ne pritisne. Startovanje mešalice vrši radnik. Čip treba da bude testabilan. Raspored pinova usvojiti proizvoljno. Rad treba da sadrži opis funkcije svakog bloka na VHDL-u, šemu implementacije koja je rezultat opisa, talasne oblike napona koji dokazuju ispravnost implementacije, projekat layout-a, i tekstualna objašnjenja.

PREDMETNI NASTAVNIK, Prof.dr Milunka Damnjanović

2

2.UVOD

U uvodnom delu biće uvedeni osnovni pojmovi i opisane najvažnije aktivnosti koje obuhvata složena delatnost projektovanja elektronskih kola. U procesu projektovanja elektronskih kola se na osnovu opisa željene funkcije kola generiše potpuna dokumentacija za proizvodnju istog. Kolo može da bude opisano u tri domena: ponašanja, strukture i u fizičkom domenu. Kada kažemo ponašanje mislimo na način kako kolo (ili sistem) i njegovi delovi reaguje u odnosu sa njegovom okolinom. Drugim rečima, ponašanjem zovemo preslikavanje ulaza u izlaz. Rezultat projektovanja – projekat, u ovom slučaju, predstavlja funkcionalni opis koji sadrži pomenuto preslikavanje. Kada kažemo struktura mislimo na skup komponenata koje se povezuju i koje čine sistem. Drugim rečima, struktura predstavlja arhitekturu datog sistema kada se iskazuje kao veza svojih elemenata. Za opis strukture često se koristi tzv. netlista. Netlista je, u stvari, spisak veza kojima su pojedinačno pridruženi elementi. Ponekad se koristi i njen komplement: spisak elemenata sa oznakama veza na njihovim priključcima. Najzad, kada kažemo fizički domen, govorimo o opisu načina kako će sistem biti proizveden. Akronim VHDL označava Very Hihg Speed Integrated Ciruits Hardware Description Language. VHDL može da se primenjuje u svim fazama projektovanja: opis, verifikaciju (simulaciju), sintezu i dokumentovanje. Osnovna prednost jeste mogućnost jednostavnog opisa projekta na višim nivoima apstrakcije. Nastao je iz potrebe da se popravi komunikacija među projektantima koji rade na razvoju istog integrisanog kola. Budući da razvoj tehnologije nameće nove zahteve jeziku IEEE komitet za standardizaciju svakih pet godina razmatra primedbe koje stižu od korisnika VHDL-a kako bi se povećala efikasnost jezika. Postoji više načina da se opiše ista funkcija a da automatska sinteza rezultira istovetnim hardverom. Pri tome neki od opisa su kraći a neki duži. Pored toga, zavisno od primenjinih konstrukcija i naredbi, istu funkciju mogu da realizuju različiti hardveri, pri čemu su jedni jednostavniji od drugih. Naravno, postoje i potpuno neželjene kategorije opisa, a to su one koje ne daju željenu funkciju kola. Da bi se one eliminisale, neophodno je simulacijom verifikovati opis pre njegovog prevođenja u hardver. Postoje tri stila opisa projekta u VHDL-u. To su: - Strukturni opis (structural) - Opis toka podataka (data flow) - Opis ponašanja (behavioral) Strukturni opis podrazumeva da nam je struktura arhitekture sistema na nivou logičkih blokova poznata. Opis ponašanja ne razlikuje se mnogo od opisa toka podataka, naročito kada su u pitanju manja kola. Zasniva se na algoritamskom opisu bloka pri čemu se koristi definisanje procesa da bi se opisale sekvencijalne aktivnosti. Slično drugim programskim jezicima i u VHDL-u balansiranje između fleksibilnosti i mogućnosti zahteva određenu disciplinu od strane korisnika time što uvodi striktna pravila. Ona se odnose na način deklarisanja tipova signala i na pravila koja definišu način opisa i mesto pojavljivanja određenih naredbi. Iako ova pravila na prvi pogled mogu da izgledaju zamršeno, njihova prava prednost dolazi do izražaja kod opisa složenih kola.

3

3.ARHITEKTURA SISTEMA I PRINCIP RADA

Slika1. blok dijagram sitema

4

Struktura sistema upravljanja mešalicom za beton je prikazana blok dijagramom na slici1. Princip rada je sledeći:Prvo se vrši upis podataka u RAM iz računara preko RS232 konektora . Kada se računar priključi na RS232 onda signal DCD dobija vrednost logičke nule, dok se preko signala RXD podaci upisuju u RAM na način kako je to odrađeno u bloku upis_u_ram. Podaci koji se upisuju predstavljaju broj kontejnera sastojaka za spremanje betona. Sistem je napravljen tako da se mogu koristiti 8 različitih kombinacija za spremanje betona. Za svaku kombinaciju potrebno je znati broj kontejnera za pesak tipa1, pesak tipa2, pesak tipa3, cementa i vode. Za broj kontejnera za svaki sastojak omogućen je memorijski prostor od 8 bita. Za svaku kombinaciju omogućen je memorijski prostor od od 8 bajta sa tim da pored 5 bajta koji su iskorišteni za smeštanje informacije o sastojcima za spremanje betona postoje i 3 bajta u kojima se ne smešta nikakva informacija. Dakle za 8 kombinacija zauzetost memorije je 64 bajta. Kada je informacija o broju kontejnera sastojaka za spremanje betona uskladištena u memoriji onda se može pristupiti odabiranju određene kombinacije za spremanje. To se vrši pomoću bloka odabir_spremanja pritiskom na željeni taster. Kada je željeni taster pritisnut na izlazu datog bloka signal req se dovodi na logičku jedinicu i magistrala code dobija odgovarajuću vrednost. Ovim počinje proces isčitavanja memorije i postavljanje podataka o broju kontejnera u registre. Code predstavlja tri adresna bita memorije (5:3) dok se ostala 3 adresna bita (2:0) dobijaju kao izlaz iz bloka counter_4_bit. Razlog tome je to da je za isčitavanje memorije potrebno 2 takta i to je urađeno upravo pomoću ovog brojača. Isčitavanje iz memorije je moguće dok brojač izbroji do 9, posle toga se preko 2 multipleksera i d flip flopa signal OE dovodi na logičku nulu čime je čitanje sadržaja memorije onemogućeno. Kada je informacija o broju kontejnera smeštena u 5 registra, respektivno za svaki sastojak, pomoću konačnog automata koji je opisan u bloku fsm1 vrši se kontrola ubacivanja sadržine kontejnera u bubanj mešalice. Konačni automat upravlja tajmerom1, tajmerom2,komparatorom1,komparatorom2,komparatorom3, asinhronim brojačem koji broji kontejnere i asinhronim brojačem koji broji sastojke. Komparator1 daje logičku jedinicu na izlazu kada se ubaci poslednji sadržaj iz kontejnera u mešalicu za bilo koji sastojak.Posle ubacivanja peska u bubanj mešalice komparator2 je na logičkoj jedinici i kada se u bubanj mešalice ubaci poslednji sadržaj iz kontejnera za cement aktivira se signal start_rotate kojim se startuje motor za rotiranje bubnja mešalice a ujedno i startuje tajmer1 koji broji u trajanju od jednog minuta i onda šalje signal za ubacivanje vode u bubanj mešalice. Kada se poslednji sadržaj kontejnera vode sipa u bubanj onda se aktivira tajmer2, koji broji pet minuta i posle toga se aktivira signal ready koji signalizira da je beton spreman. Bubanj se i dalje okreće a istovar mešalice se inicira signalom empty_mixer. Princip funkcionisanja blokova pojedinačno i njihov HDL kod biće prikazan i objašnjen kasnije.

5

Globalni sistem sa svim ulaznim i izlaznim signalima prikazan je na slici2.

Slika2.globalni prikaz upravljačke jedinice mešalice

Upravljačka jedinica ima 9 ulaznih signala i 6 izlaznih signala.

Ulazni signali su sledeći: -

Clk – globalni takt signal za sinhronizaciju procesa upravljačke jedinice;

-

Rst – globalni signal za resetovanje sistema;

-

DCD– signal koji označava da li je priključen sistem na PC preko RS232 konektora;

-

RXD – signal pomoću kog se vrši upis u RAM sistema;

- TASTER– magistrala pomoću koje se vrši odabiranje određene kombinacije za spremanje betona; -

Empty – signal koji označava kada je kontejner prazan;

-

Full – signal koji označava kada je kontejner pun; 6

-

Empty_mixer – signal za pražnjenje mešalice kada je beton spreman;

-

Test – signal za testiranje ispravnosti sistema;

Izlazni signali su sledeći: -

Ispravnost – signal koji je u testabilnom režimu u stanju logičke jedinice kada je sistem ispravan;

-

Neispravnost – signal koji je u testabilnom režimu u stanju logičke nule kada je sistem ispravan;

-

Ready – signal koji signalizira kada je beton spreman;

-

Req_empty – signal kojim se zahteva pražnjenje kontejnera;

-

Req_fill– signal kojim se zahteva punjenje kontejnera;

-

Start_rotate – signal kojim se startuje motor za okretanje bubnja mešalice;

7

4.OPIS U VHDL-u I ULOGA BLOKOVA SISTEMA PONAOSOB

4.1.UPIS_U_RAM

Blok upis_u_ram se sastoji od više pod blokova koji su prikazani na slici3. Njihova uloga je da generišu ulazne signale za upis podataka u memoriju. Princip rada ovog bloka je sledeći: Podaci za upis se dopremaju bit po bit signalom RXD. Blok UART_Receiver prihvata ovu informaciju i na izlazu smešta paralelno prihvaćene bajtove i signalom received označava kada se sledeći bajt pojavio na izlazu SBUF. Blok prijem_za_ram prihvata bajt za upis i ukoliko je signal OE u stanju logičke nule kao i signal DC taj bajt postavlja na izlaznu magistralu Data_upis. U bloku addr_upisa vrši se određivanje adrese memorije za upis podataka na taj način što se pri svakom primljenom batu adresa poveća za jedana signal load_upis je u stanju logičke jedinice čim je signal DCD u stanju logičke nule. Upis u memoriju je moguć samo ukoliko je signal OE na logičkoj nuli odnosno ukoliko nije u toku čitanje sadržaja memorije i ukoliko je signal DCD u stanju logičke nule odnosno ukoliko je računar povezan na RS232 port.

Slika3.upis u ram 4.1.1. UART_Receiver 8

library IEEE; use IEEE.STD_LOGIC_1164.all; use IEEE.STD_LOGIC_UNSIGNED.all; -- clk=4.194304MHz -- signal Rst_n aktivan 0 -- Baud Rate=19200 bita/sec entity T51_UART_Receiver is port( SBUF: out std_logic_vector(7 downto 0); SC_Wr, Rst_n, Clk: in std_logic; Received : out std_logic; RXD: in std_logic ); end T51_UART_Receiver; architecture T51_UART_Receiver of T51_UART_Receiver is signal RX_ShiftReg: std_logic_vector(7 downto 0); signal RX_Filtered : std_logic; signal RX_Bit_Cnt: integer range 0 to 10; signal Baud16R: std_logic; signal BR_Tick_Cnt : std_logic_vector(3 downto 0); signal Bit_Phase: std_logic_vector(3 downto 0); signal Data_in: std_logic_vector(7 downto 0); begin Data_in<=(others=>'0'); -- Baud Rate tick -- signal Baud16R - 16x veci takt nego sto je Baud Rate BR_tick: process (Clk, Rst_n) begin if Rst_n = '0' then BR_Tick_Cnt <= "0000"; Baud16R <= '0'; elsif Clk'event and Clk = '1' then Baud16R <= '0'; if BR_Tick_Cnt = "1100" then --brojac osnove 13 Baud16R <= '1'; BR_Tick_Cnt <= "0000"; else BR_Tick_Cnt <= BR_Tick_Cnt + 1; end if; end if; end process BR_tick; -- Ulazni filter 9

process (Clk, Rst_n) variable Samples : std_logic_vector(1 downto 0); begin if Rst_n = '0' then Samples := "11"; RX_Filtered <= '1'; elsif Clk'event and Clk = '1' then if Baud16R = '1' then Samples(1) := Samples(0); Samples(0) := RXD; end if; if Samples = "00" then RX_Filtered <= '0'; end if; if Samples = "11" then RX_Filtered <= '1'; end if; end if; end process; process (Clk, Rst_n) begin if Rst_n = '0' then Received <= '0'; SBUF <= "00000000"; -- primljeni 1B podatak Bit_Phase <= "0000"; -- brojac trenutne faze u okviru 1 bita RX_ShiftReg(7 downto 0) <= "00000000"; -- pomeracki registar RX_Bit_Cnt <= 0; -- brojac primljnih bitova elsif Clk'event and Clk = '1' then if SC_Wr = '1' then Received <= Data_In(0); end if; if Baud16R= '1'then if RX_Bit_Cnt = 0 and (RX_Filtered = '1' or Bit_Phase = "0111") then Bit_Phase <= "0000"; else Bit_Phase <= Bit_Phase + 1; -- detekcija prvog start -- treba da se izbroji tacno 7 Bit_Phase ciklusa end if; if RX_Bit_Cnt = 0 then if Bit_Phase = "0111" then -- prelazak na 0-ti bit RX_Bit_Cnt <= RX_Bit_Cnt + 1; end if; 10

elsif Bit_Phase = "1111" then RX_Bit_Cnt <= RX_Bit_Cnt + 1; if (RX_Bit_Cnt = 9) then -- Stop bit RX_Bit_Cnt <= 0; Received <= '1'; SBUF <= RX_ShiftReg(7 downto 0); else RX_ShiftReg(7 downto 0) <= RX_Filtered & RX_ShiftReg(7 downto 1); end if; end if; end if; end if; end process; end T51_UART_Receiver;

11

4.1.2. Prijem_za_ram

-- Description : The RS-232 standard defines some 18 different signals for serial communications --DCD je Data Carrier Detect kao osmi pin --The DCD signal is received from the computer or device on the other end of your serial cable. --A space voltage on this signal line indicates that the computer or device is currently connected or on line ---------------------------------------------------------------------------------------------------

--{entity {prijem_za_ram} architecture {prijem_za_ram}} library IEEE; use IEEE.STD_LOGIC_1164.all; use IEEE.STD_LOGIC_UNSIGNED.all; entity prijem_za_ram is port( DCD: in STD_LOGIC; OE : in STD_LOGIC; bajt_ulaz : in STD_LOGIC_VECTOR(7 downto 0); received: in STD_LOGIC; load_upis: out STD_LOGIC; bajt_izlaz: out STD_LOGIC_VECTOR(7 downto 0) ); end prijem_za_ram;

architecture prijem_za_ram of prijem_za_ram is signal temp : STD_LOGIC_VECTOR(7 downto 0); begin

P2: PROCESS(received) IS BEGIN

IF RISING_EDGE(received) THEN temp<=bajt_ulaz; end if; end process P2 ; 12

bajt_izlaz<=temp when (DCD = '0' and OE ='0') else (others=>'Z'); load_upis<='1' when (DCD = '0' and OE ='0') else '0'; end prijem_za_ram; 4.1.3. addr_upisa

library IEEE; use IEEE.STD_LOGIC_1164.all; use IEEE.NUMERIC_STD.all; entity addr_upisa is port( increment : in STD_LOGIC; DCD: in STD_LOGIC; rst : in STD_LOGIC; address_upis : out STD_LOGIC_VECTOR(7 downto 0) ); end addr_upisa;

architecture addr_upisa of addr_upisa is begin process (DCD,increment,rst) is variable k: unsigned(7 downto 0); begin if rst = '1' or DCD='1' then address_upis<="00000000"; k:="00000000"; elsif RISING_EDGE(increment) then k:= k+1; end if; if (k=1 or k<1) then address_upis<="00000000"; else address_upis<= std_logic_vector(k-1); end if; end process;

end addr_upisa; 13

4.2. ODABIR SPREMANJA

Blok odabir_spremanja služi da korisnik zada sistemu koji način spremanja betona želi, odnosno zadaje određenu kombinaciju broja kontejnera za svaki sastojak. Ukupno ima 8 kombinacija i korisnik pritiskom na odgovarajući taster zadaje željenu kombinaciju. library IEEE; Use IEEE.STD_LOGIC_1164.all; entity odabir_spremanja is port( CLK : in STD_LOGIC; enable : in STD_LOGIC; taster : IN STD_LOGIC_VECTOR(7 DOWNTO 0 ); req : out STD_LOGIC; code : out STD_LOGIC_VECTOR(2 downto 0) ); end odabir_spremanja; architecture odabir_spremanja of odabir_spremanja is begin with taster select code<="111"when "10000000", "110" when "01000000", "101" when "00100000", "100" when "00010000", "011" when "00001000", "010" when "00000100", "001" when "00000010", "000" when "00000001", "000" when others; PROCESS(CLK) IS BEGIN IF RISING_EDGE(CLK)THEN IF ((taster(0)='1' or taster(1)='1' or taster(2)='1' or taster(3)='1' or taster(4)='1' or taster(5)='1' or taster(6)='1' or taster(7)='1')or enable='1' )THEN REQ<='1' ; ELSE REQ<='0'; END IF; END IF; END PROCESS; end odabir_spremanja; Signalom enable se onemogućava pokretanje novog procesa sve dok prethodni nije završen. 14

4.3 reg_code U ovom bloku se vrši smeštanje koda za odgovarajuću kombinaciju spremanja i generiše se signal enable čija je uloga prethodno objašnjena. library IEEE; use IEEE.STD_LOGIC_1164.all; entity reg_code is port ( req : in std_logic; rset: in std_logic; code : in std_logic_vector (2 downto 0); data : out std_logic_vector (2 downto 0); enable: out std_logic ); end entity;

architecture reg_code_arch of reg_code is signal TEMP_Q: std_logic_vector (2 downto 0); begin process (req,rset,code)is begin if rset = '1' then TEMP_Q <= (others => '0'); enable<='0'; elsif rising_edge(req) then TEMP_Q <= code; enable<='1'; end if; end process; data <= TEMP_Q; end reg_code_arch; Signal data predstavlja prva 3 adresna bita za čitanje memorije.

15

4.4. read_address

Sve dok je signal oper u stanju logičke jedinice na izlaznoj magistrali imamo 8 adresna bita za čitanje memorije koji se dobijaju kao spoj "00"&ul_1&ul_2. U slučaju kada je oper u stanju logičke nule izlaz je "00000000".Kod u HDL-u je sledeći:

library IEEE; use IEEE.STD_LOGIC_1164.all; entity read_address is port( enable : in STD_LOGIC; ul_1 : in STD_LOGIC_VECTOR(2 downto 0); ul_2 : in STD_LOGIC_VECTOR(2 downto 0); addr_read : out STD_LOGIC_VECTOR(7 downto 0) ); end read_address;

architecture read_address of read_address is begin p1: process (enable,ul_1,ul_2) is begin if enable='1' then addr_read<= "00"&ul_1&ul_2; else addr_read<="00000000"; end if; end process p1; end read_address; 4.5. or2b

U bloku or2b se vrši logička operacija ILI između 2 bajta. Prvi bajt je adresni bajt za čitanje memorije a drugi adresni bajt za upis podataka u memoriju.

library IEEE; use IEEE.STD_LOGIC_1164.all; use IEEE.STD_LOGIC_UNSIGNED.all;

16

entity or2B is port( ul1 : in STD_LOGIC_VECTOR(7 downto 0); ul2 : in STD_LOGIC_VECTOR(7downto 0); or_exit : out STD_LOGIC_VECTOR(7 downto 0) ); end or2B; --}} End of automatically maintained section architecture or2B of or2B is begin or_exit(0)<=ul1(0) or ul2(0); or_exit(1)<=ul1(1) or ul2(1); or_exit(2)<=ul1(2) or ul2(2); or_exit(3)<=ul1(3) or ul2(3); or_exit(4)<=ul1(4) or ul2(4); or_exit(5)<=ul1(5) or ul2(5); or_exit(6)<=ul1(6) or ul2(6); or_exit(7)<=ul1(7) or ul2(7);

end or2B;

17

4.6. mux1 Ovaj blok je multiplekser čiji je kod: library IEEE; use IEEE.STD_LOGIC_1164.all; entity mux1 is port( muxin1 : in STD_LOGIC; muxin2 : in STD_LOGIC; e : in STD_LOGIC; muxout : out STD_LOGIC ); end mux1;

architecture mux1 of mux1 is begin p1: process ( e,muxin1,muxin2 ) begin case e is when '1' => muxout<=muxin1; when '0' => muxout<=muxin2; when others => muxout<='X'; end case; end process p1; end mux1;

18

4.7. df_flop Ovaj blok je d flip flop čili je kod: library IEEE; use IEEE.STD_LOGIC_1164.all; entity df_flop is port( rst: in STD_LOGIC; d : in STD_LOGIC; clk : in STD_LOGIC; oper : out STD_LOGIC ); end df_flop;

architecture df_flop of df_flop is begin process(rst,clk) is begin if rst='1' then oper<='0'; elsif (clk='1' and clk'event)then oper<=d; end if; end process ;

end df_flop;

Dva multipleksera i D flip flop povezani kao na slici 4 omogučavaju da signal oper bude u stanju logičke jedinice sve dok ne stigne signal T_c sa brojača counter_4_bit. Dok je signal oper u stanju logičke jedinice moguće je čitati sadržaj memorijem u suprotnom nije.

Slika4 19

4.8.counter_4_bit

Counter_4_bit četvorobitni brojač koji na izlazu ima signal brojanja i signal koji signalizira kada brojač izbroji do deset.

Kod u HDL-u je sledeći:

library IEEE; use IEEE.std_logic_1164.all; use IEEE.STD_LOGIC_UNSIGNED.all; entity counter_4_bit is port ( CLK : in std_logic; req : in std_logic; T_c : out std_logic; Q : out std_logic_vector(3 downto 0) ); end entity; architecture counter_arch of counter_4_bit is signal TEMP_Q : std_logic_vector(3 downto 0):="0000"; begin process(CLK,req) begin if req='0' THEN temp_Q <= "0000"; elsif rising_edge(CLK) then TEMP_Q <= TEMP_Q + 1 ; end if; end process; T_c<='1' when TEMP_Q ="1010" else '0' ; Q <= std_logic_vector(TEMP_Q) ; end counter_arch;

20

4.9.verzija_256_bajta Ovaj blok predstavlja memoriju koja je napravljena pomoću memorijskog modula RAM256x9SSR iz biblioteke a500k.

library IEEE; use IEEE.STD_LOGIC_1164.all; --KADA SE RADI SINTEZA ISKLJUCITI KOMENTARE ZA BIBLIOTEKU A500K --library a500k; --use a500k.components.all; --USE IEEE.VITAL_timing.all; --USE IEEE.VITAL_primitives.all; entity verzija_256B is port( data: inout std_logic_vector(7 downto 0); address: in std_logic_vector (7 downto 0); r_nw,load,oe,clk: in std_logic); end verzija_256B; --}} End of automatically maintained section architecture verzija_256B of verzija_256B is component RAM256x9SSR --generic( -- MEMORYFILE : string := "" --); port ( DI0: in STD_LOGIC; DI1: in STD_LOGIC; DI2 : in STD_LOGIC; DI3 : in STD_LOGIC; DI4 : in STD_LOGIC; DI5 : in STD_LOGIC; DI6 : in STD_LOGIC; DI7 : in STD_LOGIC; DI8 : in STD_LOGIC; DIS : in STD_LOGIC; PARODD : in STD_LOGIC; RADDR0 : in STD_LOGIC; RADDR1 : in STD_LOGIC; RADDR2 : in STD_LOGIC; RADDR3 : in STD_LOGIC; RADDR4 : in STD_LOGIC; RADDR5 : in STD_LOGIC; RADDR6 : in STD_LOGIC; 21

RADDR7 : in STD_LOGIC; RBLKB : in STD_LOGIC; RCLKS : in STD_LOGIC; RDB : in STD_LOGIC; WADDR0 : in STD_LOGIC; WADDR1 : in STD_LOGIC; WADDR2 : in STD_LOGIC; WADDR3 : in STD_LOGIC; WADDR4 : in STD_LOGIC; WADDR5 : in STD_LOGIC; WADDR6 : in STD_LOGIC; WADDR7 : in STD_LOGIC; WBLKB : in STD_LOGIC; WCLKS : in STD_LOGIC; WRB : in STD_LOGIC; DO0 : out STD_LOGIC; DO1 : out STD_LOGIC; DO2 : out STD_LOGIC; DO3: out STD_LOGIC; DO4 : out STD_LOGIC; DO5 : out STD_LOGIC; DO6 : out STD_LOGIC; DO7 : out STD_LOGIC; DO8 : out STD_LOGIC; DOS : out STD_LOGIC; RPE : out STD_LOGIC; WPE : out STD_LOGIC ); end component; signal data1: std_logic_vector(7 downto 0); signal r_clk,w_clk,w_nr:std_logic; begin r_clk<=(load nand r_nw) nor clk; w_clk<= ((not r_nw) nand load)nor clk; w_nr<=not r_nw; data<=data1 when oe='1' else (others=>'Z'); U1_LSB : RAM256x9SSR --generic map( --MEMORYFILE => "LSB.txt" --) port map( DI0 => data(0), DI1 => data(1), DI2 => data(2), 22

DI3 => data(3), DI4 => data(4), DI5 => data(5), DI6 => data(6), DI7 => data(7), DI8 => '0', DIS => '1', PARODD =>'0', RADDR0 => address(0), RADDR1 => address(1), RADDR2=> address(2), RADDR3 => address(3), RADDR4 => address(4), RADDR5 => address(5), RADDR6 => address(6), RADDR7 => address(7), RBLKB => w_nr, RCLKS => r_clk, RDB => w_nr, WADDR0 => address(0), WADDR1 => address(1), WADDR2 => address(2), WADDR3 => address(3), WADDR4 => address(4), WADDR5 => address(5), WADDR6 => address(6), WADDR7 => address(7), WBLKB=> r_nw, WCLKS => w_clk, WRB => r_nw, DO0 => data1(0), DO1 => data1(1), DO2 => data1(2), DO3 => data1(3), DO4 => data1(4), DO5 => data1(5), DO6 => data1(6), DO7 => data1(7) );

end verzija_256B;

23

4.10. reg1b Registar u kome se smešta informacija o broju kontejnera za odgovarajući material. Imamo 5 ovakvih registara, za svaki materijal po jedan.

library IEEE; use IEEE.STD_LOGIC_1164.all; entity reg1B is port( CLK :in STD_LOGIC; EN : in STD_LOGIC; RST : in STD_LOGIC; B_IN : in STD_LOGIC_VECTOR(7 downto 0); B_OUT : out STD_LOGIC_VECTOR(7 downto 0) ); end reg1B;

architecture reg1B of reg1B is signal temp : STD_LOGIC; begin process (en,rst,clk) is begin if rst='1'then B_out<="00000000"; elsif falling_edge(clk) then if en='1' then B_out<=B_in; end if; end if; end process; end reg1B;

24

4.11. dmux1 Ovaj blok predstavlja demultiplekser koji služi da da dozvolu za upis broja potrebnih kontejnera u odgovarajući registar.

library IEEE; use IEEE.STD_LOGIC_1164.all; use IEEE.STD_LOGIC_UNSIGNED.all; entity dmux1 is port ( EN : in std_logic; WR : out std_logic_vector(4 downto 0); S : in std_logic_vector(2 downto 0); jedan: in std_logic ); end entity; architecture dmux1_arch of dmux1 is constant nula : std_logic_vector (4 downto 0):="00000"; begin process (en,s,jedan) is begin WR<=nula; if en='1' then if S>4 then WR<=nula; else WR(CONV_INTEGER(S))<=jedan; end if; else WR<=nula; end if; end process; end dmux1_arch;

25

4.12.upis_reg

library IEEE; use IEEE.STD_LOGIC_1164.all; entity upis_reg is port( oer : in STD_LOGIC; prvo : in STD_LOGIC_VECTOR(4 downto 0); drugo : in STD_LOGIC_VECTOR(4 downto 0); izlaz : out STD_LOGIC_VECTOR(4 downto 0) ); end upis_reg;

architecture upis_reg of upis_reg is begin p1: process (oer,prvo,drugo ) begin case oer is when '1' => izlaz<=prvo; when '0' => izlaz<=drugo; when others => izlaz<="XXXXX"; end case; end process p1;

end upis_reg;

26

4.13.mux_mat Ovaj blok je multiplekser koji dovodi informaciju o broju kontejnera u komparator1. U zavisnosti od S ulaza određena informacija se dovodi do komparatora1. HDL kod je sledeći:

library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_unsigned.all; entity mux_mat is port ( I0 : in std_logic_vector(7 downto 0); I1 : in std_logic_vector(7 downto 0); I2 : in std_logic_vector(7 downto 0); I3 : in std_logic_vector(7 downto 0); I4 : in std_logic_vector(7 downto 0); S : in std_logic_vector(2 downto 0); O : out std_logic_vector(7 downto 0) ); end entity;

architecture mux_arch of mux_mat is constant NON_ACTIVE : std_logic_vector(7 downto 0) := (others => '0'); begin process (S, I0, I1, I2, I3, I4) begin case CONV_INTEGER(S) is when 0 => O <= I0; when 1 => O <= I1; when 2 => O <= I2; when 3 => O <= I3; when 4 => O <= I4; when others => O <= NON_ACTIVE; end case; end process; end architecture;

27

4.14. counter_8_bit

Asinhroni brojač koji broji kontejnere, inkrementira i resetuje se od strane konačnog automata a izlaz se vodi na komparator1.

library IEEE; use IEEE.STD_LOGIC_1164.all; use ieee.std_logic_unsigned.all; entity counter_8bit is port( clk : in STD_LOGIC; inc_counter : in STD_LOGIC; res_counter : in STD_LOGIC; counter_out : out STD_LOGIC_VECTOR(7 downto 0) ); end counter_8bit;

architecture counter_8bit of counter_8bit is signal m: std_logic_vector(7 downto 0); begin process (inc_counter,clk,res_counter) is begin if res_counter='1' then m<="00000000"; elsif RISING_EDGE(clk) then if inc_counter='1' then m<=m+1; end if; end if; end process; counter_out<=std_logic_vector(m); end counter_8bit;

28

4.15. counter_material

Asinhroni brojač koji se inkrementira i resetuje od strane konačnog automata a izlaz se vodi na mux_mat.

library IEEE; use IEEE.STD_LOGIC_1164.all; use IEEE.STD_LOGIC_UNSIGNED.all; entity counter_material is port( clk: in STD_LOGIC; res_mat : in STD_LOGIC; inc_mat : in STD_LOGIC; sel : out STD_LOGIC_VECTOR(2 downto 0) ); end counter_material;

architecture counter_material of counter_material is signal k: std_logic_vector (2 downto 0); begin process (inc_mat,res_mat,clk) is begin if res_mat='1' then k<="000"; elsif rising_edge(clk)then if inc_mat='1' then k<=k+1; end if; end if; end process; sel<=std_logic_vector(k); end counter_material;

29

4.16.komparator1

Komparator1 upoređuje potreban broj kontejnera sa dostignutim brojem kontejnera.

library IEEE; use IEEE.STD_LOGIC_1164.all; use ieee.std_logic_unsigned.all; entity komparator1 is port( datain1 : in STD_LOGIC_VECTOR(7 downto 0); datain2 : in STD_LOGIC_VECTOR(7 downto 0); comp_out : out STD_LOGIC ); end komparator1;

architecture komparator1 of komparator1 is begin process ( datain1,datain2 ) begin if datain1 - datain2 =0 then comp_out<='1'; else comp_out<='0'; end if; end process;

30

4.17.komparator2

Komparator2 upoređuje da li se krenulo sa ubacivanjem cementa,da bi se posle toga uključio tajmer_1min i startovao motor za obrtanje bubnja mešalice.

library IEEE; use IEEE.STD_LOGIC_1164.all; use ieee.std_logic_unsigned.all; entity komparator2 is port( in1 : in STD_LOGIC_VECTOR(2 downto 0); comp2_out : out STD_LOGIC ); end komparator2;

architecture komparator2 of komparator2 is signal in2 : STD_LOGIC_VECTOR(2 downto 0):="011"; begin process(in1) begin if in1="011" then comp2_out<='1'; else comp2_out<='0'; end if; end process ;

end komparator2;

31

4.18.komparator3

Komparator3 upoređuje da li se krenulo sa ubacivanjem vode,da bi se posle toga uključio tajmer_5min.

library IEEE; use IEEE.STD_LOGIC_1164.all; use ieee.std_logic_unsigned.all; entity komparator3 is port( in1 : in STD_LOGIC_VECTOR(2 downto 0); comp3_out : out STD_LOGIC ); end komparator3;

architecture komparator3 of komparator3 is begin process(in1) begin if in1="100" then comp3_out<='1'; else comp3_out<='0'; end if; end process ; end komparator3;

32

4.19.tajmer_1min

Tajmer_1min je brojač koji uz globalni takt clk=4.194304MHz teba da broji do 251658240 odnosno do "1111000000000000000000000000" da bi vreme trajanja tog brojanja bilo jedan minut.

library IEEE; use IEEE.STD_LOGIC_1164.all; use ieee.std_logic_unsigned.all; entity timer_1min is port( clk : in STD_LOGIC; start_timer1 : in STD_LOGIC; time1_finished : out STD_LOGIC; reset_timer : in STD_LOGIC ); end timer_1min;

architecture timer_1min of timer_1min is signal stanje: std_logic_vector(27 downto 0); begin proc:process(clk, reset_timer) begin if reset_timer = '1' then stanje <= "0000000000000000000000000000"; elsif rising_edge(clk) then if (start_timer1 = '1') then stanje <= stanje + 1; end if; end if; end process; --time1_finished<='1' when stanje="1111000000000000000000000000" else '0'; time1_finished<='1' when stanje="0000000000000000000000011111" else '0'; end timer_1min; 33

4.20.tajmer_5min

Tajmer_1min je brojač koji uz globalni takt clk=4.194304MHz teba da broji do 1258291200 odnosno do "1001011000000000000000000000000"da bi vreme trajanja tog brojanja bilo jedan minut.

library IEEE; use IEEE.STD_LOGIC_1164.all; use ieee.std_logic_unsigned.all; entity timer_5min is port( clk : in STD_LOGIC; start_timer2 : in STD_LOGIC; time2_finished : out STD_LOGIC; reset_timer : in STD_LOGIC ); end timer_5min; architecture timer_5min of timer_5min is signal stanje:STD_LOGIC_VECTOR(30 downto 0); begin proc:process(clk, reset_timer) begin if reset_timer = '1' then stanje <= "0000000000000000000000000000000"; elsif rising_edge(clk) then if start_timer2='1' then stanje <= stanje + 1; end if; end if; end process; --time2_finished <= '1' when stanje = "1001011000000000000000000000000" else '0'; time2_finished <= '1' when stanje = "0000000000000000000000000111111" else '0'; end timer_5min;

34

4.21.fsm1

Blok fsm1 je FSM (Finite State Machine) (automat sa konačnim brojem stanja) koji nakon prve faze unošenja podataka u registre upravlja celokupnim sistemom. Njegove ulazne i izlazne signale možemo uočiti na slici desno. Ovaj blok opisan je sa dva procesa. U prvom procesu definisano je da se sve aktivnosti i svi prelazi iz jednog stanja u drugo stanje dešavaju sinhrono, na prednju ivicu taktnog signala. Prvim procesom se takođe definiše da nakon delovanja rst signala sistem prelazi u početno stanje. U drugom procesu se za svako stanje definišu aktivnosti koje će se u tom stanju preduzeti, kao i naredno stanje u koje će sistem da pređe po ispunjenju odgovarajućih uslova. Na početku rada, nakon reseta, svi izlazni signali iz bloka fsm1 postavljeni su na nulu. U zavisnosti od stanja u kome se sistem nalazi fsm1 postavlja određene izlazne signale na logičku jedinicu.

Njegov kod u HDL-u je:

library ieee; use ieee.std_logic_1164.all; entity FSM1 is port ( ena,comp_out,comp2_out,comp3_out,full,empty,time1_finished,time2_finished,empty_mixer, clk,res: in std_logic; req_fill,req_empty,inc_counter,inc_mat,res_mat,res_counter,start_timer1,start_timer2,ready,reset_t imer1, reset_timer2 : out std_logic ); end entity; architecture fsm of FSM1 is type state is (s,s0,s1,s2,sp2,s3,s4,s5,s6,s7,s8,s9,s10,s11,s12); signal pstate,nstate: state; 35

begin p1: process (clk,res) is begin if (res ='1') then pstate <= s; elsif (clk ='1' and clk'event)then pstate <= nstate; end if; end process p1; p2: process(ena,comp_out,comp2_out,comp3_out,full,empty,time1_finished,time2_finished,empty_mi xer, pstate)is ------ inicijalizacija izlaznih promenljivih begin req_fill<='0'; req_empty<='0'; inc_counter<='0'; inc_mat<='0'; res_mat<='0'; res_counter<='0'; start_timer1<='0'; start_timer2<='0'; ready<='0'; reset_timer1<='0'; reset_timer2<='0'; nstate<=s ; case pstate is when s=> if ena='0' then nstate<=s; else nstate<=s0; end if; when s0=> nstate<=s1;

when s1=> res_counter<='1'; res_mat<='1'; nstate<=sp2;

when sp2=> 36

nstate<=s2;

when s2=> if comp_out='0' then nstate<=s3; else nstate<=s6; end if; when s3=> req_fill<='1'; if full='1' then nstate<=s4; else nstate<=s3; end if; when s4=> req_empty<='1'; if empty='1' then nstate<=s5; else nstate<=s4; end if; when s5=> inc_counter<='1'; nstate<=s2; when s6=> res_counter<='1'; if comp2_out='1' then nstate<=s7; else nstate<=s9; end if; when s7=> start_timer1<='1'; if time1_finished='1' then nstate<=s8; else nstate<=s7; end if;

when s8=> inc_mat<='1'; reset_timer1<='1'; nstate<=s2; when s9=> if comp3_out='1' then nstate<=s10; 37

else nstate<=s12; end if; when s10=> start_timer2<='1'; if time2_finished='1' then nstate<=s11; else nstate<=s10; end if; when s11=> ready<='1'; reset_timer2<='1'; if empty_mixer='1' then nstate<=s; else nstate<=s11; end if; when s12=> inc_mat<='1'; nstate<=s2; when others => null; end case; end process p2; end;

38

Ovaj kod možemo prikazati kao dijagram stanja kroz koja prolazi fsm1 u toku rada.Dijagram je prikazan na slici5.

Slika5.Dijagram stanja 39

Nakon resetovanja sistema ili pražnjenja mešalice sistem dolazi u stanje s.On ostaje u tom stanju sbe dok se ne pokrene neki program za pripremanje betona što se inicira signalom ena. Kada je startovan prograza pripremanje betona sistem prelazi na stanje s0 gde se ništa ne dešava pa na sledeću ivicu taktnog signala prelazi na stanje s1. U stanju s1 resetuje se brojač kontejnera i brojač materijala. Zatim se prelazi na stanje sp2 bez iniciranja vrednosti a zatim na stanje s2 gde se postavlja uslov da li je izlaz iz komparatora1 prešao na vrednost logičke jedinice odnosno da li se napunio poslednji kontejner za odredjeni materijal. Ukoliko jeste onda sistem prelazi na stanje s6 ukoliko nije prelazi na stanje s3. U stanju s3 šalje se zahtev za punjenje kontejnera i dok se kontejner ne napuni ostaje se u ovom stanju. Kad se kontejner napuni prelazi se na stanje s4 gde se šalje zahtev za njegovo pražnjenje. Kad se isprazni prelazi se na stanje s5 inače se ostaje u istom stanju. U stanju s5 brojač kontejnera se povećava za jedan. Zatim se ponovo vraćamo na stanje s3 gde se ispituje da li je izlaz komparatora1 prešao na jedinicu, ukoliko jeste prelazimo na stanje s6 gde se resetuje brojač kontejnera i ispituje se da li je izlaz komparatora2 u stanju logičke jedinice. Izlaz komparatora2 je u stanju logičke jedinice kada se počne sa punjenjem cementa. Ali kada sistem dodje do ovog stanja i bude ispoštovan uslov(if comp2_out='1') znači da su i pesak i cement u bubnju mešalice pa prelazimo na stanje s7 gde iniciramo signal za pokretanje tajmera1 koji broji do jednog minuta i taj signal koristimo kao start signal za uključenje motora koti pokreće rotacioni sistem bubnja mešalice. Motor se uključuje na prednju ivicu ovog signala a gasi se po završetku pražnjenja mešalice, ručno ili dejstvom nekog senzora koji nije predviđen za ovo integrisano kolo. Iz stanja s7 se prelazi u stanje s8 gde se resetuje tajmer1, brojač materijala se povećava za jedan i prelazi u stanje s2. Ukoliko je izlaz komparatora2 i dalje u stanju logičke nule prelazimo na stanje s9 gde ispitujemo izlaz komparatora3 odnosno da li je sistem napunio poslednji materijal u bubanj mešalice. Izlaz komparatora3 je u stanju logičke jedinice kada se počne sa punjenjem poslednjeg sastojka odnosno vode. Ali kada dodje do ovog stanja ukoliko je uslov (if comp3_out='1') tačan onda su svi sastojci u bubnju. Onda se prelazi na stanje s10 u kome se startuje tajmer2 koji broji u trajanju od 5 minuta i dok ne završi brojanje sistem ostaje u ovom stanju. Kada se brojanje završi prelazi se na stanje s11 gde se resetuje tajmer2 i signal ready postavlja u stanje logičke jedinice i označava da je beton spreman. Sistem ostaje u ovom stanju sve dok se ne počne sa istovarom mešalice. Tada sistem prelazi u početno stanje. Ukoliko uslov u stanju s9 nije ispoštovan prelazi se na stanje s12 gde se brojač materijala povećava za jedan i sistem se dovodi do stanja s2.

40

4.22.fsm_test

U okviru projektovanja i proizvodnje elektronskih kola testiranje zauzima jedno od najznačajnijih mesta. Zadatak testiranja je da ustanovi da li je projekat, proces, tehnologija, komponenta ili sistem ispravan. Blok fsm_test predstavlja automat sa konačnim brojem stanja, koji ima ulogu da ispita ispravnost odnosno da omogući testiranje pet registra u kojima se smešta broj kontejnera sastojaka potrebnih za spremanje betona (pesak1, pesak2, pesak3, cement, voda) respektivno.

Kod u HDL-u je:

library ieee; use ieee.std_logic_1164.all; entity fsm_test is port ( test,req,clk,res,DCD: in std_logic; data1_in,data2_in,data3_in,data4_in,data5_in : in std_logic_vector (7 downto 0); test_bajt : out std_logic_vector (7 downto 0); upis_omoguci: out std_logic_vector (4 downto 0); ispravnost, neispravnost: out std_logic ); end entity; architecture fsm_test of fsm_test is type state is (st0,st1,str1,st2,st4,st5,st6,st7,st8,ispravno,neispravno); signal pstate,nstate: state; constant bajt : std_logic_vector (7 downto 0):= "01101010"; constant svejedan : std_logic_vector (4 downto 0):= "11111"; begin p1: process (clk,res) is begin if (res ='1') then pstate <= st0; elsif (clk ='1' and clk'event)then pstate <= nstate; end if; end process p1; p2: process(req,test,data1_in,data2_in,data3_in,data4_in,data5_in, pstate, dcd)is ------ inicijalizacija izlaznih promenljivih 41

begin test_bajt<=(others=>'Z'); upis_omoguci<=(others=>'Z'); ispravnost<='0'; neispravnost<='0'; nstate<=st0; case pstate is when st0=> if test='0' then nstate<=st0; else nstate<=st1; end if; when st1=> if req='1' then nstate<=st0; else nstate<=str1; end if; when str1 => if DCD='0' then nstate<=st0; else nstate<=st2; end if; when st2=> test_bajt<= bajt; upis_omoguci<=svejedan; nstate<=st4;

when st4=> test_bajt<= bajt; upis_omoguci<=svejedan; if data1_in=bajt then nstate<=st5; else nstate<=neispravno; end if; when st5=> test_bajt<= bajt; upis_omoguci<=svejedan; if data2_in=bajt then 42

nstate<=st6; else nstate<=neispravno; end if; when st6=> test_bajt<=bajt; upis_omoguci<=svejedan; if data3_in=bajt then nstate<=st7; else nstate<=neispravno; end if; when st7=> test_bajt<= bajt; upis_omoguci<=svejedan; if data4_in=bajt then nstate<=st8; else nstate<=neispravno; end if; when st8=> test_bajt<= bajt; upis_omoguci<=svejedan; if data5_in=bajt then nstate<=ispravno; else nstate<=neispravno; end if; when ispravno=> ispravnost<='1'; if req='1' then nstate<=st0; else nstate<=ispravno; end if; when neispravno=> neispravnost<='1'; if req='1' then nstate<=st0; else nstate<=neispravno; end if; when others => null; end case; end process p2; end;

43

Dijagram stanja bloka fsm_test prikazan je na slici6.

slika6. Dijagram stanja bloka fsm_test 44

Ovim automatom omogućeno je upisivanje konstantne vrednosti "01101010" u svaki registar i ispitivanje da li se ista vrednost našla i na izlazu registra. Ukoliko jeste onda se sistem vodi na stanje ispravno gde se istoimeni signal postavlja na vrednost logičke jedinice. Ukoliko izlazni signal iz registra, bilo kog od ukupno pet koje testiramo, nije isti kao ulazni ili ga nema onda se sistem vodi na stanje neispravno gde se istoimeni signal postavlja na vrednost logičke jedinice. Da bi testiranje bilo moguće potrebno je da se u sistemu ne vrši upis podataka u memoriju i da nije proces spremanja betona u toku. To je omogućeno uslovima u stanjima st1 i str1. A uslovi su da signal req mora da bude u stanju logičke nule dok signal DCD mora da bude u stanju logičke jedinice. Prvi uslov pokazuje da mešalica nije u procesu spremanja betona a drugi uslov pokazuje da računar nije povezan na RS232 port i da nije u toku upis podataka u memoriju.

45

5. Test Bench i talasni oblici Tokom opisivanja projekta neophodno je voditi računa i o načinu verifikacije ispravnog funkcionisanja. Najbolji način da se uverimo da li kolo obavlja željenu funkciju jeste simulacija.VHDL, kao univerzalni jezik za opis projekta, podržava, osim sinteze i verifikaciju. Uobičajeni način provere ispravnosti elektronskog kola jeste posmatranje odziva za datu pobudu na probnoj ploči. Simuliranje ove aktivnosti omogućava par entitet-arhitektura koji se naziva testbench. Test bench (TB) mora da sadrži tri celine: - komponentu koja se ispituje (UUT, Unit Under Test) - pobudu (generatori test sekvence) - monitor (''instrument'' na kome se prati odziv). S obzirom da su i pobuda i odziv sastavni deo TB, mora da se napomene da se radi o jedinstvenom entitetu koji ne komunicira sa okolnim svetom preko portova. Prema tome, saglasno definiciji entiteta, opis TB entiteta ne zahteva definisanje ni portova ni generika. S druge strane, UUT je posebna celina koja je predhodno već opisana entitetom i arhitekturom i kao takva se stavlja na probnu ploču. Sa pobudnim signalima i monitorom ona je vezana preko sopstvenih portova. Zato se arhitektura TB opisuje na strukturnom nivou. S obzirom da se podrazumeva da je UUT već opisana kao par entitet-arhitektura, potrebno je da se ona unese kao komponenta u arhitekturu test bench-a. Zato se u opisu TB mora naći i blok u kome se deklariše komponenta za entitet koji se testira. Pored deklarisanja komponenti javlja se potreba za deklarisanjem internih signala i konstanti. Naravno, blok u kome se obavljaju ove aktivnosti prethodi opisu arhitekture i nalazi se ispred ključne reči begin. Unošenje opisa jedne komponente u neki entitet predstavlja, zapravo, instanciranje. Pored unošenja opisa komponente koja se testira neohodno je definisati sam proces testiranja. On se sastoji od zadavanja pobude i tumačenja odziva i može biti podeljen u više procesa ili čak komponenti. Test bench kod za upravljačku jedinicu mešalice za prikazan je u nastavku. library ieee; use ieee.std_logic_1164.all; -- Add your library and packages declaration here ... entity top_level_unit_tb is end top_level_unit_tb; architecture TB_ARCHITECTURE of top_level_unit_tb is -- Component declaration of the tested unit component top_level_unit port( DCD : in std_logic; RXD : in std_logic; clk : in std_logic; empty : in std_logic; empty_mixer : in std_logic; full : in std_logic; 46

rst : in std_logic; test : in std_logic; TASTER : in std_logic_vector(7 downto 0); ispravnost : out std_logic; neispravnost : out std_logic; ready : out std_logic; req_empty : out std_logic; req_fill : out std_logic; start_rotate : out std_logic ); end component; -- Stimulus signals - signals mapped to the input and inout ports of tested entity signal DCD : std_logic:= '0'; signal RXD : std_logic:= '1'; signal clk : std_logic:='0'; signal empty : std_logic:='0'; signal empty_mixer : std_logic:='0'; signal full : std_logic:='0'; signal test : std_logic:='0'; signal rst : std_logic:='0'; signal TASTER : std_logic_vector(7 downto 0):="00000000"; -- Observed signals - signals mapped to the output ports of tested entity signal ispravnost : std_logic; signal neispravnost : std_logic; signal ready : std_logic; signal req_empty : std_logic; signal req_fill : std_logic; signal start_rotate : std_logic; constant CLK_PERIOD : time := 238 ns; signal endsim: boolean:=false; -- Add your code here ... begin -- Unit Under Test port map UUT : top_level_unit port map ( DCD => DCD, RXD => RXD, clk => clk, empty => empty, empty_mixer => empty_mixer, full => full, rst => rst, test => test, TASTER => TASTER, ispravnost => ispravnost, 47

neispravnost => neispravnost, ready => ready, req_empty => req_empty, req_fill => req_fill, start_rotate => start_rotate ); CLK_GEN: process begin if endsim=false then clk <= '0'; wait for CLK_PERIOD/2; clk <= '1'; wait for CLK_PERIOD/2; else wait; end if; end process; GEN: process is procedure ReceiveByte(Data: std_logic_vector(7 downto 0)) is begin Rxd<='1'; wait for 52.08 us; Rxd<='0'; wait for 52.08 us; Rxd<=Data(0); wait for 52.08 us; Rxd<=Data(1); wait for 52.08 us; Rxd<=Data(2); wait for 52.08 us; Rxd<=Data(3); wait for 52.08 us; Rxd<=Data(4); wait for 52.08 us; Rxd<=Data(5); wait for 52.08 us; Rxd<=Data(6); wait for 52.08 us; Rxd<=Data(7); wait for 52.08 us; Rxd<='1'; wait for 52.08 us; end procedure; begin 48

rst <= '1'; wait for CLK_PERIOD; rst <= '0'; DCD <= '1'; wait for CLK_PERIOD; test<='1'; wait for 3*CLK_PERIOD; test<='0'; wait for 10*CLK_PERIOD; DCD <= '0';

wait until (clk'event and clk = '1'); rst <= '1'; wait for CLK_PERIOD; rst <= '0'; wait for 10* CLK_PERIOD; ReceiveByte("00000001"); ReceiveByte("00000000"); ReceiveByte("00000011"); ReceiveByte("00000010"); ReceiveByte("00000010");

RxD <= '1'; --wait for 10 ms; DCD <= '1'; wait for CLK_PERIOD; TASTER<="00000001" ; wait for 2*CLK_PERIOD; TASTER<="00000000"; wait for 15*CLK_PERIOD; full<='1'; wait for 3*CLK_PERIOD; full<='0'; wait for 10*CLK_PERIOD; empty<='1'; wait for 3*CLK_PERIOD; empty<='0'; wait for 15*CLK_PERIOD; full<='1'; wait for 3*CLK_PERIOD; full<='0'; 49

wait for 15*CLK_PERIOD; empty<='1'; wait for 3*CLK_PERIOD; empty<='0'; wait for 6*CLK_PERIOD; full<='1'; wait for 10*CLK_PERIOD; full<='0'; wait for 6*CLK_PERIOD; empty<='1'; wait for 3*CLK_PERIOD; empty<='0'; wait for 6*CLK_PERIOD; full<='1'; wait for 3*CLK_PERIOD; full<='0'; wait for 15*CLK_PERIOD; empty<='1'; wait for 3*CLK_PERIOD; empty<='0'; wait for 6*CLK_PERIOD; full<='1'; wait for 3*CLK_PERIOD; full<='0'; wait for 15*CLK_PERIOD; empty<='1'; wait for 3*CLK_PERIOD; empty<='0'; wait for 6*CLK_PERIOD; full<='1'; wait for 3*CLK_PERIOD; full<='0'; wait for 15*CLK_PERIOD; empty<='1'; wait for 3*CLK_PERIOD; empty<='0'; wait for 38*CLK_PERIOD; full<='1'; wait for 6*CLK_PERIOD; full<='0'; wait for CLK_PERIOD; empty<='1'; wait for 3*CLK_PERIOD; empty<='0'; wait for 10*CLK_PERIOD; full<='1'; wait for 3*CLK_PERIOD; 50

full<='0'; wait for 5*CLK_PERIOD; empty<='1'; wait for 3*CLK_PERIOD; empty<='0'; wait for 10*CLK_PERIOD; wait until ready='1'; wait for 10*CLK_PERIOD; empty_mixer<='1'; wait for 10*CLK_PERIOD; wait for 0.5ms; endsim<=true; wait; end process; end TB_ARCHITECTURE; configuration TESTBENCH_FOR_top_level_unit of top_level_unit_tb is for TB_ARCHITECTURE for UUT : top_level_unit use entity work.top_level_unit(top_level_unit); -- use entity work.top_level_unit(beh); end for; end for; end TESTBENCH_FOR_top_level_unit;

51

talasni oblici prikazani su na sledećim slikama:

Slika7.testiranje pet registra

Slika8.upis u memoriju

52

Slika9.proces spremanja betona

53

6.Sinteza Za sintezu projekta je upotrebljen Sinplify Pro7.x koji je deo programskog paketa Synplicity. Za sintezu je uzet čip pod nazivom kolo iz familije Actel A500k koje ima oznaku A500K180PQ208. frekvencija: 1 MHz; maxfan: 100. Na ovaj način je dobijena je Netlista koja je potrebna za implementaciju. Nad sintetizovanim kolom je izvršena simulacija radi provere rada dobijenog kola nakon sinteze. Provera se vrši poređenjem grafika dobijenog nakon simulacije opisa na VHDL-u i grafika posle sinteze. Tokom projektovanja ovog sistema, korišćene su prednosti pristupa projektovanja zasnovanog na VHDL opisu. Kao prvo, proces projektovanja veoma složenih sistema se veoma pojednostavljuje zato što se ceo sistem sastoji od blokova koji se posmatraju kao crne kutije i opisuju na funkcionalnom nivou. Zatim omogućava se veoma jednostavna i jeftina tehnika za testiranje sistema pre njegove realizacije. Kompletan sistem se zatim lako realizuje na VLSI nivou.

Slika10. RTL netlist

54

Slika11.Gate netlist

55

Slika12.memorija

56

Posle sinteze izvršena je simulacija i utvrđeno da signali koji su dobijeni zadovoljavaju željene vrednosti.

Slika13.talasni oblici signala posle sinteze

57

Slika14. talasni oblici ulazno-izlaznih signala globalnog sistema posle sinteze

Slika15. talasni oblici ulazno-izlaznih signala globalnog sistema pre sinteze

58

SADRŽAJ 1. 2. 3. 4.

Projektni zadatak ..........................................................................................................................2 Uvod ............................................................................................................................................ 3 Arhitektura sistema i princip rada ................................................................................................4 Opis u vhdl-u i uloga blokova sistema ponaosob …………………........................................8 4.1. Upis_u_ram ………………………………………………….…......................................8 4.1.1. UART_Receiver ………………………………………….........................................9 4.1.2. Prijem_za_ram ..........................................................................................................11 4.1.3. addr_upisa .................................................................................................................12 4.2. odabir spremanja ……………………………………………..................................….13 4.3. reg_code ………………………………………………………......................................14 4.4. read_address ....................................................................................................................15 4.5. or2b ................................................................................................................................16 4.6. mux1 ……………………………………………………….................................….….17 4.7. df_flop ............................................................................................................................18 4.8. counter_4_bit …………………………………………………......................................19 4.9. verzija_256_bajta …………………………………………….…...................................20 4.10. reg1b ……………………………………………………….................................…23 4.11. dmux1………………………………………………………....................................24 4.12. upis_reg…………………………………………………….................................…25 4.13. mux_mat……………………………………………………....................................26 4.14. counter_8_bit……………………………………………….....................................27 4.15. counter_material ……………………………………………...................................28 4.16. komparator1 …………………………………………….................................…….29 4.17. komparator2…………………………………………….................................……..30 4.18. komparator3 …………………………………………………..................................31 4.19. tajmer_1min …………………………………………………..................................32 4.20. tajmer_5min …………………………………………………..................................33 4.21. fsm1…………………………………………………………...................................34 4.22. fsm_test ……………………………………………………....................................40 5. Test Bench i talasni oblici ………………………………………………………................................45 6. Sinteza ……………………………………………………………………................................53

59