EmbDev.net

Forum: FPGA, VHDL & Verilog HELP call VHDL code to other VHDL code


Du wurdest von Mikrocontroller.net auf diese Seite weitergeleitet. Zurück zu Mikrocontroller.net
HELP call VHDL code to other VHDL code
von Vicky V. (viduka)

Rate this post
• ▲ useful
▼ not useful 
Hi.. i need help to call 1 VHDL code to other VHDL code..

i have 2 VHDL code (Rotary_switch and buzzer).. that program work well 
and i can run it at FPGA.. and now i need to call buzzer.vhdl at 
rotary.vhdl. but i dont know how to do that..

this is my vhdl code for rotary_switch
1
library IEEE;

2
use IEEE.STD_LOGIC_1164.ALL;

3
use IEEE.STD_LOGIC_ARITH.ALL;

4
use IEEE.STD_LOGIC_UNSIGNED.ALL;

5
6
-- Uncomment the following library declaration if using

7
-- arithmetic functions with Signed or Unsigned values

8
--use IEEE.NUMERIC_STD.ALL;

9
10
-- Uncomment the following library declaration if instantiating

11
-- any Xilinx primitives in this code.

12
--library UNISIM;

13
--use UNISIM.VComponents.all;

14
15
entity main is

16
port(  clk: in STD_LOGIC;

17
    rot_a: in STD_LOGIC;

18
    rot_b : in STD_LOGIC;

19
    rot_center : in STD_LOGIC;

20
    J4 : out  STD_LOGIC;

21
    led : out STD_LOGIC_VECTOR (7 downto 0):="00000000");

22
end main;

23
24
architecture Behavioral of main is

25
26
signal rotary_a_in: std_logic;

27
signal rotary_b_in: std_logic;

28
signal rotary_q1: std_logic;

29
signal rotary_q2: std_logic;

30
signal rotary_in: std_logic_vector(1 downto 0);

31
signal rotary_event: std_logic;

32
signal rotary_left:std_logic;

33
signal delay_rotary_q1:std_logic;

34
signal center_flag:std_logic;

35
36
begin

37
38
rotary_a_in <= rot_a;

39
rotary_b_in <= rot_b;

40
41
rotary_filter: process(clk)

42
begin

43
if clk'event and clk='1' then

44
rotary_in <= rotary_b_in & rotary_a_in;

45
46
case rotary_in is

47
when "00" => rotary_q1 <= '0';

48
rotary_q2 <= rotary_q2;

49
when "01" => rotary_q1 <= rotary_q1;

50
rotary_q2 <= '0';

51
when "10" => rotary_q1 <= rotary_q1;

52
rotary_q2 <= '1';

53
when "11" => rotary_q1 <= '1';

54
rotary_q2 <= rotary_q2;

55
when others => rotary_q1 <= rotary_q1;

56
rotary_q2 <= rotary_q2;

57
end case;

58
end if;

59
end process rotary_filter;

60
61
direction: process(clk)

62
begin

63
if clk'event and clk='1' then

64
65
delay_rotary_q1 <= rotary_q1;

66
if rotary_q1='1' and delay_rotary_q1='0' then

67
rotary_event <= '1';

68
rotary_left <= rotary_q2;

69
else

70
rotary_event <= '0';

71
rotary_left <= rotary_left;

72
end if;

73
end if;

74
end process direction;

75
76
led_switch: process(clk,rotary_event,rotary_left)

77
78
variable i : integer:=8;

79
variable index : integer;

80
begin

81
if clk'event and clk='1' then

82
if rotary_event='1' and rotary_left='0' then --left

83
index :=i mod 8;

84
led(index)<='1';

85
if index=3 then

86
J4<='1';

87
--I WANT CALL MY BUZZER.VHDL IN HERE. SO ITS MEAN WHEN INDEX=3 I WANT MY BUZZER ON..

88
end if;

89
i:=i+1;

90
if i=8 then

91
i:=7;

92
end if;

93
end if;

94
if rotary_event='1' and rotary_left='1' then --right

95
if i=8 then

96
i:=7;

97
end if;

98
index :=i mod 8;

99
led(index)<='0';

100
i:=i-1;

101
if index=3 then

102
J4<='0';

103
end if;

104
if i=0 then

105
i:=1;

106
led(0)<='1';

107
end if;

108
end if;

109
end if;

110
end process led_switch;

111
112
process(rot_center)

113
begin

114
if (rot_center='1') then

115
center_flag<='1';

116
elsif (rot_center='0') then

117
center_flag<='0';

118
end if;

119
end process;

120
121
end Behavioral;


this is my vhdl code for buzzer
1
library IEEE;

2
use IEEE.STD_LOGIC_1164.ALL;

3
use IEEE.STD_LOGIC_ARITH.ALL;

4
use IEEE.STD_LOGIC_UNSIGNED.ALL;

5
6
ENTITY buzzer IS

7
   PORT (

8
      clk  : IN std_logic;   

9
      rst  : IN std_logic;   

10
      out_bit  : OUT std_logic);   

11
END buzzer;

12
13
ARCHITECTURE arch OF buzzer IS

14
15
16
   SIGNAL clk_div1   :  std_logic_vector(3 DOWNTO 0);  

17
   SIGNAL clk_div2   :  std_logic_vector(12 DOWNTO 0); 

18
   SIGNAL cnt        :  std_logic_vector(21 DOWNTO 0);  

19
   SIGNAL state      :  std_logic_vector(2 DOWNTO 0); 

20
   CONSTANT  duo   :  std_logic_vector(12 DOWNTO 0) :="0111011101110";     

21
   CONSTANT  lai  :  std_logic_vector(12 DOWNTO 0) := "0110101001101";    

22
   CONSTANT  mi   :  std_logic_vector(12 DOWNTO 0) := "0101111011010";    

23
   CONSTANT  fa    :  std_logic_vector(12 DOWNTO 0) := "0101100110001";    

24
   CONSTANT  suo   :  std_logic_vector(12 DOWNTO 0) := "0100111110111";    

25
   CONSTANT  la    :  std_logic_vector(12 DOWNTO 0) := "0100011100001";    

26
   CONSTANT  xi    :  std_logic_vector(12 DOWNTO 0) := "0011111101000";    

27
   CONSTANT  duo1   :  std_logic_vector(12 DOWNTO 0) := "0011101110111";   

28
   SIGNAL out_bit_tmp :std_logic; 

29
30
BEGIN

31
   out_bit<=out_bit_tmp;

32
   PROCESS(clk,rst)

33
   BEGIN

34
       IF (NOT rst = '1') THEN

35
         clk_div1 <= "0000";    

36
      ELSif(clk'event and clk='1')then

37
         IF (clk_div1 /= "1100") THEN

38
            clk_div1 <= clk_div1 + "0001";    

39
         ELSE

40
            clk_div1 <= "0000";    

41
         END IF;

42
      END IF;

43
   END PROCESS;

44
45
   PROCESS(clk,rst)

46
   BEGIN

47
    

48
      IF (NOT rst = '1') THEN

49
         clk_div2 <= "0000000000000";    

50
         state <= "000";    

51
         cnt <= "0000000000000000000000";    

52
         out_bit_tmp <= '0';    

53
      ELSif(clk'event and clk='1')then

54
         IF (clk_div1 = "1001") THEN

55
            CASE state IS

56
               WHEN "000" =>

57
                        cnt <= cnt + "0000000000000000000001";    

58
                        IF (cnt = "1111111111111111111111") THEN

59
                           state <= "001";    

60
                        END IF;

61
                        IF (clk_div2 /= duo) THEN

62
                           clk_div2 <= clk_div2 + "0000000000001";    

63
                        ELSE

64
                           clk_div2 <= "0000000000000";    

65
                           out_bit_tmp <= NOT out_bit_tmp;    

66
                        END IF;

67
               WHEN "001" =>  

68
                        cnt <= cnt + "0000000000000000000001";    

69
                        IF (cnt = "1111111111111111111111") THEN

70
                           state <= "010";    

71
                        END IF;

72
                        IF (clk_div2 /=lai) THEN

73
                           clk_div2 <= clk_div2 + "0000000000001";    

74
                        ELSE

75
                           clk_div2 <= "0000000000000";    

76
                           out_bit_tmp <= NOT out_bit_tmp;    

77
                        END IF;

78
               WHEN "010" => 

79
                        cnt <= cnt + "0000000000000000000001";    

80
                        IF (cnt = "1111111111111111111111") THEN

81
                           state <= "011";    

82
                        END IF;

83
                        IF (clk_div2 /=mi) THEN

84
                           clk_div2 <= clk_div2 + "0000000000001";    

85
                        ELSE

86
                           clk_div2 <= "0000000000000";    

87
                           out_bit_tmp <= NOT out_bit_tmp;    

88
                        END IF;

89
               WHEN "011" =>  

90
                        cnt <= cnt + "0000000000000000000001";    

91
                        IF (cnt = "1111111111111111111111") THEN

92
                           state <= "100";    

93
                        END IF;

94
                        IF (clk_div2 /=fa) THEN

95
                           clk_div2 <= clk_div2 + "0000000000001";    

96
                        ELSE

97
                           clk_div2 <= "0000000000000";    

98
                           out_bit_tmp <= NOT out_bit_tmp;    

99
                        END IF;

100
               WHEN "100" =>   

101
                        cnt <= cnt + "0000000000000000000001";    

102
                        IF (cnt = "1111111111111111111111") THEN

103
                           state <= "101";    

104
                        END IF;

105
                        IF (clk_div2 /=suo) THEN

106
                           clk_div2 <= clk_div2 + "0000000000001";    

107
                        ELSE

108
                           clk_div2 <= "0000000000000";    

109
                           out_bit_tmp <= NOT out_bit_tmp;    

110
                        END IF;

111
               WHEN "101" => 

112
                        cnt <= cnt + "0000000000000000000001";    

113
                        IF (cnt = "1111111111111111111111") THEN

114
                           state <= "110";    

115
                        END IF;

116
                        IF (clk_div2 /= la) THEN

117
                           clk_div2 <= clk_div2 + "0000000000001";    

118
                        ELSE

119
                           clk_div2 <= "0000000000000";    

120
                           out_bit_tmp <= NOT out_bit_tmp;    

121
                        END IF;

122
               WHEN "110" => 

123
                        cnt <= cnt + "0000000000000000000001";    

124
                        IF (cnt = "1111111111111111111111") THEN

125
                           state <= "111";    

126
                        END IF;

127
                        IF (clk_div2 /= xi) THEN

128
                           clk_div2 <= clk_div2 + "0000000000001";    

129
                        ELSE

130
                           clk_div2 <= "0000000000000";    

131
                           out_bit_tmp <= NOT out_bit_tmp;    

132
                        END IF;

133
               WHEN "111" => 

134
                        cnt <= cnt + "0000000000000000000001";    

135
                        IF (cnt = "1111111111111111111111") THEN

136
                           state <= "000";    

137
                        END IF;

138
                        IF (clk_div2 /= duo1) THEN

139
                           clk_div2 <= clk_div2 + "0000000000001";    

140
                        ELSE

141
                           clk_div2 <= "0000000000000";    

142
                           out_bit_tmp <= NOT out_bit_tmp;    

143
                        END IF;

144
               WHEN OTHERS =>

145
                        NULL;

146
               

147
            END CASE;

148
         END IF;

149
      END IF;

150
   END PROCESS;

151
152
END arch;


anyone can help me to do it.. or explain it how to call buzzer.vhdl at 
my rotary switch when i need to turn on my buzzer.
1
if index=3 then

2
J4<='1';

3
--I WANT CALL MY BUZZER.VHDL IN HERE. SO ITS MEAN WHEN INDEX=3 I WANT MY BUZZER ON..

4
end if;


I'm sorry if my english not good.

  


  




  

    Report post Edit Move Thread sperren Anmeldepflicht aktivieren Anpinnen Delete topic Thread mit anderem zusammenführen Quote selected text Reply Reply with quote
  







      

      



  

    Re: HELP call VHDL code to other VHDL code
  


  

    

      von
      
        lkmiller (Guest)
      
      


      
    


    

      
    

    

    

  
  


  

  Rate this post
  

  •
  
  ▲ useful 
  

  ▼ not useful 
  		
  

  


  

      
> and now i need to call buzzer.vhdl at rotary.vhdl
With VHDL you are not programming a piece of software, where one 
module calls another. You are doing a hardware description, and so you 
must describe a wiring inside a chip (CPLD/FPGA). And therfore you do 
not call another module, but you instantiate a component and connect it 
to your top level module.
This task is a very common, and so you can find the procedure easily in 
any VHDL book.

> this is my vhdl code for rotary_switch
I don't want to read a VHDL decription formatted in such a bad manner. 
But in there you must do something like that:
1
architecture Behavioral of main is

2
3
signal rotary_a_in: std_logic;

4
signal rotary_b_in: std_logic;

5
signal rotary_q1: std_logic;

6
signal rotary_q2: std_logic;

7
signal rotary_in: std_logic_vector(1 downto 0);

8
signal rotary_event: std_logic;

9
signal rotary_left:std_logic;

10
signal delay_rotary_q1:std_logic;

11
signal center_flag:std_logic;

12
13
component buzzer IS

14
   PORT (

15
      clk  : IN std_logic;   

16
      rst  : IN std_logic;   

17
      out_bit  : OUT std_logic);   

18
END component;

19
20
begin

21
22
buzz : buzzer 

23
      PORT MAP ( clk  => clk, rst => rst, out_bit => buzzer_pin);   

24
END component;

25
26
rotary_a_in <= rot_a;

27
rotary_b_in <= rot_b;


But as far i can see, the buzzer code is doing something very stupid in 
a very difficult way...

> or explain it how to call buzzer.vhdl at
> my rotary switch when i need to turn on my buzzer.
You do not call the code, but you can set a signal to enable buzzing. 
And then the buzzer will buzz as long as the enable signal is active.

BTW:
>              cnt <= cnt + "0000000000000000000001";
>              IF (cnt = "1111111111111111111111") THEN
I would do this so:
>              cnt <= cnt + '1';
>              IF (cnt = (others=>'1') THEN
Thats much easier to read.

  


  




  

    Report post Edit Delete Quote selected text Reply Reply with quote
  







      

      

      

      


    

    

       Watch this topic

      |
         Disable multi-page view

    

        


Please log in before posting. Registration is free and takes only a minute.



  Existing account

  


  
  

  
    

      

        
          
        
        
          
        
      

      

        
          
        
        
          
        
      

    


    
    
    





  Do you have a Google/GoogleMail account? No registration required!

  Log in with Google account
  





  No account? Register here.