Books | ALBI_Books | Fig_31

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use work.my_package.all;

entity Funcmi is
    port (
        bit0         : in std_logic;
        bit1         : in std_logic;
        clk          : in std_logic;
        data_in      : in std_logic_vector(15 downto 0);
        dma          : in std_logic;
        ext_adr      : in std_logic_vector(15 downto 0);
        ext_in       : out std_logic_vector(15 downto 0);
        ext_out      : in std_logic_vector(15 downto 0);
        ext_rdwr     : in std_logic;
        idle         : out std_logic;
        m            : in std_logic;
        rst          : in std_logic;
        s            : in std_logic
    );
end Funcmi;

architecture ARC_Funcmi of Funcmi is

    type FSMStates is (
        a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, 
        a16, a17, a18
    );
    type bor_type is array (integer range 0 to 15) of std_logic_vector(15 downto 0);
    type m0_type is array (integer range 0 to 65535) of std_logic_vector(15 downto 0);
    type m1_type is array (integer range 0 to 65535) of std_logic_vector(15 downto 0);

    signal bor : bor_type;
    signal br : std_logic_vector(15 downto 0);
    signal currentState : FSMStates;
    signal inpr : std_logic_vector(15 downto 0);
    signal ir1 : std_logic_vector(15 downto 0);
    signal ir2 : std_logic_vector(15 downto 0);
    signal m0 : m0_type;
    signal m1 : m1_type;
    signal pc : std_logic_vector(15 downto 0);
    signal ralu : std_logic_vector(15 downto 0);
    signal rialu : std_logic_vector(15 downto 0);

begin

    process (clk , rst)

        variable alu : std_logic_vector(15 downto 0);
        variable alu_ctr : std_logic_vector(4 downto 0);
        variable alu_in1 : std_logic_vector(15 downto 0);
        variable alu_in2 : std_logic_vector(15 downto 0);
        variable bor_adr : std_logic_vector(3 downto 0);
        variable ialu : std_logic_vector(15 downto 0);
        variable ialu_in1 : std_logic_vector(15 downto 0);
        variable ialu_in2 : std_logic_vector(15 downto 0);
        variable m0_adr : std_logic_vector(15 downto 0);
        variable m1_adr : std_logic_vector(15 downto 0);

    procedure proc_Funcmi is 
    begin


    case currentState is
    when a1 =>
        if (s and dma and ext_rdwr and m) = '1' then
            m1_adr := ext_adr;
            m1(to_integer(unsigned(m1_adr))) <= ext_out;
            currentState <= a1;
            idle <= '1';

        elsif (s and dma and ext_rdwr and not m) = '1' then
            m0_adr := ext_adr;
            m0(to_integer(unsigned(m0_adr))) <= ext_out;
            currentState <= a1;
            idle <= '1';

        elsif (s and dma and not ext_rdwr and m) = '1' then
            m1_adr := ext_adr;
            ext_in <= m1(to_integer(unsigned(m1_adr)));
            currentState <= a1;
            idle <= '1';

        elsif (s and dma and not ext_rdwr and not m) = '1' then
            m0_adr := ext_adr;
            ext_in <= m0(to_integer(unsigned(m0_adr)));
            currentState <= a1;
            idle <= '1';

        elsif (s and not dma) = '1' then
            m0_adr := pc;
            ir1 <= m0(to_integer(unsigned(m0_adr)));
            currentState <= a8;

        else
            currentState <= a1;
            idle <= '1';

        end if;

    when a2 =>
        if (bit1) = '1' then
            bor_adr := ir1(7 downto 4);
            bor(to_integer(unsigned(bor_adr))) <= br;
            currentState <= a1;
            idle <= '1';

        else
            ir2 <= br;
            currentState <= a6;

        end if;

    when a3 =>
        
            alu_in1 := br;
            alu_in2 := ir2;
            alu_ctr := ir1(15 downto 11);
            alub(alu_in1, alu_in2, alu_ctr, alu);
            ralu <= alu;
            currentState <= a5;

    when a4 =>
        if (ir1(9)) = '1' then
            m1_adr := ir2;
            br <= m1(to_integer(unsigned(m1_adr)));
            currentState <= a2;

        else
            bor_adr := ir1(7 downto 4);
            br <= bor(to_integer(unsigned(bor_adr)));
            currentState <= a3;

        end if;

    when a5 =>
        
            bor_adr := ir1(7 downto 4);
            bor(to_integer(unsigned(bor_adr))) <= ralu;
            currentState <= a1;
            idle <= '1';

    when a6 =>
        if (bit1) = '1' then
            m1_adr := ir2;
            br <= m1(to_integer(unsigned(m1_adr)));
            currentState <= a2;

        else
            bor_adr := ir1(7 downto 4);
            br <= bor(to_integer(unsigned(bor_adr)));
            currentState <= a3;

        end if;

    when a7 =>
        
            pc <= std_logic_vector(unsigned(pc) + 1);
            currentState <= a17;

    when a8 =>
        
            pc <= std_logic_vector(unsigned(pc) + 1);
            currentState <= a18;

    when a9 =>
        
            bor_adr := ir1(7 downto 4);
            bor(to_integer(unsigned(bor_adr))) <= inpr;
            currentState <= a1;
            idle <= '1';

    when a10 =>
        if (ir1(9)) = '1' then
            ir2 <= br;
            currentState <= a6;

        else
            bor_adr := ir1(7 downto 4);
            bor(to_integer(unsigned(bor_adr))) <= br;
            currentState <= a1;
            idle <= '1';

        end if;

    when a11 =>
        
            bor_adr := ir1(7 downto 4);
            bor(to_integer(unsigned(bor_adr))) <= br;
            currentState <= a1;
            idle <= '1';

    when a12 =>
        
            ialu_in1 := ir2;
            ialu_in2 := br;
            ialub(ialu_in1, ialu_in2, ialu);
            rialu <= ialu;
            currentState <= a15;

    when a13 =>
        
            ir2 <= br;
            currentState <= a16;

    when a14 =>
        if (bit0) = '1' then
            m1_adr := ir2;
            pc <= m1(to_integer(unsigned(m1_adr)));
            currentState <= a1;
            idle <= '1';

        else
            m1_adr := ir2;
            br <= m1(to_integer(unsigned(m1_adr)));
            currentState <= a2;

        end if;

    when a15 =>
        
            ir2 <= rialu;
            currentState <= a14;

    when a16 =>
        if (ir1(3 downto 0) = "0000" and (bit0) = '1') then
            m1_adr := ir2;
            pc <= m1(to_integer(unsigned(m1_adr)));
            currentState <= a1;
            idle <= '1';

        elsif (ir1(3 downto 0) = "0000" and (not bit0) = '1') then
            m1_adr := ir2;
            br <= m1(to_integer(unsigned(m1_adr)));
            currentState <= a2;

        else
            bor_adr := ir1(3 downto 0);
            br <= bor(to_integer(unsigned(bor_adr)));
            currentState <= a12;

        end if;

    when a17 =>
        if (ir1(8) and bit0) = '1' then
            pc <= ir2;
            currentState <= a1;
            idle <= '1';

        elsif (ir1(8) and not bit0 and bit1) = '1' then
            br <= ir2;
            currentState <= a11;

        elsif (ir1(8) and not bit0 and not bit1) = '1' then
            bor_adr := ir1(7 downto 4);
            br <= bor(to_integer(unsigned(bor_adr)));
            currentState <= a3;

        elsif (not ir1(8) and ir1(9)) = '1' then
            m1_adr := ir2;
            br <= m1(to_integer(unsigned(m1_adr)));
            currentState <= a13;

        elsif (ir1(3 downto 0) = "0000" and (not ir1(8) and not ir1(9) and bit0) = '1') then
            m1_adr := ir2;
            pc <= m1(to_integer(unsigned(m1_adr)));
            currentState <= a1;
            idle <= '1';

        elsif (ir1(3 downto 0) = "0000" and (not ir1(8) and not ir1(9) and not bit0) = '1') then
            m1_adr := ir2;
            br <= m1(to_integer(unsigned(m1_adr)));
            currentState <= a2;

        else
            bor_adr := ir1(3 downto 0);
            br <= bor(to_integer(unsigned(bor_adr)));
            currentState <= a12;

        end if;

    when a18 =>
        if (bit0 and bit1) = '1' then
            inpr <= data_in;
            currentState <= a9;

        elsif (bit0 and not bit1 and ir1(10)) = '1' then
            m0_adr := pc;
            ir2 <= m0(to_integer(unsigned(m0_adr)));
            currentState <= a7;

        elsif (bit0 and not bit1 and not ir1(10)) = '1' then
            bor_adr := ir1(3 downto 0);
            pc <= bor(to_integer(unsigned(bor_adr)));
            currentState <= a1;
            idle <= '1';

        elsif (not bit0 and ir1(10)) = '1' then
            m0_adr := pc;
            ir2 <= m0(to_integer(unsigned(m0_adr)));
            currentState <= a7;

        elsif (not bit0 and not ir1(10) and bit1) = '1' then
            bor_adr := ir1(3 downto 0);
            br <= bor(to_integer(unsigned(bor_adr)));
            currentState <= a10;

        else
            bor_adr := ir1(3 downto 0);
            ir2 <= bor(to_integer(unsigned(bor_adr)));
            currentState <= a4;

        end if;

    end case;
    end proc_Funcmi;

    begin
        if (rst = '1') then
            br <= (others => '0');
            ext_in <= (others => '0');
            idle <= '0';
            inpr <= (others => '0');
            ir1 <= (others => '0');
            ir2 <= (others => '0');
            pc <= (others => '0');
            ralu <= (others => '0');
            rialu <= (others => '0');

            currentState <= a1;
            idle <= '1';

        elsif (clk'event and clk = '1') then
            idle <= '0';
            proc_Funcmi;
        end if;
    end process;

end ARC_Funcmi;
 

Synthezza logo White 2020.png

PRODUCTS

Synthagate—HLS & RTL

     Synthagate Overview

     What makes Synthagate different

     Examples of High Level and RTL Design

          Synthesis From GUI

          Synthesis From SystemC

          Synthesis From VHDL

Logic Synthesizer

     Overview
     Logic Synthesizer Experiments

     Benchmarks

DESIGN TECHNOLOGY

Algorithmic State machines in HLS

     What is Algorithmic State Machine?

     Time in ASM

     ASM in GUI, System C and VHDL

     ASM Transformations

          Asm Combining

          Asm Minimization

          SubAsm Inclusion

High Level Synthesis

     How Does Synthagate Work

     ASM Creator Short Manual

Synthesis at Register Transfer Level (RTL)

     Data Path

     Control Unit

     Top Design

BOOKS

  

DEMO SERIES

  

COMPANY

     About Us

     Contact US

  

Copyright © 2013 - 2020 Synthezza Corporation. All Rights Reserved

Synthezza logo navy.png