Using the 7-segment Displays/ 7 Segment Anzeige

[Manah (Gast)]

Hallo alle,

ich habe nachgeguckt und mir mehrere YouTube Videos angeguckt, bei denn 
Boards die ich in Internet gefunden habe, gibt es so was wie ein Input, 
welches Automatisch das Segment wechselt (mit einem Mux), ich glaube bei 
meinem Board ist das nicht der Fall, ich habe nichts in der Doku darüber 
gefunden.

d
d.h.:

Wenn ich 5 Segmente ansprechen möchte, brauche ich 5 Fälle (case)? Oder 
gibt es eine Anweisung, die automatisch die Pins des nächsten Segments 
adressiert? In der Dokumentation hat jedes Segment seine eigenen 
Ausgangspins.

English:
if i want to address 5 segments need 5 cases? Or is there an instruction 
that automatically addresses the pins of the next segment? In the 
documentation, each segment has its own output pins.


Board: Terasic Technologies DE10-Lite Boar
Sprache: VHDL
IDE: Quartus Prime Lite 2 - 18.1

Danke

[J. S. (engineer)]

In der "guten alten Zeit" haben wir das mit der Spannungsversorgung 
geregelt und das Display analog multiplexed. D.h. jeweils eines von 5en 
war "an". Richtig sauber geht das über ein Schieberegister mit Latch, 
wie z.B. das  165.

Es wäre also nachzusehen, WIE diese Anzeige verdrahtet ist und besaftet 
werden muss.

[Manah (Gast)]

Hallo Jürgen,

danke für deine schnelle Rückmeldung,


das ist ein ausschnitt aus meinem Code, also besser gesagt, ein Standard 
Encoder für eine 7-Seg Anzeige.

  PROCESS (seg_coder_in_s)
  BEGIN
    case seg_coder_in_s_seg1 is
      when "0000"     => a <= '1'; b <= '1'; c <= '1'; d <= '1'; e <= '1'; f <= '1'; g <= '0';
      when "0001"     => a <= '0'; b <= '1'; c <= '1'; d <= '0'; e <= '0'; f <= '0'; g <= '0';
      when "0010"     => a <= '1'; b <= '1'; c <= '0'; d <= '1'; e <= '1'; f <= '0'; g <= '1';
      when "0011"     => a <= '1'; b <= '1'; c <= '1'; d <= '1'; e <= '0'; f <= '0'; g <= '1';
      when "0100"     => a <= '0'; b <= '1'; c <= '1'; d <= '0'; e <= '0'; f <= '1'; g <= '1';
      when "0101"     => a <= '1'; b <= '0'; c <= '1'; d <= '1'; e <= '0'; f <= '1'; g <= '1';
      when "0110"     => a <= '1'; b <= '0'; c <= '1'; d <= '1'; e <= '1'; f <= '1'; g <= '1';
      when "0111"      => a <= '1'; b <= '1'; c <= '1'; d <= '0'; e <= '0'; f <= '0'; g <= '0';
      when "1000"     => a <= '1'; b <= '1'; c <= '1'; d <= '1'; e <= '1'; f <= '1'; g <= '1';
      when "1001"     => a <= '1'; b <= '1'; c <= '1'; d <= '1'; e <= '0'; f <= '1'; g <= '1';
      when others     => a <= '0'; b <= '0'; c <= '0'; d <= '0'; e <= '0'; f <= '0'; g <= '1';
    END case;
  END PROCESS;
END Seg_Steuerung;

In dem Handbuch
https://www.manualslib.com/manual/1429115/Terasic-De10-Lite.html
steht: Für jede Led, eine Eigene Pin (je LED: PIN_C14, PIN_C15 
usw...),in dem Fall müsste ich 6 Decoder schreiben, wenn ich alle 6 
7-Segment Anzeigen ansprechen möchte oder? Weil ich ja 6*7 = 42 Output 
Pins ansprechen muss? und eine für denn DP Pin? Also insgesamt 43 Pins.

In jeden Foren Eintrage sehe ich halt in Beispiel jeweils 1 Decoder. Das 
verwirrt mich, wie man mit 1 Decoder 42 Pins adressieren kann, weil ja 
jede Pin einen Eigenen Output hat.

[Manah (Gast)]

Nachtrag (Kurzfassung): Brauche ich für jedes Segment einen Eigenen 
Decoder?

[foobar (Gast)]

Man multiplext, wenn man Pins sparen will.  Auf diesem Board wissen sie 
nicht, wohin mit den 360 I/O-Pins des Chips, also werden alle 6x8 LEDs 
einzeln angeschlossen.  Wie du diese 48 Pins nun ansteuerst, ist dir 
überlassen - wenn du willst, sogar über einen Multiplexer.

Aber ehrlich: wenn du bei sowas bereits nachfragen musst, was um Himmels 
willen willst du mit so einem FPGA-Board?  Meinst du nicht, du wärst mit 
einem einfachen Arduino erstmal besser bedient?

[Manah (Gast)]

Ich muss das Board benutzten, sagen wir so :D @schöner name.
So wie ich dich Verstanden habe, muss ich alle Pins Einzel ansteuern und 
brauche dann jeweils 1 Decoder pro Segement.

In dem Fall muss ich das 6 mal kopieren:

  PROCESS (seg_coder_in_s)
  BEGIN
    case seg_coder_in_s_seg1 is
      when "0000"     => a <= '1'; b <= '1'; c <= '1'; d <= '1'; e <= '1'; f <= '1'; g <= '0';
      when "0001"     => a <= '0'; b <= '1'; c <= '1'; d <= '0'; e <= '0'; f <= '0'; g <= '0';
      when "0010"     => a <= '1'; b <= '1'; c <= '0'; d <= '1'; e <= '1'; f <= '0'; g <= '1';
      when "0011"     => a <= '1'; b <= '1'; c <= '1'; d <= '1'; e <= '0'; f <= '0'; g <= '1';
      when "0100"     => a <= '0'; b <= '1'; c <= '1'; d <= '0'; e <= '0'; f <= '1'; g <= '1';
      when "0101"     => a <= '1'; b <= '0'; c <= '1'; d <= '1'; e <= '0'; f <= '1'; g <= '1';
      when "0110"     => a <= '1'; b <= '0'; c <= '1'; d <= '1'; e <= '1'; f <= '1'; g <= '1';
      when "0111"      => a <= '1'; b <= '1'; c <= '1'; d <= '0'; e <= '0'; f <= '0'; g <= '0';
      when "1000"     => a <= '1'; b <= '1'; c <= '1'; d <= '1'; e <= '1'; f <= '1'; g <= '1';
      when "1001"     => a <= '1'; b <= '1'; c <= '1'; d <= '1'; e <= '0'; f <= '1'; g <= '1';
      when others     => a <= '0'; b <= '0'; c <= '0'; d <= '0'; e <= '0'; f <= '0'; g <= '1';
    END case;
  END PROCESS;
END Seg_Steuerung;

und dann statt a b c ... die jeweiligen pins ansteuern.

[J. S. (engineer)]

Manah schrieb:
> Nachtrag (Kurzfassung): Brauche ich für jedes Segment einen Eigenen
> Decoder?

In keinem Fall. Nur das Latch, also den gespeicherten Wert. Auch in dem 
Fall, dass wirklich alle LEDs einzeln explizit angeschlossen sind, kann 
man den Decoder per MUX wiederverwenden. Allerdings ist die Synthese 
schlau genug, das zu erkennen und vereinfacht den zu einer veringerten 
Menge, wenn man wirklich 5 identische Schaltungen instanziieren würde - 
egal, ob sie zeitgleich, oder zeitlich getrennt genutzt werden.

[Fpgakuechle K. (Gast)]

Manah schrieb:
> Nachtrag (Kurzfassung): Brauche ich für jedes Segment einen Eigenen
> Decoder?

nein, es genügt wenn du einen Decoder mit dem passenden CE (Chip-Enable) 
nachenander einmultiplext. Die brauchst also einen Zähler bspw v. 0 bis 
5, der zum Zählerstand 0 den Wert von Ziffer 0 an den Eingang des 
decoders legt und gleichzeitig für einen Takt das Chip enable der 
Ausgangs-FF für dieses 7Segment aktiviert.

[foobar (Gast)]

> muss ich das 6 mal kopieren

Na ja, kann man.  Üblich ist wohl eher, eine Entity 6 mal mit passenden 
port-maps zu instantiieren.  Näheres steht in deinem VHDL-Buch ...


PS: Ich kann kein VHDL, hab nur nen groben Überblick über die Konzepte.

[Manah (Gast)]

Ich finde das einleuchtend, in den Youtube Vidoes habe ich genau das 
gleiche gesehen. Aber deren 7Seg Anzeigen haben 9 Pins, eine für denn 
DP, 7 für die jeweiligen Segmente und ein Cat Signal.

Das Cat Signal dient halt bei den 7 Segmenten Anzeigen dafür, um es um 
ein Segment weiter zu "schieben", aber in meinem Fall gibt es kein Cat 
Signal, also in Handbuch steht nur das es 8 Pins gibt und einen für den 
DP und für die 7 Segmente und jeder Pin hat seine Eigene Pin 
Adressierung.

Und Irgendwie muss ich ja sagen (Bei der Pin-Zuweisung), der Output von 
den Decoder ist der Pin.

Z.B.:
when "0000"     => a <= '1'; b <= '1'; c <= '1'; d <= '1'; e <= '1'; f 
<= '1'; g <= '0';

Pin-Zuweisung geht nur mit Outputs.
Output: a,b,c,...

a = PIN X
b = PIN Y
c = PIN Z
...


Das muss ich doch dann denn Decoder für jedes Segment extra schreiben, 
weil ich ja 42 Outputs benötige, da ich 42 Pins ansprechen will?

[Fpgakuechle K. (Gast)]

Manah schrieb:

> Das muss ich doch dann denn Decoder für jedes Segment extra schreiben,
> weil ich ja 42 Outputs benötige, da ich 42 Pins ansprechen will?

Lt. Blockbild im Boardmanual hast du 48 pins (wegen dem dezimalpunkt)

und nein, du brauchst nicht einen Decoder für jedes Digit, sondern ein 
Chipenable für jedes der 6 Digits extra. einen Decoder-ausgang bspw (a) 
kannst du mit allen 6 Output-FF für das segment a in allen digits 
verbinden


schnippseltechnisch etwa so:

process(clk)
begin
if rising_edge(clk)
   if digit_count_q = 0 then
     digit_0_fpgaout_sega <= decoder_out_a; 
     digit_0_fpgaout_segb <= decoder_out_b;
    --  othe segements similar
   end if;
   if digit_count_q = 1 then
     digit_1_fpgaout_sega <= decoder_out_a; 
     digit_1_fpgaout_segb <= decoder_out_b;
    --  othe segements similar
   end if;
  --4 digits more
 end if;
end Process;

Natürlich kann man das mit Generate eleganter schreiben.

[foobar (Gast)]

Mag ja sein, dass ich vollkommen daneben liege, aber warum sich mit 
Muxern rumplagen?  Der BCD-nach-7seg-Dekoder passt in ein 4LUT, d.h. an 
jedem der 6x7=42 Pins hängt ein 4LUT und man hat direkt nen 24-Bit 
BCD-Bus zu den LEDs.  Einstufig kombinatorisch.  Wird das mit Muxern 
wirklich einfacher?

Bei dem Author hapert es doch eher daran, wie er's in VHDL ausdrücken 
soll.  Da kann ich ihm auch nicht helfen (wie gesagt, kann kein VHDL), 
aber vom Prinzip her:

// pseudo-language, NOT VHDL!
define bcd7seg(in[4], out[7])
{
   out[0] = in==0 or in==2 or ...   // Segment A
   out[1] = in==1 or in==2 or ...   // Segment B
   ...
   out[6] = ...                     // Segment G
   // oder umgekehrt mittels case
}

instantiate bcd7seg(bcd[0..3],   port[0..6])  // port[7] is DP
instantiate bcd7seg(bcd[4..7],   port[8..14])
instantiate bcd7seg(bcd[8..11],  port[16..22)
instantiate bcd7seg(bcd[12..15], port[24..30])
instantiate bcd7seg(bcd[16..19], port[32..38])
instantiate bcd7seg(bcd[20..23], port[40..46])

[Steffen H. (avrsteffen)]

Oder schaust mal hier:
https://www.nandland.com/vhdl/modules/binary-to-7-segment.html

[Fpgakuechle K. (Gast)]

foobar schrieb:
> Mag ja sein, dass ich vollkommen daneben liege, aber warum sich mit
> Muxern rumplagen?  Der BCD-nach-7seg-Dekoder passt in ein 4LUT, d.h. an
> jedem der 6x7=42 Pins hängt ein 4LUT und man hat direkt nen 24-Bit
> BCD-Bus zu den LEDs.  Einstufig kombinatorisch.  Wird das mit Muxern
> wirklich einfacher?

Das kommt auf einen Versuch an, weil Muxer nicht unbedingt nur mit LUT's 
gebaut werden, sondern auch mit den ohnehin vorhanden MUX5/Mux& 
primitiven.
Allerdings haste schon recht, eine Mehrfach-instanziierung ist hier der 
erfolgsversprechende Ansatz.


>
> Bei dem Author hapert es doch eher daran, wie er's in VHDL ausdrücken
> soll.  Da kann ich ihm auch nicht helfen (wie gesagt, kann kein VHDL),
> aber vom Prinzip her:

also etwa so

        architecture Behavioral of top is
          component seg_coder is
            port (
              a, b, c, d, e, f, g : out std_logic;
              bcd_i : in std_logic );
          end component seg_coder;

          signal s_led : std_logic_vector(47 downto 0);
        begin

          G_7seg : for idx in 0 to 5 Generate
            seg_coder_i : seg_coder    --im angehängten file ist diese Zeile anders
              port map (
                a => s_led(8*idx + 0),
                b => s_led(8*idx + 1),
                c => s_led(8*idx + 2),
                d => s_led(8*idx + 3),
                e => s_led(8*idx + 4),
                f => s_led(8*idx + 5),
                g => s_led(8*idx + 6),
                bcd_i => bcd_i(4*idx+3 downto 4*idx));
            S_LED(8*IDX + 7) <= '0'  -- DECIMAL POINT
          end generate;
      end architecture;

Ich hab mal das gesamtfile ungeprüft angehangen.

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

Manah schrieb:
> und dann statt a b c ... die jeweiligen pins ansteuern.
Schlauer wäre es, wenn du einfach einen 7 bit breiten Vektor definieren 
und dort dein Bitmuster ablegen würdest. Denn dann musst du nur die 7 
Bits des Vektors dem passenden Pin zuordnen und hast einen kurzen und 
kompakten Code. Hier mal eine Stoppuhr, die die Zeit auf 4 
gemultiplexten Sieben-Segment-Anzeigen ausgibt:
http://www.lothar-miller.de/s9y/archives/88-VHDL-vs.-Verilog-am-Beispiel-einer-Stoppuhr.html

Aaaaaber:
foobar schrieb:
> Auf diesem Board wissen sie nicht, wohin mit den 360 I/O-Pins des Chips,
> also werden alle 6x8 LEDs einzeln angeschlossen.
Tragisch...
Ich würde da also einfach ein kleines ROM instantiieren, mit den 
Bitmustern füllen und über einen Index draufzugreifen:

:
  type Rom10x7 is array (0 to 9) of std_logic_vector (6 downto 0);
               -- Segment (low aktiv) abcdefg        Anzeige 
  constant SevenSegRom: Rom10x7 := ( "1000000",      -- 0
                                     "1111001",      -- 1
                                     "0100100",      -- 2
                                     "0110000",      -- 3
                                     "0011001",      -- 4
                                     "0010010",      -- 5
                                     "0000010",      -- 6
                                     "1111000",      -- 7
                                     "0000000",      -- 8
                                     "0010000" );    -- 9
:
:
  HEX0 <= SevenSegRom(to_integer(unsigned(slv_wert0)));
  HEX1 <= SevenSegRom(to_integer(unsigned(slv_wert1)));
  HEX2 <= SevenSegRom(to_integer(unsigned(slv_wert2)));
  HEX3 <= SevenSegRom(to_integer(unsigned(slv_wert3)));
:

Bei der Tabelle ist dann auch gleich beachtet, dass (wie im Schaltplan 
leicht zu erkennen) die LEDs low aktiv angeschlossen sind. Eine '0' 
bedeutet also "LED leuchtet".


Zuvor jedoch dürfte es vermutlich nötig sein, eine vorliegende binäre 
Zahl (z.B. Zählerwert) in die für die einzelnen Segmente nötige 
BCD-Darstellung umzuwandeln:
http://www.lothar-miller.de/s9y/categories/44-BCD-Umwandlung

[Manah (Gast)]

Hi alle,

ich habe die Antwort: Tatsächlich muss für das Board jede Pin 
Einzelangesprochen werden, es muss über Port Mapping gelöst werden.
So wie hier in Code zu sehen ist @fpgakuechle.

Danke für euren Support!

Liebe Grüße

Okan

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

Manah schrieb:
> Tatsächlich muss für das Board jede Pin Einzelangesprochen werden
> es muss über Port Mapping gelöst werden.
Aber eben nicht über 4x7 = 28 einzelne 1-Bit Signale mit 28 
unterschiedlichen Namen. Es geht auch über 4 Vektoren mit je 7 Bit 
Breite.
Denn du kannst in den Constraints (Pin Assignment, LOC Constraints,...) 
eben auch einzelne Bits eines Vektors an bestimmte IO-Pins zuweisen.

[Manah (Gast)]

ich werde mir beide Ansätze angucken. Danke euch allen!