LEDSnake.vhdp

Main
(
    RX            : IN STD_LOGIC;
    TX            : OUT STD_LOGIC;
    CS_O          : BUFFER STD_LOGIC;
    CLK_O         : OUT STD_LOGIC;
    DIN_O         : OUT STD_LOGIC;
    RightButton   : IN STD_LOGIC;
    LeftButton    : IN STD_LOGIC;
)
{
    
    #region Components & Signals
    
    SIGNAL Single_Port_RAM_Write    : std_logic;
    SIGNAL Single_Port_RAM_Address  : natural          range 0 to 256-1;
    SIGNAL Single_Port_RAM_Data_IN  : std_logic_vector (8-1 downto 0);
    SIGNAL Single_Port_RAM_Data_OUT : std_logic_vector (8-1 downto 0);
    NewComponent Single_Port_RAM
    (
        Width    => 256,
        Bits     => 8,
        
        Write    => Single_Port_RAM_Write,
        Address  => Single_Port_RAM_Address,
        Data_IN  => Single_Port_RAM_Data_IN,
        Data_OUT => Single_Port_RAM_Data_OUT,
    );
    
    SIGNAL UART_Interface_RX_Busy       : STD_LOGIC;
    SIGNAL UART_Interface_RX_Data       : STD_LOGIC_VECTOR (8-1 DOWNTO 0);
    SIGNAL UART_Interface_TX_Enable     : STD_LOGIC;
    SIGNAL UART_Interface_TX_Busy       : STD_LOGIC;
    SIGNAL UART_Interface_TX_Data       : STD_LOGIC_VECTOR (8-1 DOWNTO 0);
    NewComponent UART_Interface
    (
        Baud_Rate     => 9600,
        
        RX            => RX,
        TX            => TX,
        TX_Enable     => UART_Interface_TX_Enable,
        TX_Busy       => UART_Interface_TX_Busy,
        TX_Data       => UART_Interface_TX_Data,
        
        RX_Busy => UART_Interface_RX_Busy,
        RX_Data =>UART_Interface_RX_Data,
    );
    
    CONSTANT LED_Matrix_Length : NATURAL := (4*8);
    CONSTANT LED_Matrix_Height : NATURAL := 8;

    SIGNAL LED_Matrix_Panel_Bitmap  : LED_Matrix_Array (LED_Matrix_Length-1 downto 0) := (others => (others => '0'));
    SIGNAL LED_Matrix_Update        : STD_LOGIC;
    SIGNAL LED_Matrix_Brightness    : NATURAL          range 0 to 15 := 5;
    SIGNAL LED_Matrix_Shutdown      : STD_LOGIC := '0';
    SIGNAL LED_Matrix_Config        : STD_LOGIC;
    NewComponent LED_Matrix
    (
        CLK_Frequency => 12000000,
        Panels        => 4,
        Rotate_seg    => '1',
        Mirror        => '1',
        
        Reset         => '0',
        CS_O          => CS_O,
        CLK_O         => CLK_O,
        DIN_O         => DIN_O,
        Panel_Bitmap  => LED_Matrix_Panel_Bitmap,
        Update        => LED_Matrix_Update,
        Brightness    => LED_Matrix_Brightness,
        Shutdown      => LED_Matrix_Shutdown,
        Config        => LED_Matrix_Config,
    );
    
    SIGNAL UARTInputValue : NATURAL range 0 to 3;
    
    SIGNAL Input_Debouncer_Inputs       : STD_LOGIC_VECTOR (2-1 downto 0);
    SIGNAL Input_Debouncer_Outputs      : STD_LOGIC_VECTOR (2-1 downto 0);
    Input_Debouncer_Inputs(0) <= LeftButton;
    Input_Debouncer_Inputs(1) <= RightButton;
    NewComponent Input_Debouncer
    (
        Counter_Size => 19,
        Input_Number => 2,
        
        Inputs       => Input_Debouncer_Inputs,
        Outputs      => Input_Debouncer_Outputs,
    );
    
    TYPE Point IS RECORD
    X : INTEGER range -1 to LED_Matrix_Length;
    Y : INTEGER range -1 to LED_Matrix_Height;
    END RECORD Point;
    
    TYPE PointArray IS ARRAY (natural range <>) OF Point;
    
    SIGNAL rng_xoshiro128plusplus_out_valid : std_logic;
    SIGNAL rng_xoshiro128plusplus_out_ready : std_logic := '0';
    SIGNAL rng_xoshiro128plusplus_out_data  : std_logic_vector (31 downto 0);
    NewComponent rng_xoshiro128plusplus
    (
        init_seed => x"3141592653589793fedcba9876543210",
        pipeline  => true,
        
        clk       => CLK,
        rst       => '0',
        reseed    => '0',
        newseed   => (others => '0'),
        out_ready => rng_xoshiro128plusplus_out_ready,
        out_valid => rng_xoshiro128plusplus_out_valid,
        out_data  => rng_xoshiro128plusplus_out_data,
    );
    
    SIGNAL SnakeLength : POSITIVE range 1 to (LED_Matrix_Length*LED_Matrix_Height-1) := 3;
    
    #endregion
    
    Process
    (
        --0 = Left, 1 = Top, 2 = Right, 3 = Bottom
        VARIABLE Direction : NATURAL range 0 to 3 := 2;

        VARIABLE Ready : BOOLEAN := false;
        
        VARIABLE LastLeftButton : STD_LOGIC := '0';
        VARIABLE LastRightButton : STD_LOGIC := '0';
        
        VARIABLE Snack : Point;
    )
    {
        Thread --Setup: Set Default values to ram and spawn random point
        {
            Single_Port_RAM_Data_IN <= "00000000";
            Single_Port_RAM_Write <= '1';
            Single_Port_RAM_Address <= 0;

            --Set default ram
            For(Single_Port_RAM_Address <= 0; Single_Port_RAM_Address < 10; Single_Port_RAM_Address <= Single_Port_RAM_Address + 1)
            {
            }

            Single_Port_RAM_Write <= '0';

            Wait(100ms);
            
            --Spawn random dot
            Snack := (X => TO_INTEGER(UNSIGNED(rng_xoshiro128plusplus_out_data(4 downto 0))), Y => TO_INTEGER(UNSIGNED(rng_xoshiro128plusplus_out_data(7 downto 5))));

            Ready := true;

            while(true){}
        }

        If(Ready)
        {
            Thread
            {
                
                VARIABLE Head : Point;

                --read Snake Head from Ram
                Single_Port_RAM_Write <= '0';
                Single_Port_RAM_Address <= 0;
                
                --Use step to generate random
                rng_xoshiro128plusplus_out_ready <= '1';
                Step
                {
                    rng_xoshiro128plusplus_out_ready <= '0';
                    Head.X := TO_INTEGER(UNSIGNED(Single_Port_RAM_Data_OUT(4 downto 0))); --X;
                    Head.Y := TO_INTEGER(UNSIGNED(Single_Port_RAM_Data_OUT(7 downto 5))); --Y;
                }
                
                #region Move

                if(Direction = 0)
                {
                    Head.X := Head.X - 1;
                }
                elsif(Direction = 1)
                {
                    Head.Y := Head.Y + 1;
                }
                elsif(Direction = 2)
                {
                    Head.X := Head.X + 1;
                }
                elsif(Direction = 3)
                {
                    Head.Y := Head.Y - 1;
                }

                #endregion
                
                #region Collisions
                
                --Check if snack is consumed
                if(Snack.X = Head.X AND Snack.Y = Head.Y)
                {
                    SnakeLength <= SnakeLength + 1;
                    --Spawn new snack
                    Snack := (X => TO_INTEGER(UNSIGNED(rng_xoshiro128plusplus_out_data(4 downto 0))),
                        Y => TO_INTEGER(UNSIGNED(rng_xoshiro128plusplus_out_data(7 downto 5))));
                }
                elsif(Head.X < 0
                    OR Head.Y >= LED_Matrix_Height
                    OR Head.X >= LED_Matrix_Length
                    OR Head.Y < 0
                    OR LED_Matrix_Panel_Bitmap(Head.X)(Head.Y) = '1')
                {
                    --Reset
                    Direction := 2;
                    Head.X := 0;
                    Head.Y := 0;
                    SnakeLength <= 3;
                    Snack := (X => TO_INTEGER(UNSIGNED(rng_xoshiro128plusplus_out_data(4 downto 0))),
                        Y => TO_INTEGER(UNSIGNED(rng_xoshiro128plusplus_out_data(7 downto 5))));
                    
                    NewFunction assignString (s"\nGame Over! Your Score: ", gameOverTextString);
                    NewFunction newString (scoreString);
                    NewFunction naturalToStringInst ((SnakeLength-3), scoreString, bcdEna, bcdBus, bcdBin, bcdDec);
                    NewFunction newString (gameOverString);
                    NewFunction stringConcat (gameOverTextString, scoreString, gameOverString);
                    NewFunction printString (gameOverString, UART_Interface_TX_Data, UART_Interface_TX_Busy, UART_Interface_TX_Enable);
                }
                
                #endregion
                
                #region Update Snake Draw
                
                --Reset Canvas
                LED_Matrix_Panel_Bitmap <= (others => (others => '0'));
                
                --Move snake one back and write whoole snake to Ram and draw
                For (VARIABLE i : INTEGER := SnakeLength - 1; i > 0; i := i - 1)
                {
                    Single_Port_RAM_Write <= '0';
                    Single_Port_RAM_Address <= i - 1;
                    Step
                    {
                        LED_Matrix_Panel_Bitmap(TO_INTEGER(UNSIGNED(Single_Port_RAM_Data_OUT(4 downto 0))))(TO_INTEGER(UNSIGNED(Single_Port_RAM_Data_OUT(7 downto 5)))) <= '1';
                        Single_Port_RAM_Data_IN <= Single_Port_RAM_Data_OUT;
                        Single_Port_RAM_Address <= i;
                        Single_Port_RAM_Write <= '1';
                    }
                }

                --Write Head to Ram and draw
                Single_Port_RAM_Address <= 0;
                Single_Port_RAM_Data_IN <= STD_LOGIC_VECTOR(TO_UNSIGNED(Head.Y, 3)) & STD_LOGIC_VECTOR(TO_UNSIGNED(Head.X, 5));
                LED_Matrix_Panel_Bitmap(Head.X)(Head.Y) <= '1';
                
                --Draw Snack
                LED_Matrix_Panel_Bitmap(Snack.X)(Snack.Y) <= '1';

                Step{ LED_Matrix_Update <= '0'; Single_Port_RAM_Write <= '0'; }
                LED_Matrix_Update <= '1';

                #endregion

                Wait(100ms);
            }
        }

        Thread
        {
            NewFunction newString (inputString);
            NewFunction readString (inputString, UART_Interface_RX_Data, UART_Interface_RX_Busy);

            NewFunction stringToNatural (inputString, UARTInputValue);
            NewFunction printString (inputString, UART_Interface_TX_Data, UART_Interface_TX_Busy, UART_Interface_TX_Enable);

            Direction := UARTInputValue;
        }

        Thread
        {
            if(Input_Debouncer_Outputs(0) /= LastLeftButton)
            {
                LastLeftButton := Input_Debouncer_Outputs(0);

                if(Input_Debouncer_Outputs(0) = '1')
                {
                       --LeftButton
                    if(Direction > 0)
                    {
                        Direction := Direction - 1;
                    }
                    else
                    {
                        Direction := 3;
                    }
                }
            }
            
            if(Input_Debouncer_Outputs(1) /= LastRightButton)
            {
                LastRightButton := Input_Debouncer_Outputs(1);

                if(Input_Debouncer_Outputs(1) = '1')
                {
                       --RightButton
                    if(Direction < 3)
                    {
                        Direction := Direction + 1;
                    }
                    else
                    {
                        Direction := 0;
                    }
                }
            }
        }
    }
}