8bit采樣sine波形發生

----------------------------------------------------------------------------------
--
-- 采用ROM結構的8bit采樣 sine波形發生器
--
-- Download from http://www.pld.com.cn
-- The data for each signal shape is stored in a separate memory block.
-- NOTE: At least two samples per the highest output signal frequency are required to produce a valid waveform.
-- The contents of the ROM is synchronously sent to the output in accordance with the selected frequency and phase shift. 
-- The following table shows how to configure the phase shift and signal frequency.
--
-- PR    FR     DATA Description 
-- 1      0   programming phase shift 
-- 0      1   programming work frequency 
-- 
--
-- FR: Specifies how many CLK cycles per a single analog waveform sample are required. 

-----------------------------------------------------------------------------------



------------------------------------------------------------------------------------
-- DESCRIPTION   :  Cascadable Accumulator with Adder
--                  Width : 6
--                  CLK (CLK) active : high
--                  CLR (CLR) active : high
--                  CLR (CLR) type : asynchronous
--                  CE (CE) active : high
--
------------------------------------------------------------------------------------



library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_unsigned.all;

entity generator_acc6 is
 port (
  CLK : in std_logic;
  CE : in std_logic;
  CLR : in std_logic;
  A : in std_logic_vector (5 downto 0);
  Q : out std_logic_vector (5 downto 0)
 );
end entity;



architecture acc_arch of generator_acc6 is
signal REG_Q : std_logic_vector (5 downto 0);
signal TEMP_Q : std_logic_vector (5 downto 0);
begin

 process (REG_Q, A)
 begin
  TEMP_Q <= REG_Q + A;
 end process;

 process(CLK, CLR)
 begin
  if CLR = '1' then
   REG_Q <= "000000";
  elsif rising_edge(CLK) then
   if CE = '1' then
    REG_Q <= TEMP_Q;
   end if;
  end if;
 end process;

 Q <= REG_Q;


end architecture;


------------------------------------------------------------------------------------
-- DESCRIPTION   :  Multiplexer
--                  Code style: used case statement
--                  Width of output terminal: 8
--                  Number of terminals: 1
--                  Output value of all bits when enable not active: '0'
-- 
------------------------------------------------------------------------------------



library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_unsigned.all;

entity generator_mux is
 port (
  I0 : in std_logic_vector (7 downto 0);
  S : in std_logic;
  O : out std_logic_vector (7 downto 0)
 );
end entity;



architecture mux_arch of generator_mux is
begin

 process (S, I0)
 begin
  if (S = '0') then
    O <= I0;
  else
    O <= I1;
  end if;
 end process;

end architecture;

------------------------------------------------------------------------------------
-- DESCRIPTION   :  cascadable Adder
--                  Width: 6
--
-- 
------------------------------------------------------------------------------------


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

entity generator_adder is
 port (
  A, B : in std_logic_vector (5 downto 0);
  Q : out std_logic_vector (5 downto 0)
 );
end entity;

--}} End of automatically maintained section

architecture add_anGen_arch of generator_adder is
begin

 process (A, B)
 begin
  Q <= A + B;
 end process;

end architecture add_anGen_arch;

------------------------------------------------------------------------------------
-- DESCRIPTION   :  Gate: AND
-- 
------------------------------------------------------------------------------------



library IEEE;
use IEEE.std_logic_1164.all;

entity generator_and2 is
 port (
  I0 : in STD_LOGIC;
  I1 : in STD_LOGIC;
  O : out STD_LOGIC
 );
end entity;



architecture and_anGen_arch of generator_and2 is
begin
 O <= I0 and I1;
end architecture and_anGen_arch;

------------------------------------------------------------------------------------
-- DESCRIPTION   :  Name : Analog Generator ROM
-- 
------------------------------------------------------------------------------------



library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;

use IEEE.std_logic_unsigned.all;

entity generator_sin is
    port (
 OE : in STD_LOGIC;
 ADDRESS : in STD_LOGIC_VECTOR(5 downto 0);
 Q : out STD_LOGIC_VECTOR(7 downto 0) );

end generator_sin;



architecture sin_arch of generator_sin is 

begin 
 process(ADDRESS, OE)
 begin
  if (OE = '1') then 
   case (ADDRESS) is 
    when "000000" => Q <= CONV_STD_LOGIC_VECTOR(0,8);
    when "000001" => Q <= CONV_STD_LOGIC_VECTOR(1,8);
    when "000010" => Q <= CONV_STD_LOGIC_VECTOR(3,8);
    when "000011" => Q <= CONV_STD_LOGIC_VECTOR(5,8);
    when "000100" => Q <= CONV_STD_LOGIC_VECTOR(7,8);
    when "000101" => Q <= CONV_STD_LOGIC_VECTOR(10,8);
    when "000110" => Q <= CONV_STD_LOGIC_VECTOR(13,8);
    when "000111" => Q <= CONV_STD_LOGIC_VECTOR(17,8);
    when "001000" => Q <= CONV_STD_LOGIC_VECTOR(21,8);
    when "001001" => Q <= CONV_STD_LOGIC_VECTOR(25,8);
    when "001010" => Q <= CONV_STD_LOGIC_VECTOR(31,8);
    when "001011" => Q <= CONV_STD_LOGIC_VECTOR(37,8);
    when "001100" => Q <= CONV_STD_LOGIC_VECTOR(43,8);
    when "001101" => Q <= CONV_STD_LOGIC_VECTOR(51,8);
    when "001110" => Q <= CONV_STD_LOGIC_VECTOR(60,8);
    when "001111" => Q <= CONV_STD_LOGIC_VECTOR(72,8);
    when "010000" => Q <= CONV_STD_LOGIC_VECTOR(85,8);
    when "010001" => Q <= CONV_STD_LOGIC_VECTOR(100,8);
    when "010010" => Q <= CONV_STD_LOGIC_VECTOR(116,8);
    when "010011" => Q <= CONV_STD_LOGIC_VECTOR(132,8);
    when "010100" => Q <= CONV_STD_LOGIC_VECTOR(148,8);
    when "010101" => Q <= CONV_STD_LOGIC_VECTOR(164,8);
    when "010110" => Q <= CONV_STD_LOGIC_VECTOR(180,8);
    when "010111" => Q <= CONV_STD_LOGIC_VECTOR(196,8);
    when "011000" => Q <= CONV_STD_LOGIC_VECTOR(212,8);
    when "011001" => Q <= CONV_STD_LOGIC_VECTOR(228,8);
    when "011010" => Q <= CONV_STD_LOGIC_VECTOR(234,8);
    when "011011" => Q <= CONV_STD_LOGIC_VECTOR(238,8);
    when "011100" => Q <= CONV_STD_LOGIC_VECTOR(244,8);
    when "011101" => Q <= CONV_STD_LOGIC_VECTOR(248,8);
    when "011110" => Q <= CONV_STD_LOGIC_VECTOR(255,8);
    when "011111" => Q <= CONV_STD_LOGIC_VECTOR(255,8);
    when "100000" => Q <= CONV_STD_LOGIC_VECTOR(255,8);
    when "100001" => Q <= CONV_STD_LOGIC_VECTOR(255,8);
    when "100010" => Q <= CONV_STD_LOGIC_VECTOR(255,8);
    when "100011" => Q <= CONV_STD_LOGIC_VECTOR(248,8);
    when "100100" => Q <= CONV_STD_LOGIC_VECTOR(244,8);
    when "100101" => Q <= CONV_STD_LOGIC_VECTOR(238,8);
    when "100110" => Q <= CONV_STD_LOGIC_VECTOR(234,8);
    when "100111" => Q <= CONV_STD_LOGIC_VECTOR(228,8);
    when "101000" => Q <= CONV_STD_LOGIC_VECTOR(212,8);
    when "101001" => Q <= CONV_STD_LOGIC_VECTOR(196,8);
    when "101010" => Q <= CONV_STD_LOGIC_VECTOR(180,8);
    when "101011" => Q <= CONV_STD_LOGIC_VECTOR(164,8);
    when "101100" => Q <= CONV_STD_LOGIC_VECTOR(148,8);
    when "101101" => Q <= CONV_STD_LOGIC_VECTOR(132,8);
    when "101110" => Q <= CONV_STD_LOGIC_VECTOR(116,8);
    when "101111" => Q <= CONV_STD_LOGIC_VECTOR(100,8);
    when "110000" => Q <= CONV_STD_LOGIC_VECTOR(85,8);
    when "110001" => Q <= CONV_STD_LOGIC_VECTOR(72,8);
    when "110010" => Q <= CONV_STD_LOGIC_VECTOR(60,8);
    when "110011" => Q <= CONV_STD_LOGIC_VECTOR(51,8);
    when "110100" => Q <= CONV_STD_LOGIC_VECTOR(43,8);
    when "110101" => Q <= CONV_STD_LOGIC_VECTOR(37,8);
    when "110110" => Q <= CONV_STD_LOGIC_VECTOR(31,8);
    when "110111" => Q <= CONV_STD_LOGIC_VECTOR(25,8);
    when "111000" => Q <= CONV_STD_LOGIC_VECTOR(21,8);
    when "111001" => Q <= CONV_STD_LOGIC_VECTOR(17,8);
    when "111010" => Q <= CONV_STD_LOGIC_VECTOR(13,8);
    when "111011" => Q <= CONV_STD_LOGIC_VECTOR(10,8);
    when "111100" => Q <= CONV_STD_LOGIC_VECTOR(7,8);
    when "111101" => Q <= CONV_STD_LOGIC_VECTOR(5,8);
    when "111110" => Q <= CONV_STD_LOGIC_VECTOR(3,8);
    when "111111" => Q <= CONV_STD_LOGIC_VECTOR(0,8);
    when others => Q <= "00000000";
   end case;
  else
   Q <= "ZZZZZZZZ"; 
  end if;
 end process;
end architecture sin_arch;

------------------------------------------------------------------------------------
-- DESCRIPTION   :  Flip-flop D type
--                  Width: 6
--                  Clock active: high
--                  Asynchronous clear active: high
--                  Clock enable active: high
-- 
------------------------------------------------------------------------------------


library IEEE;
use IEEE.std_logic_1164.all;

entity generator_reg6 is
 port (
  CLR : in std_logic;
  CE : in std_logic;
  CLK : in std_logic;
  DATA : in std_logic_vector (5 downto 0);
  Q : out std_logic_vector (5 downto 0)
 );
end entity;



architecture reg_arch6 of generator_reg6 is
signal TEMP_Q_0: std_logic_vector (5 downto 0);
begin

 process (CLK, CLR)
 begin

  if CLR = '1' then
   TEMP_Q_0 <= (others => '0');
  elsif rising_edge(CLK) then
   if CE = '1' then
    TEMP_Q_0 <= DATA;
   end if;
  end if;

 end process;

 Q <= TEMP_Q_0;

end architecture;


------------------------------------------------------------------------------------
-- DESCRIPTION   :  Flip-flop D type
--                  Width: 8
--                  Clock active: high
--                  Asynchronous clear active: high
--                  Clock enable active: high
-- 
------------------------------------------------------------------------------------



library IEEE;
use IEEE.std_logic_1164.all;

entity generator_reg8 is
 port (
  CLR : in std_logic;
  CE : in std_logic;
  CLK : in std_logic;
  DATA : in std_logic_vector (7 downto 0);
  Q : out std_logic_vector (7 downto 0)
 );
end entity;



architecture reg_arch8 of generator_reg8 is
signal TEMP_Q_1: std_logic_vector (7 downto 0);
begin

 process (CLK, CLR)
 begin

  if CLR = '1' then
   TEMP_Q_1 <= (others => '0');
  elsif rising_edge(CLK) then
   if CE = '1' then
    TEMP_Q_1 <= DATA;
   end if;
  end if;

 end process;

 Q <= TEMP_Q_1;

end architecture;


------------------------------------------------------------------------------------
-- DESCRIPTION   :  Name : Analog Generator
-- 
------------------------------------------------------------------------------------


library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_unsigned.all;

entity generator is
 port (
  DATA : in std_logic_vector(5 downto 0);
  PR : in std_logic;
  FR : in std_logic;
  CLR : in std_logic;
  CE : in std_logic;
  Q : out std_logic_vector(7 downto 0);
  CLK : in std_logic);

end generator;



architecture generator_arch of generator is 

component generator_acc6
    port(
      A : in STD_LOGIC_VECTOR(5 downto 0);
      CE : in STD_LOGIC;
      CLK : in STD_LOGIC;
      CLR : in STD_LOGIC;
      Q : out STD_LOGIC_VECTOR(5 downto 0));
end component;

component generator_adder
    port (
      A : in STD_LOGIC_VECTOR(5 downto 0);
      B : in STD_LOGIC_VECTOR(5 downto 0);
      Q : out STD_LOGIC_VECTOR(5 downto 0));
end component;

component generator_and2
    port (
      I0 : in STD_LOGIC;
      I1 : in STD_LOGIC;
      O : out STD_LOGIC
);
end component;

component generator_sin
    port (
      OE : in STD_LOGIC;
      ADDRESS : in STD_LOGIC_VECTOR(5 downto 0);
      Q : out STD_LOGIC_VECTOR(7 downto 0) );
end component;

component generator_reg6
    port (
      CE : in STD_LOGIC;
      CLK : in STD_LOGIC;
      CLR : in STD_LOGIC;
      DATA : in STD_LOGIC_VECTOR(5 downto 0);
      Q : out STD_LOGIC_VECTOR(5 downto 0));
end component;

component generator_reg8
    port (
      CE : in STD_LOGIC;
      CLK : in STD_LOGIC;
      CLR : in STD_LOGIC;
      DATA : in STD_LOGIC_VECTOR(7 downto 0);
      Q : out STD_LOGIC_VECTOR(7 downto 0));
end component;

signal CE_U1 : STD_LOGIC;
signal CE_U2 : STD_LOGIC;
signal cur_FR : STD_LOGIC_VECTOR (5 downto 0);
signal cur_PR : STD_LOGIC_VECTOR (5 downto 0);
signal def_FR : STD_LOGIC_VECTOR (5 downto 0);
signal VAL : STD_LOGIC_VECTOR (7 downto 0);
signal VAL1 : STD_LOGIC_VECTOR (7 downto 0);
signal VAL2 : STD_LOGIC_VECTOR (7 downto 0);
signal VAL3 : STD_LOGIC_VECTOR (7 downto 0);
signal VAL4 : STD_LOGIC_VECTOR (7 downto 0);
signal PRFR : STD_LOGIC_VECTOR (5 downto 0);

begin

U1 : generator_reg6
  port map(
       CE => CE_U1,
       CLK => CLK,
       CLR => CLR,
       DATA => DATA,
       Q => cur_PR);

U6 : generator_sin
  port map(
       OE => '1',
       ADDRESS => PRFR,
       Q => VAL4);


VAL <= VAL4;
U2 : generator_reg6
  port map(
       CE => CE_U2,
       CLK => CLK,
       CLR => CLR,
       DATA => DATA,
       Q => def_FR);

U3 : generator_adder
  port map(
       A => cur_PR,
       B => cur_FR,
       Q => PRFR);

U4 : generator_acc6
  port map(
       A => def_FR,
       CE => CE,
       CLR => CLR,
       CLK => CLK,
       Q => cur_FR);

U7 : generator_reg8
  port map(
       CE => CE,
       CLR => CLR,
       CLK => CLK,
       DATA => VAL,
       Q => Q);

U8 : generator_and2
  port map(
       I0 => CE,
       I1 => FR,
       O => CE_U2);

U9 : generator_and2
  port map(
       I0 => CE,
       I1 => PR,
       O => CE_U1);

end architecture generator_arch;