# 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 propre et plus ou moins factorisé.

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

     -- display process

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

     Ce premier process permet à chaque tick de clock + diviseur d'afficher un chiffre sur le premier afficheur. Au prochain tick sur le second puis le 3ème et enfin le 4ème. Ensuite l'algorithme boucle.

  
     > le diviseur (clk_enable) ralentit la cadence de switch entre afficheur. Si l'on ne divise du fait de la vitesse les chiffres ne s'affichent pas correctement. 
  

     Ainsi la logique et l'électronique étant ici très rapide devant la fréquence de perception de l'oeil humain, l'utilisateur à l'impression que l'affichage et statique et que rien ne clignote.

  
     - 2ème processus :
  
     ```
     -- process counter
     process(clk_fpga)
     begin
        if clk_fpga'event and clk_fpga = '1' then
           if clk_counter = 2999999 then 
              clk_counter <= 0; 
              if reset = '1' then 
                 chiffre1 <= 0;
                 chiffre2 <= 0;
                 chiffre3 <= 0;
                 chiffre4 <= 0;
              else if chiffre4 = 9 then
                 chiffre4 <= 0; 
                 if chiffre3 = 9 then 
                    chiffre3 <= 0;
                    if chiffre2 = 9 then 
                       chiffre2 <= 0;
                          if chiffre1 = 9 then 
                             chiffre1 <= 0;
                          else 
                             chiffre1 <= chiffre1 + 1;
                          end if;
                    else 
                       chiffre2 <= chiffre2 + 1;
                    end if;
                 else 
                    chiffre3 <= chiffre3 + 1;
                 end if;
              else 
                 chiffre4 <= chiffre4 + 1;
              end if;
           else 
              clk_counter <= clk_counter + 1;
           end if;
        end if;
     end process;
     end Behavioral;
     ```

  
     Ce processus permet de compter avec un diviseur de la clock de base.

     Lorsque le chiffre tout à droite et à 9 et qu'il doit être incrémenté alors il passe à 0. Si le chiffre à sa gauche n'est pas à 9 alors il est incrémenter sinon il passe à 0 et on regarde le chiffre de gauche en suivant le même algorithme. 

     Si on a 9999 ou un 1 logique sur reset alors tous les chiffres repassent à 0.

  ## 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émenter un simple algorithme pour le compteur.

  ![counter](counter.gif)