main moj

module main(
    input wire clk,
    input wire reset,
    input wire start,
    input wire  sw3,
    input wire  sw2,
    input wire  sw1,
    input wire  [2:0] but,
    output wire [6:0] hex0,
    output wire [6:0] hex1,
    output wire [6:0] hex2,
    output wire [6:0] hex3,
    output wire [3:0] led
);

function automatic [6:0] BCDDecoder(input [3:0] digit);
    begin
        case(digit)
            4'd0: BCDDecoder = 7'b1000000;
            4'd1: BCDDecoder = 7'b1111001;
            4'd2: BCDDecoder = 7'b0100100;
            4'd3: BCDDecoder = 7'b0110000;
            4'd4: BCDDecoder = 7'b0011001;
            4'd5: BCDDecoder = 7'b0010010;
            4'd6: BCDDecoder = 7'b0000010;
            4'd7: BCDDecoder = 7'b1111000;
            4'd8: BCDDecoder = 7'b0000000;
            4'd9: BCDDecoder = 7'b0010000;
            default: BCDDecoder = 7'b1111111;
        endcase
    end
endfunction

wire b0, b1, b2;
reg [15:0] seconds, seconds_next;
reg [2:0] state_reg, state_next;
parameter INICIJALIZACIJA = 3'b000;
parameter ODBROJAVANJE = 3'b001;
parameter ZAMRZNUTO = 3'b010;
parameter TREPERENJE = 3'b011;
reg [15:0] sifra_reg, sifra_next;
reg [15:0] unos_reg, unos_next;
//reg[6:0] disp0, disp0_next, disp1, disp1_next, disp2, disp2_next, disp3, disp3_next;
reg[3:0] maska, maska_next;
reg [3:0] duzina_sifre, duzina_sifre_next;
reg[3:0] duzina_unosa, duzina_unosa_next;
integer counter, counter_next;
integer pokusaj, pokusaj_next;
reg[3:0] ledg, ledg_next;

assign hex0 = BCDDecoder(seconds[3:0]);
assign hex1 = BCDDecoder(seconds[7:4]);
assign hex2 = BCDDecoder(seconds[11:8]);
assign hex3 = BCDDecoder(seconds[15:12]);
assign led = ledg;
/*redge r0(
    .clk(clk),
    .reset(reset),
    .data_in(but[0]),
    .data_out(b0));
redge r1(
    .clk(clk),
    .reset(reset),
    .data_in(but[1]),
    .data_out(b1));
redge r2(
    .clk(clk),
    .reset(reset),
    .data_in(but[2]),
    .data_out(b2));*/

always @(posedge clk, posedge reset) begin
    if(reset == 1) begin
        state_reg <= INICIJALIZACIJA;
        seconds <= 16'h0000;
        sifra_reg <= 16'h0000;
        unos_reg <= 16'h0000;
        duzina_sifre <= 0;
        duzina_unosa <= 0;
        counter <= 0;
        maska <= 4'b0000;
        pokusaj <= 0;
        ledg <= 0;
    end
    else begin
        state_reg <= state_next;
        seconds <= seconds_next;
        sifra_reg <= sifra_next;
        unos_reg <= unos_next;
        duzina_sifre <= duzina_sifre_next;
        duzina_unosa <= duzina_unosa_next;
        counter <= counter_next;
        maska <= maska_next;
        pokusaj <= pokusaj_next;
        ledg <= ledg_next;
    end
end
integer i;
always @(*) begin
    state_next = state_reg;
    seconds_next = seconds;
    sifra_next = sifra_reg;
    unos_next = unos_reg;
    duzina_sifre_next = duzina_sifre;
    duzina_unosa_next = duzina_unosa;
    counter_next = counter;
    maska_next = maska;
    pokusaj_next = pokusaj;
    ledg_next = ledg;
    case(state_reg)
        INICIJALIZACIJA: begin
                if(sw3 == 1) begin
                    seconds_next = 16'h9999;
                    maska_next = 4'b1111;
                end
                else if(sw2 == 1) begin
                    seconds_next = 16'h0999;
                    maska_next = 4'b0111;
                end
                else if (sw1 == 1) begin
                    seconds_next = 16'h0099;
                    maska_next = 4'b0011;
                end
                else begin
                    seconds_next = 16'h0009;
                    maska_next = 4'b0001;
                end
            //endcase
            if(but[0] == 1) begin
                sifra_next[15:0] = {sifra_reg[13:0], 2'b01};
                duzina_sifre_next = (duzina_sifre == 8) ? 8 : duzina_sifre + 1;
            end
            if(but[1] == 1) begin
                sifra_next[15:0] = {sifra_reg[13:0], 2'b10};
                duzina_sifre_next = (duzina_sifre == 8) ? 8 : duzina_sifre + 1;
            end
            if(but[2] == 1) begin
                sifra_next[15:0] = {sifra_reg[13:0], 2'b11};
                duzina_sifre_next = (duzina_sifre == 8) ? 8 : duzina_sifre + 1;
            end
            if(start == 1) begin
                state_next = ODBROJAVANJE;
                counter_next = 0;
            end
        end
        ODBROJAVANJE: begin
            if(counter == 49_999_999) begin
                counter_next = 0;
                begin: loop;
                    for(i=0; i<4; i = i+1) begin
                        if (seconds[4*i+3-:4] == 0) begin
                            if(maska > 2**i) begin
                                seconds_next[4*i+3-:4] <= 9;
                                maska_next[i] = 1;
                            end
                            else seconds_next[4*i+3-:4] <= 0;
                        end
                        else begin
                            seconds_next[4*i+3-:4] <= seconds[4*i+3-:4] - 1;
                            if(seconds[4*i+3-:4] - 1 == 0) maska_next[i] = 0;
                            disable loop;
                        end;
                    end
                end
            end
            else counter_next = counter + 1;

            if(duzina_sifre == duzina_unosa && duzina_sifre != 0) begin
                if(sifra_reg == unos_reg) state_next = ZAMRZNUTO;
                else if(pokusaj + 1 == 4) begin
                        state_next = TREPERENJE;
                        ledg_next = 4'b1111;
                    end
                    else begin
                        pokusaj_next = pokusaj + 1;
                        ledg_next = {ledg[2:0], 1'b1};
                        unos_next = 16'h0000;
                        duzina_unosa_next = 0;
                    end
            end else begin
            if(but[0] == 1) begin
                unos_next[15:0] = {unos_reg[13:0], 2'b01};
                duzina_unosa_next = duzina_unosa + 1;
            end
            if(but[1] == 1) begin
                unos_next[15:0] = {unos_reg[13:0], 2'b10};
                duzina_unosa_next = duzina_unosa + 1;
            end
            if(but[2] == 1) begin
                unos_next[15:0] = {unos_reg[13:0], 2'b11};
                duzina_unosa_next = duzina_unosa + 1;
            end
            end
        end
        ZAMRZNUTO: begin
            seconds_next = seconds;
        end
        TREPERENJE: begin
            if(counter < 24_999_999) seconds_next = 16'h0000;
            else seconds_next = 16'h8888;
            if(counter == 49_999_999) counter_next = 0;
            else counter_next = counter + 1;
        end
    endcase
end
endmodule