STD_LOGIC_VECTOR --> 7 SEGMENT DISPLAY

Bernd Gast #2813157
Lesenswert?
• ▲
▼ 
Hi,

ich bekomme als Eingangssignal ein 12 Bit STD_LOGIC_VECTOR. Das Ergebnis 
möchte ich im Dezimalen (0-9) auf einer 4 stelligen 7 Segment Anzeige 
anzeigen lassen.

Gibt es dafür ein fertiges Desgin?

Falls nein, welche Schritte müssen realisiert werden?

Ich habe beispielsweise folgenden Dekoder in einer Digilent FPGA Board 
Beschreibung gefunden:

1
library IEEE;

2
use IEEE.STD_LOGIC_1164.all;

3
entity hex7seg is

4
port(

5
x : in STD_LOGIC_VECTOR(3 downto 0);

6
a_to_g : out STD_LOGIC_VECTOR(6 downto 0)

7
);

8
end hex7seg;

9
architecture hex7seg of hex7segbis

10
begin

11
process(x)

12
begin

13
case x is

14
when X"0" => a_to_g <= "0000001"; --0

15
when X"1" => a_to_g <= "1001111"; --1

16
when X"2" => a_to_g <= "0010010"; --2

17
when X"3" => a_to_g <= "0000110"; --3

18
when X"4" => a_to_g <= "1001100"; --4

19
when X"5" => a_to_g <= "0100100"; --5

20
when X"6" => a_to_g <= "0100000"; --6

21
when X"7" => a_to_g <= "0001101"; --7

22
when X"8" => a_to_g <= "0000000"; --8

23
when X"9" => a_to_g <= "0000100"; --9

24
when X"A" => a_to_g <= "0001000"; --A

25
when X"B" => a_to_g <= "1100000"; --b

26
when X"C" => a_to_g <= "0110001"; --C

27
when X"D" => a_to_g <= "1000010"; --d

28
when X"E" => a_to_g <= "0110000"; --E

29
when others => a_to_g <= "0111000"; --F

30
end case;

31
end process;

32
end hex7seg;



x wäre dann das anzuzeigenen Zeichen und a_to_g das Signal an die 
Segmente bzw. an das Segment.

Ich verstehe noch nicht ganz, wie ich den 12 Bit Wert an den Dekoder 
sende, damit er diesen richig interpretieren kann. Ich habe 
beispielsweise den Wert 2154, was im Binären 100001101010 entspricht. 
Auf der letzen Anzeige müsste ja die 4 stehen, auf der vorletzen die 5, 
dann die 1 und auf dem ersten Segment die 2. Diese Werte sind ja 4 Bit 
groß und werden an den EIngang des Dekoders gesendet. Dieser gibt dann 
die kodierte Information für die Segmente an.

Den a_to_g Vektor würde ich ja dann im Pin Planer oder in der UCF Datei 
mit den IOB's des Boards verknüpfen.

Jedoch wie realisiere ich das mit meinem 12 Bit Wert. Ich habe das 
Prinzip noch nicht richtig verstanden.

Benötige ich für die 4 Segmente auch 4 Dekoder?


Dankeschön
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Lothar M. Moderator (Firma: Titel) Persönliche Seite #2813175
Lesenswert?
• ▲
▼ 
Bernd schrieb:
> Gibt es dafür ein fertiges Desgin?
Vermutlich schon. Aber evtl. nicht "so zum Runterladen"...

> Falls nein, welche Schritte müssen realisiert werden?
Du musst erst mal dein 12-Bit Vektor (0...1023) in die einzenlen 
Dezimalstellen umwandeln. Dafür bietet sich ein Binär-nach-BCD Wandler 
an.
http://www.lothar-miller.de/s9y/archives/34-Vektor-nach-BCD.html
http://www.lothar-miller.de/s9y/categories/44-BCD-Umwandlung

> Benötige ich für die 4 Segmente auch 4 Dekoder?
Ja. Die kommen dann an die 4 Dezimalstellen aus dem BCD Wandler...
Oder auch nein, wenn die 4 Stück 7-Segmentanzeigen parallel 
angeschlossen sind und gemultiplext werden müssen...
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Bernd Gast #2813283
Lesenswert?
• ▲
▼ 
Ich habe jetzt den Vector2BCD implementiert. Ich erhalte dann einen 16 
Bit Wert, der die 4 x 4 Bit Information für die Segmente benötigt.

Nun würde ich mir also 4 Signale erzeugen, die jeweils die 4 Bit Werte 
übernehmen. Also in der Art und Weise:

signal segm1 : std_logic_vector(3 downto 0);
signal segm2 : std_logic_vector(3 downto 0);
signal segm3 : std_logic_vector(3 downto 0);
signal segm4 : std_logic_vector(3 downto 0);

begin

process(clk, busy)
begin
if rising_edge(clk) then
 if (busy = '0') then
    segm1 <= bcd(15 downto 12);
    segm2 <= bcd(11 downto 8);
    segm3 <= bcd(7 downto 4);
    segm4 <= bcd(3 downto 0);
  end if;
end if;
end process;



segm1, segm2, segm3, segm4 würde ich dann jeweils an die hex7seg 
Componente anlegen und den Ausgang der hex7seg Komponente jeweils an die 
Schnittstelle zu den LED bzw. Segmenten.


Kann ich das so machen?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Bernd Gast #2813444
Lesenswert?
• ▲
▼ 
Irgendwie tue mich irgendwie schwer mit der Umsetzung.

Bevor gemultiplexed wird, müssen doch die 4 Signalwerte der jeweiligen 
Anzeigen erst einmal separiert werden, wenn ich das richtig verstehe.
Dann gehen die 4 Werte (a 4 bit) auf den Multiplexer + die 4 
Anodensignale, welche das jeweilge Anzeigeelement ansprechen.

Und dann in einer Refreshzeit von 1 ms bis 16 ms beispielsweise wird der 
erste Signalwert mit der 1 Anode, der zweite Signalwert mit der zweiten 
Anode, der dritte mit der Dritten und der Vierte mit der vierte Anode 
ausgegeben werden.

Ist das korrekt?

Das kann doch nicht so schwer sein :-/
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Bernd Gast #2814440
Lesenswert?
• ▲
▼ 
Guten Morgen,

ich habe jetzt folgendes versucht:

TOP LEVEL DESIGN

1
library IEEE;

2
use IEEE.STD_LOGIC_1164.ALL;

3
use IEEE.NUMERIC_STD.ALL;

4


5
-- Uncomment the following library declaration if using

6
-- arithmetic functions with Signed or Unsigned values

7
--use IEEE.NUMERIC_STD.ALL;

8


9
-- Uncomment the following library declaration if instantiating

10
-- any Xilinx primitives in this code.

11
--library UNISIM;

12
--use UNISIM.VComponents.all;

13


14
entity test_max is

15
    Port ( max_in : in  STD_LOGIC_VECTOR (11 downto 0);

16
      --     max_out : out  STD_LOGIC_VECTOR (11 downto 0);

17
      --  bcd_4_out : out STD_LOGIC_VECTOR( 3 downto 0);

18
        anod      : out std_logic_vector(3 downto 0);

19
        a2g       : out std_logic_vector(6 downto 0);

20
           clk : in  STD_LOGIC);

21
end test_max;

22


23
architecture Behavioral of test_max is

24


25


26
component Vector2BCD

27
Port (     clk      : in  std_logic;

28
           vector   : in  std_logic_vector (11 downto 0);

29
           start    : in  std_logic;

30
           busy     : out std_logic;

31
           overflow : out std_logic;

32
           bcd      : out std_logic_vector (15 downto 0));

33
end component;

34


35


36


37
--component hex7seg

38
--Port (     x         : in  STD_LOGIC_VECTOR (3 downto 0);

39
--           a_to_g    : out  STD_LOGIC_VECTOR (6 downto 0));

40
--end component;

41


42


43


44
component multiplexer

45
Port (     clk       : in STD_LOGIC;

46
          seg1      : in STD_LOGIC_VECTOR (6 downto 0);

47
        seg2      : in STD_LOGIC_VECTOR (6 downto 0);

48
        seg3      : in STD_LOGIC_VECTOR (6 downto 0);

49
        seg4      : in STD_LOGIC_VECTOR (6 downto 0);        

50
           seg_out   : out STD_LOGIC_VECTOR(6 downto 0);

51
        an        : out STD_LOGIC_VECTOR(3 downto 0));

52
end component;

53


54


55
------------ SIGNALE ------------------------

56


57
signal busy  : STD_LOGIC;

58
signal bcd   : std_logic_vector(15 downto 0); 

59


60
signal sel : STD_LOGIC_VECTOR (1 downto 0);

61
--signal x_bcd : STD_LOGIC_VECTOR (3 downto 0);

62
signal counter : natural range 999999 downto 0;

63


64
signal clk2 : std_logic;

65


66


67


68
signal segm1 : STD_LOGIC_VECTOR(3 downto 0);

69
signal segm2 : STD_LOGIC_VECTOR(3 downto 0);

70
signal segm3 : STD_LOGIC_VECTOR(3 downto 0);

71
signal segm4 : STD_LOGIC_VECTOR(3 downto 0);

72


73
signal a_to_g1 : STD_LOGIC_VECTOR(6 downto 0);

74
signal a_to_g2 : STD_LOGIC_VECTOR(6 downto 0);

75
signal a_to_g3 : STD_LOGIC_VECTOR(6 downto 0);

76
signal a_to_g4 : STD_LOGIC_VECTOR(6 downto 0);

77


78
----------------------------------------------

79


80


81
begin

82


83
---------------- SCHRITT 1 ---------------

84


85
Comp_BCD : Vector2BCD port map ( clk => clk,

86
                  vector => max_in,

87
                  start => '1',

88
                  busy => busy,

89
                  overflow => open,

90
                  bcd => bcd);

91
--------------------------------------------                  

92
                  

93
--SEG : hex7seg port map (  x => x_bcd,

94
--                  a_to_g => a2g

95
--                );                  

96
--                  

97
--

98
--

99


100
COMP_Multiplexer : multiplexer port map ( clk => clk2,

101
                            seg1 => a_to_g1 ,

102
                            seg2 => a_to_g2,

103
                            seg3 => a_to_g3 ,

104
                            seg4 => a_to_g4,

105
                            seg_out => a2g,

106
                            an => anod);

107


108


109


110
------- SCHRITT 2 ----------

111


112
segm1 <= bcd(15 downto 12);

113
segm2 <= bcd(11 downto 8);

114
segm3 <= bcd(7 downto 4);

115
segm4 <= bcd(3 downto 0);  

116


117
------------------------------ 

118


119


120


121
----- 50 HZ Generator ------

122


123
process(clk)

124
begin

125
  if (counter = 999999) then

126
    counter <= 0;

127
  else

128
    counter <= counter + 1;

129
  end if;

130
  

131
  if counter < 500000 then

132
    clk2 <= '1';

133
  else

134
    clk2 <= '0'; 

135
  end if;

136
end process;

137


138


139


140


141


142


143
process (segm1)

144
begin

145
case segm1 is

146
when X"0" => a_to_g1 <= "0000001"; --0

147
when X"1" => a_to_g1 <= "1001111"; --1

148
when X"2" => a_to_g1 <= "0010010"; --2

149
when X"3" => a_to_g1 <= "0000110"; --3

150
when X"4" => a_to_g1 <= "1001100"; --4

151
when X"5" => a_to_g1 <= "0100100"; --5

152
when X"6" => a_to_g1 <= "0100000"; --6

153
when X"7" => a_to_g1 <= "0001101"; --7

154
when X"8" => a_to_g1 <= "0000000"; --8

155
when X"9" => a_to_g1 <= "0000100"; --9

156
when X"A" => a_to_g1 <= "0001000"; --A

157
when X"B" => a_to_g1 <= "1100000"; --b

158
when X"C" => a_to_g1 <= "0110001"; --C

159
when X"D" => a_to_g1 <= "1000010"; --d

160
when X"E" => a_to_g1 <= "0110000"; --E

161
when others => a_to_g1 <= "0111000"; --F

162
end case;

163
end process;

164


165


166


167


168
process (segm2)

169
begin

170
case segm2 is

171
when X"0" => a_to_g2 <= "0000001"; --0

172
when X"1" => a_to_g2 <= "1001111"; --1

173
when X"2" => a_to_g2 <= "0010010"; --2

174
when X"3" => a_to_g2 <= "0000110"; --3

175
when X"4" => a_to_g2 <= "1001100"; --4

176
when X"5" => a_to_g2 <= "0100100"; --5

177
when X"6" => a_to_g2 <= "0100000"; --6

178
when X"7" => a_to_g2 <= "0001101"; --7

179
when X"8" => a_to_g2 <= "0000000"; --8

180
when X"9" => a_to_g2 <= "0000100"; --9

181
when X"A" => a_to_g2 <= "0001000"; --A

182
when X"B" => a_to_g2 <= "1100000"; --b

183
when X"C" => a_to_g2 <= "0110001"; --C

184
when X"D" => a_to_g2 <= "1000010"; --d

185
when X"E" => a_to_g2 <= "0110000"; --E

186
when others => a_to_g2 <= "0111000"; --F

187
end case;

188
end process;

189


190


191


192
process (segm3)

193
begin

194
case segm3 is

195
when X"0" => a_to_g3 <= "0000001"; --0

196
when X"1" => a_to_g3 <= "1001111"; --1

197
when X"2" => a_to_g3 <= "0010010"; --2

198
when X"3" => a_to_g3 <= "0000110"; --3

199
when X"4" => a_to_g3 <= "1001100"; --4

200
when X"5" => a_to_g3 <= "0100100"; --5

201
when X"6" => a_to_g3 <= "0100000"; --6

202
when X"7" => a_to_g3 <= "0001101"; --7

203
when X"8" => a_to_g3 <= "0000000"; --8

204
when X"9" => a_to_g3 <= "0000100"; --9

205
when X"A" => a_to_g3 <= "0001000"; --A

206
when X"B" => a_to_g3 <= "1100000"; --b

207
when X"C" => a_to_g3 <= "0110001"; --C

208
when X"D" => a_to_g3 <= "1000010"; --d

209
when X"E" => a_to_g3 <= "0110000"; --E

210
when others => a_to_g3 <= "0111000"; --F

211
end case;

212
end process;

213


214


215
process (segm4)

216
begin

217
case segm4 is

218
when X"0" => a_to_g4 <= "0000001"; --0

219
when X"1" => a_to_g4 <= "1001111"; --1

220
when X"2" => a_to_g4 <= "0010010"; --2

221
when X"3" => a_to_g4 <= "0000110"; --3

222
when X"4" => a_to_g4 <= "1001100"; --4

223
when X"5" => a_to_g4 <= "0100100"; --5

224
when X"6" => a_to_g4 <= "0100000"; --6

225
when X"7" => a_to_g4 <= "0001101"; --7

226
when X"8" => a_to_g4 <= "0000000"; --8

227
when X"9" => a_to_g4 <= "0000100"; --9

228
when X"A" => a_to_g4 <= "0001000"; --A

229
when X"B" => a_to_g4 <= "1100000"; --b

230
when X"C" => a_to_g4 <= "0110001"; --C

231
when X"D" => a_to_g4 <= "1000010"; --d

232
when X"E" => a_to_g4<= "0110000"; --E

233
when others => a_to_g4 <= "0111000"; --F

234
end case;

235
end process;

236


237


238


239


240


241


242


243
end Behavioral;








Hier die Vector2BCD von Lothar Miller.


1
library IEEE;

2
use IEEE.STD_LOGIC_1164.ALL;

3
use IEEE.NUMERIC_STD.ALL;

4


5
entity Vector2BCD is

6
    Generic ( stellen : natural := 4;   -- Anzahl BCD-Stellen

7
              breite  : natural := 12); -- Breite des Eingangsvektors

8
    Port ( clk      : in  std_logic;

9
           vector   : in  std_logic_vector (breite-1 downto 0);

10
           start    : in  std_logic;

11
           busy     : out std_logic;

12
           overflow : out std_logic;

13
           bcd      : out std_logic_vector (stellen*4-1 downto 0));

14
end Vector2BCD;

15


16
architecture Behavioral of Vector2BCD is            -- Beispiel: Stellen=3, Breite=8

17
type states is (idle,calc);                          -- 2 1111   1111   11

18
signal state : states := idle;                       -- 0 9876   5432   1098   76543210

19
signal sr : unsigned (stellen*4+breite downto 0);  -- O BCDh & BCDz & BCDe & VVVVVVVV

20
signal bitcnt : integer range 0 to breite;

21
signal ovl : std_logic;

22
begin

23
   process begin

24
      wait until rising_edge(clk);

25
      busy <= '0';

26
      case state is

27
         when idle => 

28
            sr <= (others=>'0');

29
            sr(breite-1 downto 0) <= unsigned(vector);

30
            bitcnt <= breite;

31
            if (start='1') then 

32
               busy <= '1';

33
               ovl  <= '0';

34
               state<=calc;

35
            end if;

36
                      

37
         when calc => 

38
            if (bitcnt/=0) then 

39
               bitcnt <= bitcnt-1; -- bearbeitete Bits mitzählen

40
               busy <= '1';

41
               sr <= sr(stellen*4+breite-1 downto 0)&'0';         -- einmnal komplett durchschieben

42
               for i in 0 to stellen-1 loop 

43
                  if (sr(i*4+breite+3 downto i*4+breite)>4) then  -- falls nötig: BCD-Übertrag + schieben

44
                     sr(i*4+breite+4 downto i*4+breite+1) <= sr(i*4+breite+3 downto i*4+breite)+3;

45
                  end if;

46
               end loop;

47
               if (sr(sr'high)='1') then  ovl <= '1'; end if;

48
            else 

49
               state <= idle;

50
               bcd   <= std_logic_vector(sr(stellen*4+breite-1 downto breite));

51
               if(ovl='1' or sr(sr'high)='1') then overflow <= '1';

52
               else                                overflow <= '0';

53
               end if;

54
            end if;

55
            

56
      end case;

57
   end process;

58
end Behavioral;














MULTIPLEXER

1
library IEEE;

2
use IEEE.STD_LOGIC_1164.ALL;

3
use IEEE.NUMERIC_STD.ALL;

4


5
-- Uncomment the following library declaration if using

6
-- arithmetic functions with Signed or Unsigned values

7
--use IEEE.NUMERIC_STD.ALL;

8


9
-- Uncomment the following library declaration if instantiating

10
-- any Xilinx primitives in this code.

11
--library UNISIM;

12
--use UNISIM.VComponents.all;

13


14
entity multiplexer is

15
    Port ( clk       : in STD_LOGIC;

16
          seg1      : in STD_LOGIC_VECTOR (6 downto 0);

17
        seg2      : in STD_LOGIC_VECTOR (6 downto 0);

18
        seg3      : in STD_LOGIC_VECTOR (6 downto 0);

19
        seg4      : in STD_LOGIC_VECTOR (6 downto 0);        

20
           seg_out   : out STD_LOGIC_VECTOR(6 downto 0);

21
        an        : out STD_LOGIC_VECTOR(3 downto 0));

22
end multiplexer;

23


24
architecture Behavioral of multiplexer is

25


26


27
signal error: std_logic_vector(6 downto 0):= "0000000";

28
signal sel  : UNSIGNED (1 downto 0) := "00";

29
begin

30


31


32
process(clk) 

33
begin

34
  if rising_edge(clk) then

35
    if sel = "11" then

36
      sel <= "00";

37
    else

38
      sel <= sel + "01";

39
    end if;

40
  end if;

41
end process;

42


43


44


45
process (clk) is

46
   begin

47
      case Sel is

48
         when "00"  => seg_out <= seg1;      

49
      when "01"  => seg_out <= seg2;    

50
         when "10"  => seg_out <= seg3;    

51
         when "11"  => seg_out <= seg4;        

52
      

53
         when others => seg_out <= error;

54
      end case;

55
   end process;

56


57


58
process (clk) is

59
   begin

60
      case Sel is

61
         when "00"  => an <= "1110";      -- 0 = Activ , 1 = low

62
      when "01"  => an <= "1101";    

63
         when "10"  => an <= "1011";    

64
         when "11"  => an <= "0111";        

65
      

66
         when others => an <= "0000";

67
      end case;

68
   end process;

69


70


71


72


73


74


75
end Behavioral;



Das war nun das komplette Design. Im folgenden erläutere ich kurz, wie 
ich es mir gedacht habe.


Ich lese erst mit LM Vector2BCD Algorithmus den 12 Bit Vektor ein und 
extrahiere mir die 4 * 4 Bit BCD Werte.


Portmaping der Komponente Vector2BCD
1
Comp_BCD : Vector2BCD port map ( clk => clk,

2
                  vector => max_in,

3
                  start => '1',

4
                  busy => busy,

5
                  overflow => open,

6
                  bcd => bcd);


Start =>'1' wird wohl nicht funktionieren: Aber dazu später mehr.

Hier extrahiere ich mir die relevanten BCD Werte
1
segm1 <= bcd(15 downto 12);

2
segm2 <= bcd(11 downto 8);

3
segm3 <= bcd(7 downto 4);

4
segm4 <= bcd(3 downto 0);


Hier definiere ich die Elemente für die 7 Segment Anzeige:

1
process (segm1)

2
begin

3
case segm1 is

4
when X"0" => a_to_g1 <= "0000001"; --0

5
when X"1" => a_to_g1 <= "1001111"; --1

6
when X"2" => a_to_g1 <= "0010010"; --2

7
when X"3" => a_to_g1 <= "0000110"; --3

8
when X"4" => a_to_g1 <= "1001100"; --4

9
when X"5" => a_to_g1 <= "0100100"; --5

10
when X"6" => a_to_g1 <= "0100000"; --6

11
when X"7" => a_to_g1 <= "0001101"; --7

12
when X"8" => a_to_g1 <= "0000000"; --8

13
when X"9" => a_to_g1 <= "0000100"; --9

14
when X"A" => a_to_g1 <= "0001000"; --A

15
when X"B" => a_to_g1 <= "1100000"; --b

16
when X"C" => a_to_g1 <= "0110001"; --C

17
when X"D" => a_to_g1 <= "1000010"; --d

18
when X"E" => a_to_g1 <= "0110000"; --E

19
when others => a_to_g1 <= "0111000"; --F

20
end case;

21
end process;

22


23


24


25


26
process (segm2)

27
begin

28
case segm2 is

29
when X"0" => a_to_g2 <= "0000001"; --0

30
when X"1" => a_to_g2 <= "1001111"; --1

31
when X"2" => a_to_g2 <= "0010010"; --2

32
when X"3" => a_to_g2 <= "0000110"; --3

33
when X"4" => a_to_g2 <= "1001100"; --4

34
when X"5" => a_to_g2 <= "0100100"; --5

35
when X"6" => a_to_g2 <= "0100000"; --6

36
when X"7" => a_to_g2 <= "0001101"; --7

37
when X"8" => a_to_g2 <= "0000000"; --8

38
when X"9" => a_to_g2 <= "0000100"; --9

39
when X"A" => a_to_g2 <= "0001000"; --A

40
when X"B" => a_to_g2 <= "1100000"; --b

41
when X"C" => a_to_g2 <= "0110001"; --C

42
when X"D" => a_to_g2 <= "1000010"; --d

43
when X"E" => a_to_g2 <= "0110000"; --E

44
when others => a_to_g2 <= "0111000"; --F

45
end case;

46
end process;

47


48


49


50
process (segm3)

51
begin

52
case segm3 is

53
when X"0" => a_to_g3 <= "0000001"; --0

54
when X"1" => a_to_g3 <= "1001111"; --1

55
when X"2" => a_to_g3 <= "0010010"; --2

56
when X"3" => a_to_g3 <= "0000110"; --3

57
when X"4" => a_to_g3 <= "1001100"; --4

58
when X"5" => a_to_g3 <= "0100100"; --5

59
when X"6" => a_to_g3 <= "0100000"; --6

60
when X"7" => a_to_g3 <= "0001101"; --7

61
when X"8" => a_to_g3 <= "0000000"; --8

62
when X"9" => a_to_g3 <= "0000100"; --9

63
when X"A" => a_to_g3 <= "0001000"; --A

64
when X"B" => a_to_g3 <= "1100000"; --b

65
when X"C" => a_to_g3 <= "0110001"; --C

66
when X"D" => a_to_g3 <= "1000010"; --d

67
when X"E" => a_to_g3 <= "0110000"; --E

68
when others => a_to_g3 <= "0111000"; --F

69
end case;

70
end process;

71


72


73
process (segm4)

74
begin

75
case segm4 is

76
when X"0" => a_to_g4 <= "0000001"; --0

77
when X"1" => a_to_g4 <= "1001111"; --1

78
when X"2" => a_to_g4 <= "0010010"; --2

79
when X"3" => a_to_g4 <= "0000110"; --3

80
when X"4" => a_to_g4 <= "1001100"; --4

81
when X"5" => a_to_g4 <= "0100100"; --5

82
when X"6" => a_to_g4 <= "0100000"; --6

83
when X"7" => a_to_g4 <= "0001101"; --7

84
when X"8" => a_to_g4 <= "0000000"; --8

85
when X"9" => a_to_g4 <= "0000100"; --9

86
when X"A" => a_to_g4 <= "0001000"; --A

87
when X"B" => a_to_g4 <= "1100000"; --b

88
when X"C" => a_to_g4 <= "0110001"; --C

89
when X"D" => a_to_g4 <= "1000010"; --d

90
when X"E" => a_to_g4<= "0110000"; --E

91
when others => a_to_g4 <= "0111000"; --F

92
end case;

93
end process;


Und die Ergbenisse werden an den Multiplexer angelegt.

1
COMP_Multiplexer : multiplexer port map ( clk => clk2,

2
                            seg1 => a_to_g1 ,

3
                            seg2 => a_to_g2,

4
                            seg3 => a_to_g3 ,

5
                            seg4 => a_to_g4,

6
                            seg_out => a2g,

7
                            an => anod);


Ich habe mich doch für folgenden Ablauf entschieden:

http://www.ee.ucr.edu/~qzhu/courses/ee120a_11fall/labs/Lab_4_seq_logic.pdf
Seite 10:

Alle 4 7-Bit Segmentsignale liegen am Multiplexer an, der nur noch 
anhand des Selectes den jeweiligen Wert auswählt und parallel die 
dazugehörige Anode ansteuert.

Der Multiplexer wählt mit 50 Hz aus und sollte seine Ergebnisse auf den 
Ausgang bzw. an die Segmentanzeigen + Anoden anlegen.


Leider wird auf der 7 Segmentanzeige nur das letzte Element mit einem A 
falsch herum angezeigt, auch wenn die Eingangsignale sich ändern.

Ich denke, das liegt zum Einen daran, das Start die ganze Zeit auf '1' 
ist. Ich weiß jetzt nicht genau, wie bzw. wann ich den Startzyklus 
setzen soll.


Ohje, ich hoffe, ich verschrecke hiermit keinen und ihr könnt mir sagen, 
wo ich den Fehler gemacht habe.


Viele viele Dank schonmal dafür!!!
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Bernd Gast #2814468
Lesenswert?
• ▲
▼ 
Ich sehe gerade, das die letzte Anzeige sich doch verändert, sobald 
andere Signale kommen. Jedoch ist meist auch das umgedrehte A dabei, 
welches ja  gar nicht vorkommen sollte.

Es leuchtet jedoch nur die letzte Anzeige
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Lothar M. Moderator (Firma: Titel) Persönliche Seite #2814518
Lesenswert?
• ▲
▼ 
1
----- 50 HZ Generator ------

2
process(clk)

3
begin

4
  if (counter = 999999) then

5
    counter <= 0;

6
  else

7
    counter <= counter + 1;

8
  end if;

9
  

10
  if counter < 500000 then

11
    clk2 <= '1';

12
  else

13
    clk2 <= '0'; 

14
  end if;

15
end process;

Das funktioniert nur in der Simulation. Und die ist falsch, weil die 
Sensitivliste falsch ist...
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Bernd Gast #2814567
Lesenswert?
• ▲
▼ 
Eine Skizze der Schaltung im Anhang.

Jedoch wer ist jetzt für die Ausgabe der Anode "an" zuständig. Der 
Multiplexer? Oder die hex7Seg Komponente`? Oder wird dies im Top Level 
Design umgesetzt?


Und wie realisiere ich das mit dem Startwert für den Vector2BCD?
Über einen zusätzlichen counter?
Angehängte Dateien:
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Bernd Gast #2814574
Lesenswert?
• ▲
▼ 
Es funktioniert jetzt soweit, dass alle 4 Segmente angezeigt werden, 
jedoch kommt ein E und das umgedrehte A u.a. vor.


Lothar Miller schrieb:
> weil die
> Sensitivliste falsch ist...

das stimmt. Jedoch funktioniert es jetzt folgendermaßen soweit:

1
process(clk)

2
begin

3
 if rising_edge(clk) then

4
 

5
  --if (counter = 999999) then

6
  if (counter = 99999) then

7
    counter <= 0;

8
  else

9
    counter <= counter + 1;

10
  end if;

11
  

12
  --if counter < 500000 then

13
  if counter < 50000 then

14
    clk2 <= '1';

15
  else

16
    clk2 <= '0'; 

17
  end if;

18
end if;

19
end process;


In der Synthese kam auch keine Fehlermeldung. Und durch die höhere 
Frequenz bekomme ich jetzt auch eine stabile Zahl angezeigt.

Ich schätze nur, das ich die Anschlüsse falsch gesetzt habe, sodass ich 
statt einer 3 ein E heraus bekomme. Kann das sein?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Lothar M. Moderator (Firma: Titel) Persönliche Seite #2814575
Lesenswert?
• ▲
▼ 
Bernd schrieb:
> Jedoch wer ist jetzt für die Ausgabe der Anode "an" zuständig.
Der, der dem Multiplexer über C1 und C2 sagt, welche Stelle er zum 
Decodieren weiterzuleiten hat...

> Und wie realisiere ich das mit dem Startwert für den Vector2BCD?
Der "Startwert" ist der Wert, den du ausgeben willst. Irgendwoher muss 
der ja kommen. Und sobald dieser Wert anliegt, gibst du den Start-Puls. 
Du wirst wahrscheinlich um eine weitere FSM nicht herumkommen.
> Über einen zusätzlichen counter?
Ja nun, wenn reicht. Im einfachsten Fall ist eine FSM ein Zähler...
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren