STD_LOGIC_VECTOR --> 7 SEGMENT DISPLAY

[Bernd (Gast)]

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:

library IEEE;
use IEEE.STD_LOGIC_1164.all;
entity hex7seg is
port(
x : in STD_LOGIC_VECTOR(3 downto 0);
a_to_g : out STD_LOGIC_VECTOR(6 downto 0)
);
end hex7seg;
architecture hex7seg of hex7segbis
begin
process(x)
begin
case x is
when X"0" => a_to_g <= "0000001"; --0
when X"1" => a_to_g <= "1001111"; --1
when X"2" => a_to_g <= "0010010"; --2
when X"3" => a_to_g <= "0000110"; --3
when X"4" => a_to_g <= "1001100"; --4
when X"5" => a_to_g <= "0100100"; --5
when X"6" => a_to_g <= "0100000"; --6
when X"7" => a_to_g <= "0001101"; --7
when X"8" => a_to_g <= "0000000"; --8
when X"9" => a_to_g <= "0000100"; --9
when X"A" => a_to_g <= "0001000"; --A
when X"B" => a_to_g <= "1100000"; --b
when X"C" => a_to_g <= "0110001"; --C
when X"D" => a_to_g <= "1000010"; --d
when X"E" => a_to_g <= "0110000"; --E
when others => a_to_g <= "0111000"; --F
end case;
end process;
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

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

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...

[Bernd (Gast)]

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?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Bernd schrieb:
> Kann ich das so machen?
Kommt (wie schon gesagt) auf die Beschaltung der 7-Segment-Anzeigen 
an...

[Bernd (Gast)]

Ich benötige einen Multiplexer.

Seite 4:
http://www.digilentinc.com/Data/Products/BASYS2/Basys2_rm.pdf


Es müssen ja AN0, AN1, AN2, AN3 gesetzt werden, sodass jeweils dann die 
7 Segementwerte zugeordnet werden.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Bernd schrieb:
> Ich benötige einen Multiplexer.
Den setzt du dann sinnvollerweise zwischen den BCD-Decoder und den 
7-Segment-Decoder, dann musst du nur 4 Leitungen multiplexen (statt 
7)...

[Bernd (Gast)]

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 :-/

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Bernd schrieb:
> Ist das korrekt?
Ja, an sich schon.

> Das kann doch nicht so schwer sein :-/
Zeichne mal einen Schaltplan, wie du das mit Funktionsblöcken aufbauen 
würdest (und poste den). Dann siehst du schnell, was am besten wohin 
kommt...

[Bernd (Gast)]

Guten Morgen,

ich habe jetzt folgendes versucht:

TOP LEVEL DESIGN

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
--use IEEE.NUMERIC_STD.ALL;

-- Uncomment the following library declaration if instantiating
-- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity test_max is
    Port ( max_in : in  STD_LOGIC_VECTOR (11 downto 0);
      --     max_out : out  STD_LOGIC_VECTOR (11 downto 0);
      --  bcd_4_out : out STD_LOGIC_VECTOR( 3 downto 0);
        anod      : out std_logic_vector(3 downto 0);
        a2g       : out std_logic_vector(6 downto 0);
           clk : in  STD_LOGIC);
end test_max;

architecture Behavioral of test_max is


component Vector2BCD
Port (     clk      : in  std_logic;
           vector   : in  std_logic_vector (11 downto 0);
           start    : in  std_logic;
           busy     : out std_logic;
           overflow : out std_logic;
           bcd      : out std_logic_vector (15 downto 0));
end component;



--component hex7seg
--Port (     x         : in  STD_LOGIC_VECTOR (3 downto 0);
--           a_to_g    : out  STD_LOGIC_VECTOR (6 downto 0));
--end component;



component multiplexer
Port (     clk       : in STD_LOGIC;
          seg1      : in STD_LOGIC_VECTOR (6 downto 0);
        seg2      : in STD_LOGIC_VECTOR (6 downto 0);
        seg3      : in STD_LOGIC_VECTOR (6 downto 0);
        seg4      : in STD_LOGIC_VECTOR (6 downto 0);        
           seg_out   : out STD_LOGIC_VECTOR(6 downto 0);
        an        : out STD_LOGIC_VECTOR(3 downto 0));
end component;


------------ SIGNALE ------------------------

signal busy  : STD_LOGIC;
signal bcd   : std_logic_vector(15 downto 0); 

signal sel : STD_LOGIC_VECTOR (1 downto 0);
--signal x_bcd : STD_LOGIC_VECTOR (3 downto 0);
signal counter : natural range 999999 downto 0;

signal clk2 : std_logic;



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);

signal a_to_g1 : STD_LOGIC_VECTOR(6 downto 0);
signal a_to_g2 : STD_LOGIC_VECTOR(6 downto 0);
signal a_to_g3 : STD_LOGIC_VECTOR(6 downto 0);
signal a_to_g4 : STD_LOGIC_VECTOR(6 downto 0);

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


begin

---------------- SCHRITT 1 ---------------

Comp_BCD : Vector2BCD port map ( clk => clk,
                  vector => max_in,
                  start => '1',
                  busy => busy,
                  overflow => open,
                  bcd => bcd);
--------------------------------------------                  
                  
--SEG : hex7seg port map (  x => x_bcd,
--                  a_to_g => a2g
--                );                  
--                  
--
--

COMP_Multiplexer : multiplexer port map ( clk => clk2,
                            seg1 => a_to_g1 ,
                            seg2 => a_to_g2,
                            seg3 => a_to_g3 ,
                            seg4 => a_to_g4,
                            seg_out => a2g,
                            an => anod);



------- SCHRITT 2 ----------

segm1 <= bcd(15 downto 12);
segm2 <= bcd(11 downto 8);
segm3 <= bcd(7 downto 4);
segm4 <= bcd(3 downto 0);  

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



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

process(clk)
begin
  if (counter = 999999) then
    counter <= 0;
  else
    counter <= counter + 1;
  end if;
  
  if counter < 500000 then
    clk2 <= '1';
  else
    clk2 <= '0'; 
  end if;
end process;






process (segm1)
begin
case segm1 is
when X"0" => a_to_g1 <= "0000001"; --0
when X"1" => a_to_g1 <= "1001111"; --1
when X"2" => a_to_g1 <= "0010010"; --2
when X"3" => a_to_g1 <= "0000110"; --3
when X"4" => a_to_g1 <= "1001100"; --4
when X"5" => a_to_g1 <= "0100100"; --5
when X"6" => a_to_g1 <= "0100000"; --6
when X"7" => a_to_g1 <= "0001101"; --7
when X"8" => a_to_g1 <= "0000000"; --8
when X"9" => a_to_g1 <= "0000100"; --9
when X"A" => a_to_g1 <= "0001000"; --A
when X"B" => a_to_g1 <= "1100000"; --b
when X"C" => a_to_g1 <= "0110001"; --C
when X"D" => a_to_g1 <= "1000010"; --d
when X"E" => a_to_g1 <= "0110000"; --E
when others => a_to_g1 <= "0111000"; --F
end case;
end process;




process (segm2)
begin
case segm2 is
when X"0" => a_to_g2 <= "0000001"; --0
when X"1" => a_to_g2 <= "1001111"; --1
when X"2" => a_to_g2 <= "0010010"; --2
when X"3" => a_to_g2 <= "0000110"; --3
when X"4" => a_to_g2 <= "1001100"; --4
when X"5" => a_to_g2 <= "0100100"; --5
when X"6" => a_to_g2 <= "0100000"; --6
when X"7" => a_to_g2 <= "0001101"; --7
when X"8" => a_to_g2 <= "0000000"; --8
when X"9" => a_to_g2 <= "0000100"; --9
when X"A" => a_to_g2 <= "0001000"; --A
when X"B" => a_to_g2 <= "1100000"; --b
when X"C" => a_to_g2 <= "0110001"; --C
when X"D" => a_to_g2 <= "1000010"; --d
when X"E" => a_to_g2 <= "0110000"; --E
when others => a_to_g2 <= "0111000"; --F
end case;
end process;



process (segm3)
begin
case segm3 is
when X"0" => a_to_g3 <= "0000001"; --0
when X"1" => a_to_g3 <= "1001111"; --1
when X"2" => a_to_g3 <= "0010010"; --2
when X"3" => a_to_g3 <= "0000110"; --3
when X"4" => a_to_g3 <= "1001100"; --4
when X"5" => a_to_g3 <= "0100100"; --5
when X"6" => a_to_g3 <= "0100000"; --6
when X"7" => a_to_g3 <= "0001101"; --7
when X"8" => a_to_g3 <= "0000000"; --8
when X"9" => a_to_g3 <= "0000100"; --9
when X"A" => a_to_g3 <= "0001000"; --A
when X"B" => a_to_g3 <= "1100000"; --b
when X"C" => a_to_g3 <= "0110001"; --C
when X"D" => a_to_g3 <= "1000010"; --d
when X"E" => a_to_g3 <= "0110000"; --E
when others => a_to_g3 <= "0111000"; --F
end case;
end process;


process (segm4)
begin
case segm4 is
when X"0" => a_to_g4 <= "0000001"; --0
when X"1" => a_to_g4 <= "1001111"; --1
when X"2" => a_to_g4 <= "0010010"; --2
when X"3" => a_to_g4 <= "0000110"; --3
when X"4" => a_to_g4 <= "1001100"; --4
when X"5" => a_to_g4 <= "0100100"; --5
when X"6" => a_to_g4 <= "0100000"; --6
when X"7" => a_to_g4 <= "0001101"; --7
when X"8" => a_to_g4 <= "0000000"; --8
when X"9" => a_to_g4 <= "0000100"; --9
when X"A" => a_to_g4 <= "0001000"; --A
when X"B" => a_to_g4 <= "1100000"; --b
when X"C" => a_to_g4 <= "0110001"; --C
when X"D" => a_to_g4 <= "1000010"; --d
when X"E" => a_to_g4<= "0110000"; --E
when others => a_to_g4 <= "0111000"; --F
end case;
end process;







end Behavioral;

Hier die Vector2BCD von Lothar Miller.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity Vector2BCD is
    Generic ( stellen : natural := 4;   -- Anzahl BCD-Stellen
              breite  : natural := 12); -- Breite des Eingangsvektors
    Port ( clk      : in  std_logic;
           vector   : in  std_logic_vector (breite-1 downto 0);
           start    : in  std_logic;
           busy     : out std_logic;
           overflow : out std_logic;
           bcd      : out std_logic_vector (stellen*4-1 downto 0));
end Vector2BCD;

architecture Behavioral of Vector2BCD is            -- Beispiel: Stellen=3, Breite=8
type states is (idle,calc);                          -- 2 1111   1111   11
signal state : states := idle;                       -- 0 9876   5432   1098   76543210
signal sr : unsigned (stellen*4+breite downto 0);  -- O BCDh & BCDz & BCDe & VVVVVVVV
signal bitcnt : integer range 0 to breite;
signal ovl : std_logic;
begin
   process begin
      wait until rising_edge(clk);
      busy <= '0';
      case state is
         when idle => 
            sr <= (others=>'0');
            sr(breite-1 downto 0) <= unsigned(vector);
            bitcnt <= breite;
            if (start='1') then 
               busy <= '1';
               ovl  <= '0';
               state<=calc;
            end if;
                      
         when calc => 
            if (bitcnt/=0) then 
               bitcnt <= bitcnt-1; -- bearbeitete Bits mitzählen
               busy <= '1';
               sr <= sr(stellen*4+breite-1 downto 0)&'0';         -- einmnal komplett durchschieben
               for i in 0 to stellen-1 loop 
                  if (sr(i*4+breite+3 downto i*4+breite)>4) then  -- falls nötig: BCD-Übertrag + schieben
                     sr(i*4+breite+4 downto i*4+breite+1) <= sr(i*4+breite+3 downto i*4+breite)+3;
                  end if;
               end loop;
               if (sr(sr'high)='1') then  ovl <= '1'; end if;
            else 
               state <= idle;
               bcd   <= std_logic_vector(sr(stellen*4+breite-1 downto breite));
               if(ovl='1' or sr(sr'high)='1') then overflow <= '1';
               else                                overflow <= '0';
               end if;
            end if;
            
      end case;
   end process;
end Behavioral;

MULTIPLEXER

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
--use IEEE.NUMERIC_STD.ALL;

-- Uncomment the following library declaration if instantiating
-- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity multiplexer is
    Port ( clk       : in STD_LOGIC;
          seg1      : in STD_LOGIC_VECTOR (6 downto 0);
        seg2      : in STD_LOGIC_VECTOR (6 downto 0);
        seg3      : in STD_LOGIC_VECTOR (6 downto 0);
        seg4      : in STD_LOGIC_VECTOR (6 downto 0);        
           seg_out   : out STD_LOGIC_VECTOR(6 downto 0);
        an        : out STD_LOGIC_VECTOR(3 downto 0));
end multiplexer;

architecture Behavioral of multiplexer is


signal error: std_logic_vector(6 downto 0):= "0000000";
signal sel  : UNSIGNED (1 downto 0) := "00";
begin


process(clk) 
begin
  if rising_edge(clk) then
    if sel = "11" then
      sel <= "00";
    else
      sel <= sel + "01";
    end if;
  end if;
end process;



process (clk) is
   begin
      case Sel is
         when "00"  => seg_out <= seg1;      
      when "01"  => seg_out <= seg2;    
         when "10"  => seg_out <= seg3;    
         when "11"  => seg_out <= seg4;        
      
         when others => seg_out <= error;
      end case;
   end process;


process (clk) is
   begin
      case Sel is
         when "00"  => an <= "1110";      -- 0 = Activ , 1 = low
      when "01"  => an <= "1101";    
         when "10"  => an <= "1011";    
         when "11"  => an <= "0111";        
      
         when others => an <= "0000";
      end case;
   end process;






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

Comp_BCD : Vector2BCD port map ( clk => clk,
                  vector => max_in,
                  start => '1',
                  busy => busy,
                  overflow => open,
                  bcd => bcd);

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

Hier extrahiere ich mir die relevanten BCD Werte

segm1 <= bcd(15 downto 12);
segm2 <= bcd(11 downto 8);
segm3 <= bcd(7 downto 4);
segm4 <= bcd(3 downto 0);

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

process (segm1)
begin
case segm1 is
when X"0" => a_to_g1 <= "0000001"; --0
when X"1" => a_to_g1 <= "1001111"; --1
when X"2" => a_to_g1 <= "0010010"; --2
when X"3" => a_to_g1 <= "0000110"; --3
when X"4" => a_to_g1 <= "1001100"; --4
when X"5" => a_to_g1 <= "0100100"; --5
when X"6" => a_to_g1 <= "0100000"; --6
when X"7" => a_to_g1 <= "0001101"; --7
when X"8" => a_to_g1 <= "0000000"; --8
when X"9" => a_to_g1 <= "0000100"; --9
when X"A" => a_to_g1 <= "0001000"; --A
when X"B" => a_to_g1 <= "1100000"; --b
when X"C" => a_to_g1 <= "0110001"; --C
when X"D" => a_to_g1 <= "1000010"; --d
when X"E" => a_to_g1 <= "0110000"; --E
when others => a_to_g1 <= "0111000"; --F
end case;
end process;




process (segm2)
begin
case segm2 is
when X"0" => a_to_g2 <= "0000001"; --0
when X"1" => a_to_g2 <= "1001111"; --1
when X"2" => a_to_g2 <= "0010010"; --2
when X"3" => a_to_g2 <= "0000110"; --3
when X"4" => a_to_g2 <= "1001100"; --4
when X"5" => a_to_g2 <= "0100100"; --5
when X"6" => a_to_g2 <= "0100000"; --6
when X"7" => a_to_g2 <= "0001101"; --7
when X"8" => a_to_g2 <= "0000000"; --8
when X"9" => a_to_g2 <= "0000100"; --9
when X"A" => a_to_g2 <= "0001000"; --A
when X"B" => a_to_g2 <= "1100000"; --b
when X"C" => a_to_g2 <= "0110001"; --C
when X"D" => a_to_g2 <= "1000010"; --d
when X"E" => a_to_g2 <= "0110000"; --E
when others => a_to_g2 <= "0111000"; --F
end case;
end process;



process (segm3)
begin
case segm3 is
when X"0" => a_to_g3 <= "0000001"; --0
when X"1" => a_to_g3 <= "1001111"; --1
when X"2" => a_to_g3 <= "0010010"; --2
when X"3" => a_to_g3 <= "0000110"; --3
when X"4" => a_to_g3 <= "1001100"; --4
when X"5" => a_to_g3 <= "0100100"; --5
when X"6" => a_to_g3 <= "0100000"; --6
when X"7" => a_to_g3 <= "0001101"; --7
when X"8" => a_to_g3 <= "0000000"; --8
when X"9" => a_to_g3 <= "0000100"; --9
when X"A" => a_to_g3 <= "0001000"; --A
when X"B" => a_to_g3 <= "1100000"; --b
when X"C" => a_to_g3 <= "0110001"; --C
when X"D" => a_to_g3 <= "1000010"; --d
when X"E" => a_to_g3 <= "0110000"; --E
when others => a_to_g3 <= "0111000"; --F
end case;
end process;


process (segm4)
begin
case segm4 is
when X"0" => a_to_g4 <= "0000001"; --0
when X"1" => a_to_g4 <= "1001111"; --1
when X"2" => a_to_g4 <= "0010010"; --2
when X"3" => a_to_g4 <= "0000110"; --3
when X"4" => a_to_g4 <= "1001100"; --4
when X"5" => a_to_g4 <= "0100100"; --5
when X"6" => a_to_g4 <= "0100000"; --6
when X"7" => a_to_g4 <= "0001101"; --7
when X"8" => a_to_g4 <= "0000000"; --8
when X"9" => a_to_g4 <= "0000100"; --9
when X"A" => a_to_g4 <= "0001000"; --A
when X"B" => a_to_g4 <= "1100000"; --b
when X"C" => a_to_g4 <= "0110001"; --C
when X"D" => a_to_g4 <= "1000010"; --d
when X"E" => a_to_g4<= "0110000"; --E
when others => a_to_g4 <= "0111000"; --F
end case;
end process;

Und die Ergbenisse werden an den Multiplexer angelegt.

COMP_Multiplexer : multiplexer port map ( clk => clk2,
                            seg1 => a_to_g1 ,
                            seg2 => a_to_g2,
                            seg3 => a_to_g3 ,
                            seg4 => a_to_g4,
                            seg_out => a2g,
                            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!!!

[Bernd (Gast)]

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

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Der Multiplexer sitzt an der falschen Stelle! Du brauchst bei geeigneter 
Platzierung nur einen einzigen Segment-Decoder (statt 4). Dazu muss nur 
der Mux vor diesen Decoder.

Wie gesagt: zeichne ein Bild mit den nötigen Leitungen und 
Komponenten...

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

----- 50 HZ Generator ------
process(clk)
begin
  if (counter = 999999) then
    counter <= 0;
  else
    counter <= counter + 1;
  end if;
  
  if counter < 500000 then
    clk2 <= '1';
  else
    clk2 <= '0'; 
  end if;
end process;

Das funktioniert nur in der Simulation. Und die ist falsch, weil die 
Sensitivliste falsch ist...

[Uwe (Gast)]

Bitte einen Schaltplan zeichnen !

[Bernd (Gast)]

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?

[Bernd (Gast)]

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:

process(clk)
begin
 if rising_edge(clk) then
 
  --if (counter = 999999) then
  if (counter = 99999) then
    counter <= 0;
  else
    counter <= counter + 1;
  end if;
  
  --if counter < 500000 then
  if counter < 50000 then
    clk2 <= '1';
  else
    clk2 <= '0'; 
  end if;
end if;
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?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

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...

[Bernd (Gast)]

Aber nichtsdestotrotz habe ich start die ganze Zeit '1'. Ich habe jetzt 
nicht in einer Simulation ausprobiert, ob es dann trotzdem funktioniert.
Kann das so funktionieren?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Wenn start dauernd auf '1' ist, dann wird eben dauernd wieder neu 
gewandelt. Das geht natürlich auch, wenn der Eingangswert immer einen 
gültigen Wert darstellt...

[Bernd (Gast)]

Ich werde es trotzdem nochmal umbauen, wie es Lothar vorgeschlagen hat. 
Es wäre ja auch ein Ressourceverbrauch, 4 Dekoder zu haben und den Mux 
dem nachzuschalten.