# 7 Segment display 1. But du projet 1. I/O utilisées 1. Explication de l'algorithme 1. Résultats > L'ensemble des codes, images et vidéos sont compris dans ce répertoire. ## But du projet Nous avons décider de nous intéresser à l'affichage 7 segments grâce au but suivant: - Créer un compteur de 0 à 9999 à l'aide des 4 afficheurs. En cas de dépassement ou d'appuye sur un bouton reset le compteur redémarrera à 0. ## I/O utilisées Tout d'abord, voyons les entrées/sortie que nous avons utilisé. ```vhdl entity display is port { clk_fpga : in STD_LOGIC; reset : in STD_LOGIC; aff : out STD_LOGIC_VECTOR{7 downto 0}; an : out STD_LOGIC_VECTOR{3 downto 0} }; end display; ``` - clk_fpga : le signal de clock du fpga Dans le fichier de contrainte : ``` ## Clock signal set_property -dict { PACKAGE_PIN W5 IOSTANDARD LVCMOS33 } [get_ports clk_fpga] create_clock -add -name sys_clk_pin -period 10.00 -waveform {0 5} [get_ports clk] ``` - reset : le signal permettant de remettre le compteur à zéro grâce à un bouton Dans le fichier de contrainte : ``` ## Switches set_property -dict { PACKAGE_PIN R2 IOSTANDARD LVCMOS33 } [get_ports reset] ``` - aff : un tableau de 8 bits relier à chaque led d'un segment à afficher (en ajoutant le point de l'afficheur) Dans le fichier de contrainte : ``` ##7 Segment Display set_property -dict { PACKAGE_PIN W7 IOSTANDARD LVCMOS33 } [get_ports {aff[0]}] set_property -dict { PACKAGE_PIN W6 IOSTANDARD LVCMOS33 } [get_ports {aff[1]}] set_property -dict { PACKAGE_PIN U8 IOSTANDARD LVCMOS33 } [get_ports {aff[2]}] set_property -dict { PACKAGE_PIN V8 IOSTANDARD LVCMOS33 } [get_ports {aff[3]}] set_property -dict { PACKAGE_PIN U5 IOSTANDARD LVCMOS33 } [get_ports {aff[4]}] set_property -dict { PACKAGE_PIN V5 IOSTANDARD LVCMOS33 } [get_ports {aff[5]}] set_property -dict { PACKAGE_PIN U7 IOSTANDARD LVCMOS33 } [get_ports {aff[6]}] set_property -dict { PACKAGE_PIN V7 IOSTANDARD LVCMOS33 } [get_ports {aff[7]}] ``` > exemple : aff à "11111110" allumera la led du point de l'afficheur séléctionné. - an : un tableau comprenant 4 bits permettant de sélectionner l'un des 4 afficheurs 7 segments Dans le fichier de contrainte : ``` set_property -dict { PACKAGE_PIN U2 IOSTANDARD LVCMOS33 } [get_ports {an[0]}] set_property -dict { PACKAGE_PIN U4 IOSTANDARD LVCMOS33 } [get_ports {an[1]}] set_property -dict { PACKAGE_PIN V4 IOSTANDARD LVCMOS33 } [get_ports {an[2]}] set_property -dict { PACKAGE_PIN W4 IOSTANDARD LVCMOS33 } [get_ports {an[3]}] ``` > exemple : an à "1110" sélectionnera l'afficheur le plus à droite. ## Explication de l'algorithme Les signaux les signaux utilisés vont nous permettre d'avoir un code clean et plus ou moins factorié. ``` architecture Behavioral of display is signal count_an : integer range 3 downto 0 := 0; signal clk_enable : integer range 4999 downto 0 := 0; signal clk_counter : integer range 2999999 downto 0 := 0; constant nb0 : std_logic_vector(7 downto 0) := "11000000"; constant nb1 : std_logic_vector(7 downto 0) := "11111001"; constant nb2 : std_logic_vector(7 downto 0) := "10100100"; constant nb3 : std_logic_vector(7 downto 0) := "10110000"; constant nb4 : std_logic_vector(7 downto 0) := "10011001"; constant nb5 : std_logic_vector(7 downto 0) := "10010010"; constant nb6 : std_logic_vector(7 downto 0) := "10000010"; constant nb7 : std_logic_vector(7 downto 0) := "11111000"; constant nb8 : std_logic_vector(7 downto 0) := "10000000"; constant nb9 : std_logic_vector(7 downto 0) := "10010000"; constant seg0 : std_logic_vector(3 downto 0) := "1110"; constant seg1 : std_logic_vector(3 downto 0) := "1101"; constant seg2 : std_logic_vector(3 downto 0) := "1011"; constant seg3 : std_logic_vector(3 downto 0) := "0111"; signal chiffre4 : integer range 9 downto 0 := 0; signal chiffre3 : integer range 9 downto 0 := 0; signal chiffre2 : integer range 9 downto 0 := 0; signal chiffre1 : integer range 9 downto 0 := 0; type mynumbers is array(9 downto 0) of std_logic_vector(7 downto 0); signal numbers : mynumbers := (nb9,nb8,nb7,nb6,nb5,nb4,nb3,nb2,nb1,nb0); ``` On a: - count_an : compte pour effectuer les opérations sur les afficheurs un par un. - clk_enable : diviser la clock pour l'affichage et évite les recouvrements. - clk_counter : divise la clock pour le compteur et lui évite de compter bien trop rapidement. - nb* : représentation des chiffres par leurs segments. - seg* : attribue chaque segment à une valeur constante. - chiffre* : variable représentant le chiffre en * position - numbers : associe la représentation logique d'un chiffre à un entier. Les process 1er process : ``` begin -- process d'affichage process(clk_fpga) begin if clk_fpga'event and clk_fpga = '1' then if clk_enable = 4999 then clk_enable <= 0; if count_an = 0 then aff <= numbers(chiffre4); an <= seg0; count_an <= count_an + 1; elsif count_an = 1 then aff <= numbers(chiffre3); an <= seg1; count_an <= count_an + 1; elsif count_an = 2 then aff <= numbers(chiffre2); an <= seg2; count_an <= count_an + 1; elsif count_an = 3 then aff <= numbers(chiffre1); an <= seg3; count_an <= 0; end if; else clk_enable <= clk_enable + 1; end if; end if; end process; ``` ## Résultats - Nous avons dans un premier temps essayer d'afficher sur les 4 afficheurs sans recouvrement. C'est pour cela qu'il a fallu baisser la clock. ![img1](img1.jpg) - Ensuite il a fallu donner du sens à ce que nous affichions. C'est pourquoi nous avons tenté d'afficher 1 2 3 4. ![img2](img2.jpg) - Enfin il a fallu implémanter un simple algorithme pour le compteur. ![counter](counter.gif)