Dezimalzahl auf 7 segment-Anzeige

Ich geschrieben habe, ein kleines Paket, das tut, was Sie wollen. Gegeben einen vorzeichenlosen Eingangswert ist, bricht es, diesen Wert in einer Reihe von Dezimalstellen, und erzeugt Signale, die fahren kann eine beliebige Anzahl von sieben-Segment-displays.

Hier ist ein Beispiel, wie Sie möchten, verwenden Sie:

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use work.seven_segment_pkg.all;

entity switches_to_7seg_displays is
    port (
        switches: in std_logic_vector(4 downto 0);
        seven_segments_display_1: out std_logic_vector(6 downto 0);
        seven_segments_display_2: out std_logic_vector(6 downto 0)
    );
end entity switches_to_7seg_displays;

architecture behavior of switches_to_7seg_displays is
    signal segments: std_logic_vector(13 downto 0);
    signal input: integer;
begin

    input <= to_integer(unsigned(switches));

    segments <= unsigned_to_seven_segment(
        value => unsigned(switches),
        number_of_digits => 2,
        value_is_bcd => false          
    );

    seven_segments_display_1 <= segments(13 downto 7);
    seven_segments_display_2 <= segments(6 downto 0);

end;

Beachten Sie, dass der Eingabe-Wert ist ein unsigned. Konvertieren (eigentlich, "type cast") ein std_logic_vector in einen unsigned, nutzen Sie einfach:

switches_uns <= unsigned(switches_slv);

Wenn aus irgendeinem Grund Sie sich entscheiden, konvertieren Sie den Wert von den Schaltern in eine ganze Zahl, es gibt eine Funktion in ieee.numeric_std, die das tut. Es ist eine gute Idee, es zu benutzen, anstatt zu schreiben Ihre eigenen. Sie können es verwenden, wie:

switches_int <= to_integer(unsigned(switches_slv));

Schließlich, hier ist der code für das Paket. Sie sind willkommen, es zu benutzen oder es zu studieren und kommen mit Ihrer eigenen Lösung.

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

package seven_segment_pkg is

    -- Return a std_logic_vector ready for driving a number of 7-segment displays.
    function unsigned_to_seven_segment(
        value: unsigned;
        number_of_digits: integer;
        value_is_bcd: boolean
    ) return std_logic_vector;

end;

package body seven_segment_pkg is

    function seven_seg_from_bcd_digit(bcd_digit: std_logic_vector(3 downto 0)) 
        return std_logic_vector 
    is begin
        case bcd_digit is
            --                   abcdefg
            when x"0" => return "0111111";
            when x"1" => return "0000110";
            when x"2" => return "1011011";
            when x"3" => return "1001111";
            when x"4" => return "1100110";
            when x"5" => return "1101101";
            when x"6" => return "1111101";
            when x"7" => return "0000111";
            when x"8" => return "1111111";
            when x"9" => return "1101111";
            when x"a" => return "1110111";
            when x"b" => return "1111100";
            when x"c" => return "0111001";
            when x"d" => return "1011110";
            when x"e" => return "1111001";
            when x"f" => return "1110001";
            when others => return "0000000";
        end case;
    end;

    -- Return a vector ready for driving a series of 7-segment displays.
    function unsigned_to_seven_segment(
        value: unsigned;
        -- Number of 7-segment displays (determines output vector width: W = 7*N)
        number_of_digits: integer;
        -- When true, treat the input value as a BCD number where every 4 bits hold one
        -- digit from 0 to A. When false, treat the input number as an unsigned integer.       
        value_is_bcd: boolean
    ) return std_logic_vector is

        variable segments: std_logic_vector(number_of_digits*7-1 downto 0);
        variable bcd_quotient: unsigned(value'range);
        variable bcd_remainder: unsigned(3 downto 0);
    begin

        if value_is_bcd then
            for i in 0 to number_of_digits-1 loop
                segments(i*7+6 downto i*7) := seven_seg_from_bcd_digit(
                    std_logic_vector(value(i*4+3 downto i*4))
                );
            end loop;
        else
            bcd_quotient := value;
            for i in 0 to number_of_digits-1 loop
                bcd_remainder := resize(bcd_quotient mod 10, 4);
                bcd_quotient := bcd_quotient / 10;
                segments(i*7+6 downto i*7) := seven_seg_from_bcd_digit(
                    std_logic_vector(bcd_remainder)
                );
            end loop;

        end if;

        return segments;
    end;

end;

InformationsquelleAutor rick

Lösen 3) Sie haben zu verstehen, wie eine 7-segment Anzeige funktioniert, insbesondere Zeichen-display. Im Grunde müssen Sie implementieren einen encoder aus einer ganzen Zahl in die hexadezimale Kodierung der Anzeige. Der hexadezimale Codierung ist in dem Datenblatt von dem display, z.B. dieses Datenblatt zeigt Sie die display-pins sind miteinander verbunden, an welches segment. Eine beispielhafte hexadezimal-code ist an wikipedia.

InformationsquelleAutor Sebastian Dressler