ledmatrix.vhdl

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity LEDMatrixCNTRL is

PORT(
    --TO DO 1 -> deklarirati ulaze "rst", "wake", "send_data", "send_reg" i "clk_in" (STD_LOGIC)
    rst, wake, send_data, send_reg, clk_in: in std_logic;
    --TO DO 2 -> deklarirati ulaz "data" (STD_LOGIC_VECTOR) veličine 64 bita (koristiti '0 to 63')
    data: in STD_LOGIC_VECTOR(0 to 63);
    --TO DO 3 -> deklarirati ulaz "CNTRL_reg" (STD_LOGIC_VECTOR) veličine 16 bita
    CNTRL_reg: in STD_LOGIC_VECTOR(0 to 15);
    --TO DO 4 -> deklarirati izlaze "load" i "d_out" (STD_LOGIC)
    load, d_out: out std_logic;
    --TO DO 5 -> deklarirati buffer "clk_out" (STD_LOGIC)
    clk_out: buffer std_logic;

);

end LEDMatrixCNTRL;

architecture Behavioral of LEDMatrixCNTRL is

    --TO DO 6 -> deklarirati signal "decoded_data" (STD_LOGIC_VECTOR) veličine 16 bita i signal "decode" (integer) koji može poprimiti vrijednosti u rasponu od 0 do 7
    signal decoded_data: STD_LOGIC_VECTOR(0 to 15);
    signal decore: integer range 0 to 7;


    --TO DO 7 -> definirati konstante "wake_signal" i "shutDown_signal" (STD_LOGIC_VECTOR) veličine 16 bita te im pridružiti odgovarajuće vrijednosti
    constant wake_signal: STD_LOGIC_VECTOR(0 to 15) := "0000_1100_0000_0001";
    constant shutDown_signal: STD_LOGIC_VECTOR(0 to 15) := "0000_1100_0000_0000";


    --TO DO 8 -> definirati korisnički tip podataka naziva "state" koji može imati vrijednosti "ShutDown", "WakeState", "SSD", "NormalOP", "SendData" i "SendReg"
    TYPE state IS (ShutDown, WakeState, SSD, NormalOP, SendData, SendReg);

    --TO DO 9 -> deklarirati signale "current_state" i "next_state" koji su tipa "state"
    SIGNAL current_state, next_state: state;

    --TO DO 10 -> deklarirati signale "sent" i "sentMatrix" (STD_LOGIC)
    SIGNAL sent, sentMatrix: std_logic;


begin

    --TO DO 11 -> instancirati generički djelitelj frekvencije na način da od ulaznog singala takta kreira signal takta frekvencije 390 625 Hz


    FSMSequential: process(clk_out, rst)
    begin
    --TO DO 12 -> ako je "rst" jednak 1, signalu "current_state" pridružiti vrijednost SSD
        if(rst='1') then
            current_state <= SSD;
    --TO DO 13 -> u suprotnom, na rastući brid signala "clk_out", signalu "current_state" pridružiti vrijednost signala "next_state"
        elsif(clk_out'event and clk_out='1') then
            current_state <= next_state;
        end if;
    end process;

    process(current_state, wake, send_data, send_reg, sent, sentMatrix)
    begin

        case current_state IS

    --TO DO 14 -> ako signal "current_state" ima vrijednost ShutDown, onda signalu "next_state" pridružiti vrijednost WakeState u slučaju da ulaz "wake" ima vrijednost 1, a u suprotnom mu pridružiti vrijednost ShutDown
            when  ShutDown =>
                if(wake='1') then
                    next_state <= WakeState;
                else
                    next_state <= ShutDown;
                end if;
    --TO DO 15 -> ako signal "current_state" ima vrijednost WakeState, onda signalu "next_state" pridružiti vrijednost NormalOP u slučaju da signal "sent" ima vrijednost 1, a u suprotnom mu pridružiti vrijednost WakeState
            when  WakeState=>
                if(sent='1') then
                    next_state <= NormalOP;
                else
                    next_state <= WakeState;
                end if;
    --TO DO 16 -> ako signal "current_state" ima vrijednost SSD, onda signalu "next_state" pridružiti vrijednost ShutDown u slučaju da signal "sent" ima vrijednost 1, a u suprotnom mu pridružiti vrijednost SSD
            when SSD =>
                if(sent='1') then
                    next_state <= ShutDown;
                else
                    next_state <= SSD;
                end if;
    --TO DO 17 -> ako signal "current_state" ima vrijednost NormalOP, onda signalu "next_state" pridružiti vrijednost SendReg (u slučaju da ulaz "send_reg" ima vrijednost 1), vrijednost SendData (u slučaju da ulaz "send_data"
     --ima vrijednost 1), a u suprotnom mu pridružiti vrijednost NormalOP
            when NormalOP =>
                if(send_reg='1') then
                    next_state <= SendReg;
                elsif(send_data='1') then
                    next_state <= SendData;
                else
                    next_state <= NormalOP;
                end if;
    --TO DO 18 -> ako signal "current_state" ima vrijednost SendReg, onda signalu "next_state" pridružiti vrijednost NormalOP u slučaju da signal "sent" ima vrijednost 1, a u suprotnom mu pridružiti vrijednost SendReg
            when  SendReg=>
                if(sent='1') then
                    next_state <= NormalOP;
                else
                    next_state <= SendReg;
                end if;
    --TO DO 19 -> ako signal "current_state" ima vrijednost SendData, onda signalu "next_state" pridružiti vrijednost NormalOP u slučaju da signal "sentMatrix" ima vrijednost 1, a u suprotnom mu pridružiti vrijednost SendData
            when  SendData =>
                if(sentMatrix='1') then
                    next_state <= NormalOP;
                else
                    next_state <= SendData;
                end if;
            end case;
    end process;

    --TO DO 20 -> u listi osjetljivosti navesti signale "clk_out" i "rst"
    setLoad: process(clk_out, rst)
    begin
    --TO DO 21 -> ako signal "rst" ima vrijednost 1, onda signalu "load" pridružiti vrijednost 0
        if (rst='1') then
            load <= '0';
    --TO DO 22 -< u suprotnom, na rastući brid signala takta "clk_out", signalu "load" pridružiti vrijednost 1 (ako signal "sent" ima vrijednost 1), odnosno 0 (ako signal "sent" nema vrijednost 1)
        elsif(clk_out'event and clk_out='1') then
            if (sent='1') then
                load <= '1';
            else
                load <= '0';
            end if;
        end if;
    end process;

    SendProcess: process(rst, clk_out)
    --TO DO 23 -> deklarirati varijable "counter_reg" i "counter_data" (integer) koje mogu poprimiti vrijednosti u rasponu od 0 do 16, odnosno 0 do 8
    variable counter_reg: integer range 0 to 16;
    variable counter_data: integer range 0 to 8;

    begin
    --TO DO 24 -> ako ulaz "rst" ima vrijednost 1, onda signalima "sent" i "sentMatrix", izlazu "d_out" te varijablama "counter_reg" i "counter_data" pridružiti vrijednost 0
        if(rst='1') then
            sent <= '0';
            sentMatrix <= '0';
            d_out <= '0';
            counter_reg := 0;
            counter_data := 0;

        elsif(clk_out'event AND clk_out = '0') then

            case currentS IS
    --TO DO 25 -> ako signal "current_state" ima vrijednost ShutDown onda signalu "sent" te varijablama "counter_reg" i "counter_data" pridružiti vrijednost 0
                when  ShutDown =>
                    sent <= '0';
                    counter_reg := 0;
                    counter_data := 0;

                when WakeState =>
                    --SEND: xxxx1100_xxxxxxx1
    --TO DO 26 -> izlazu "d_out" pridružiti vrijednost bita s indeksom "counter_reg" u konstanti "wake_signal" te varijablu "counter_reg" povećati za 1
                    d_out <= wake_signal(counter_reg);
                    counter_reg := counter_reg + 1;

    --TO DO 27 -> ako je "counter_reg" veći ili jendak 16, signalu "sent" pridružiti vrijednost 1, a varijabli "counter_reg" pridružiti vrijednost 0
                    if(counter_reg >= 16) then
                        sent <= '1';
                        counter_reg := 0;
                    end if;

                when SSD =>
                    --SEND: xxxx1100_xxxxxxx0
    --TO DO 28 -> izlazu "d_out" pridružiti vrijednost bita s indeksom "counter_reg" u konstanti "shutDown_signal" te varijablu "counter_reg" povećati za 1
                    d_out <= shutDown_signal(counter_reg);
                    counter_reg := counter_reg + 1;

    --TO DO 29 -> ako je "counter_reg" veći ili jendak 16, signalu "sent" pridružiti vrijednost 1, a varijabli "counter_reg" pridružiti vrijednost 0
                    if(counter_reg >= 16) then
                        sent <= '1';
                        counter_reg := 0;
                    end if;
    --TO DO 30 -> ako signal "current_state" ima vrijednost NormalOP, signalima "sent" i "sentMatrix" te varijablama "counter_reg" i "counter_data" pridružiti vrijednost 0
                when  NormalOP =>
                    sent <= '0';
                    sentMatrix <= '0';
                    counter_reg := 0;
                    counter_data := 0;


                when SendReg =>
                    -- SEND CNTRL_reg values
    --TO DO 31 -> izlazu "d_out" pridružiti vrijednost bita s indeksom "counter_reg" u signalu "CNTRL_reg" te varijablu "counter_reg" povećati za 1
                    d_out <= CNTRL_reg(counter_reg);
                    counter_reg := counter_reg + 1;

    --TO DO 32 -> ako je "counter_reg" veći ili jendak 16, signalu "sent" pridružiti vrijednost 1, a varijabli "counter_reg" pridružiti vrijednost 0
                    if(counter_reg >= 16) then
                        sent <= '1';
                        counter_reg := 0;
                    end if;

                when SendData =>
                    -- SEND decoded_data values
    --TO DO 33 -> izlazu "d_out" pridružiti vrijednost bita s indeksom "counter_reg" u signalu "decoded_data" te varijablu "counter_reg" povećati za 1
                    d_out <= decoded_data(counter_reg);
                    counter_reg := counter_reg + 1;

    --TO DO 34 -> ako je "counter_reg" veći ili jendak 16, signalu "sent" pridružiti vrijednost 1, varijabli "counter_reg" pridružiti vrijednost 0, a varijabli "counter_data" vrijednost povećati za 1
                    if(counter_reg >= 16) then
                        sent <= '1';
                        counter_reg := 0;
                    else
                        sent <= '0';
                    end if;
    --TO DO 35 -> ako je "counter_data" veći ili jendak 8, signalu "sentMatrix" pridružiti vrijednost 1, a varijabli "counter_data" pridružiti vrijednost 0
                    if(counter_data >= 8) then
                        sentMatrix <= '1';
                        counter_data := 0;
                    end if;

            end case;
        end if;

    --TO DO 36 -> signalu "decode" pridružiti vrijednost varijable "counter_data"
        decode <= counter_data;

    end process;

    --TO DO 37 -> u ovisnosti o vrijednosti signala "decode", signalu "decoded_data" pridružiti odgovarajuće vrijednosti
    decoded_data <= "" & "" & data() when decode =  else
                        "" & "" & data() when decode =  else
                        "" & "" & data() when decode =  else
                        "" & "" & data() when decode =  else
                        "" & "" & data() when decode =  else
                        "" & "" & data() when decode =  else
                        "" & "" & data() when decode =  else
                        "" & "" & data();
end Behavioral;