.. note:: 

    Bonjour et bienvenue dans la communauté des passionnés de Raspberry Pi, Arduino et ESP32 de SunFounder sur Facebook ! Plongez dans l'univers du Raspberry Pi, d'Arduino et de l'ESP32 avec d'autres passionnés.

    **Pourquoi nous rejoindre ?**

    - **Assistance d'experts** : Résolvez vos problèmes après achat et vos défis techniques avec l'aide de notre communauté et de notre équipe.
    - **Apprendre et partager** : Échangez des astuces et des tutoriels pour perfectionner vos compétences.
    - **Aperçus exclusifs** : Accédez en avant-première aux annonces de nouveaux produits et aux aperçus.
    - **Réductions spéciales** : Profitez de réductions exclusives sur nos derniers produits.
    - **Promotions festives et concours** : Participez à des concours et promotions pendant les fêtes.

    👉 Prêt à explorer et créer avec nous ? Cliquez sur [|link_sf_facebook|] et rejoignez-nous dès aujourd'hui !

.. _ar_4_digit:

2.7 Affichage 4-Digits à 7 Segments
=======================================

Aperçu
------------

Dans cette leçon, vous apprendrez à utiliser un affichage à 4 digits de 
7 segments. Il se compose de quatre afficheurs de 7 segments fonctionnant 
ensemble pour afficher des nombres à 4 chiffres.

Composants requis
----------------------

.. image:: img/list_2.7.png

* :ref:`cpn_mega2560`
* :ref:`cpn_breadboard`
* :ref:`cpn_wires`
* :ref:`cpn_resistor`
* :ref:`cpn_4_digit`

Schéma de connexion
----------------------

.. image:: img/image438.png

Schéma électronique
---------------------

.. image:: img/image439.png

Code
------

.. note::

    * Vous pouvez ouvrir directement le fichier ``2.7_4digitalSegment.ino`` situé dans le chemin ``sunfounder_vincent_kit_for_arduino\code\2.7_4digitalSegment``.

.. raw:: html

    <iframe src=https://create.arduino.cc/editor/sunfounder01/1a717c75-35df-4674-be90-a5d290f7065d/preview?embed style="height:510px;width:100%;margin:10px 0" frameborder=0></iframe>

Analyse du Code
-------------------

Essentiellement, ce code utilise le multiplexage pour afficher un nombre à 4 chiffres sur un afficheur 7 segments. En basculant rapidement entre les chiffres et en affichant un chiffre à la fois, il donne l'illusion que tous les chiffres sont affichés en continu. 
La fonction chronomètre est réalisée grâce à la fonction ``millis()`` intégrée, qui suit le temps et incrémente le nombre affiché toutes les secondes.

#. Définitions des Variables et des Constantes :

    .. code-block:: arduino

        int segmentPins[] = {2, 3, 4, 5, 6, 7, 8, 9};
        int digitPins[] = {13, 12, 11, 10};

        long n = 0; // Variable pour stocker le nombre actuel du chronomètre
        int del = 5; // Temps de délai (en ms) pour maintenir chaque chiffre allumé
        unsigned long previousMillis = 0; // Temps du dernier incrément
        const long interval = 1000; // Intervalle d'une seconde (en ms)


    * Les tableaux ``segmentPins`` et ``digitPins`` définissent les broches connectées aux segments et aux chiffres de l'afficheur, respectivement.
    * ``n`` est une variable longue qui garde la trace du nombre actuel du chronomètre.
    * ``del`` est le délai pour afficher le chiffre actuel avant de passer au suivant.
    * ``previousMillis`` et ``interval`` sont liés à la temporisation pour décider quand incrémenter le chronomètre.

#. Modèles des Chiffres pour Affichage à 7 Segments :

    Le tableau 2D ``numbers`` définit comment chaque chiffre de 0 à 9 est représenté sur un afficheur 7 segments. Chaque sous-tableau a 8 valeurs (HIGH ou LOW), correspondant aux 7 segments et au point décimal. Ce modèle permet d'allumer les segments appropriés pour chaque chiffre.

    .. code-block:: arduino

        byte numbers[10][8] = {
            {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, LOW, LOW},  // 0
            {LOW, HIGH, HIGH, LOW, LOW, LOW, LOW, LOW},      // 1
            {HIGH, HIGH, LOW, HIGH, HIGH, LOW, HIGH, LOW},   // 2
            {HIGH, HIGH, HIGH, HIGH, LOW, LOW, HIGH, LOW},   // 3
            {LOW, HIGH, HIGH, LOW, LOW, HIGH, HIGH, LOW},    // 4
            {HIGH, LOW, HIGH, HIGH, LOW, HIGH, HIGH, LOW},   // 5
            {HIGH, LOW, HIGH, HIGH, HIGH, HIGH, HIGH, LOW},  // 6
            {HIGH, HIGH, HIGH, LOW, LOW, LOW, LOW, LOW},     // 7
            {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, LOW}, // 8
            {HIGH, HIGH, HIGH, HIGH, LOW, HIGH, HIGH, LOW}   // 9
        }; 

#. Fonction d'Initialisation (Setup) :

    .. code-block:: arduino

        void setup() {
            // Configure toutes les broches de segments et de chiffres en mode OUTPUT
            for (int i = 0; i < 8; i++) {
                pinMode(segmentPins[i], OUTPUT);
            }
            for (int i = 0; i < 4; i++) {
                pinMode(digitPins[i], OUTPUT);
                digitalWrite(digitPins[i], HIGH); // Éteindre tous les chiffres initialement (HIGH signifie OFF pour les afficheurs à cathode commune)
            }
        }

    * Toutes les broches de segments et de chiffres sont configurées en mode OUTPUT car elles contrôlent les segments et les chiffres de l'afficheur.
    * Initialement, tous les chiffres sont éteints en écrivant HIGH pour un afficheur à cathode commune.

#. Boucle Principale (Loop) :

    .. code-block:: arduino

        void loop() {
            // Vérifie si une seconde est passée depuis le dernier incrément
            if (millis() - previousMillis >= interval) {
                previousMillis += interval; // Mettre à jour le dernier temps d'incrément
                n = (n + 1) % 10000; // Incrémenter le chronomètre et revenir à 0 après 9999
            }

            displayNumber(n); // Affiche le nombre actuel du chronomètre
        }

    * Cette section vérifie si l'intervalle (défini à 1000 ms ou 1 seconde) est écoulé depuis le dernier incrément. Si oui, elle incrémente le nombre.
    * Le nombre est ensuite affiché sur le 7 segments en utilisant la fonction ``displayNumber()``.

#. Fonction ``displayNumber()`` :

    .. code-block:: arduino

        // Fonction pour afficher un nombre à 4 chiffres sur le 7 segments
        void displayNumber(long num) {
            for (int digit = 0; digit < 4; digit++) {
                clearLEDs(); // Éteint tous les segments et chiffres
                pickDigit(digit); // Active le chiffre actuel
                int value = (num / (int)pow(10, 3 - digit)) % 10; // Extrait le chiffre spécifique
                pickNumber(value); // Allume les segments pour afficher le chiffre
                delay(del); // Maintient le chiffre allumé un court instant
            }
        }

    * Cette fonction décompose le nombre à 4 chiffres en chiffres individuels et affiche chaque chiffre un à un rapidement, créant l'illusion que tous les chiffres sont affichés simultanément grâce à la persistance rétinienne.
    * Pour chaque chiffre, la fonction éteint d'abord tous les segments, sélectionne le chiffre approprié avec ``pickDigit()``, et affiche le nombre sur ce chiffre avec ``pickNumber()``.
    * Le ``delay(del)`` garantit que chaque chiffre est visible brièvement avant de passer au suivant.

#. Fonction ``pickDigit()`` :

    Cette fonction sélectionne (ou active) un des quatre chiffres de l'afficheur 7 segments en réglant la broche du chiffre correspondant à LOW.

    .. code-block:: arduino

        void pickDigit(int x) {
            digitalWrite(digitPins[x], LOW); // Allume le chiffre sélectionné (LOW signifie ON pour les afficheurs à cathode commune)
        }


#. Fonction ``pickNumber()`` :

    Cette fonction, donnée un seul chiffre (0-9), active les segments de l'afficheur pour afficher ce chiffre. Elle utilise le tableau ``numbers`` pour savoir quels segments allumer/éteindre.

    .. code-block:: arduino

        void pickNumber(int x) {
            for (int i = 0; i < 8; i++) {
                digitalWrite(segmentPins[i], numbers[x][i]); // Définit chaque segment selon le modèle pour le chiffre donné
            }
        }


#. Fonction ``clearLEDs()`` :

    Comme son nom l'indique, cette fonction éteint tous les segments et chiffres. Elle est utilisée pour s'assurer qu'un seul chiffre est actif à la fois pendant le multiplexage dans ``displayNumber()``.

    .. code-block:: arduino

        void clearLEDs() {
            for (int i = 0; i < 8; i++) {
                digitalWrite(segmentPins[i], LOW); // Éteint tous les segments
            }
            for (int i = 0; i < 4; i++) {
                digitalWrite(digitPins[i], HIGH); // Éteint tous les chiffres
            }
        }

Illustration du Phénomène
-----------------------------

.. image:: img/image104.jpeg