Note

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

Pourquoi nous rejoindre ?

  • Support d’experts : Résolvez vos problèmes après-vente et surmontez vos défis techniques grâce à l’aide de notre communauté et de notre équipe.

  • Apprendre & Partager : Échangez des astuces et des tutoriels pour améliorer vos compétences.

  • Aperçus exclusifs : Obtenez un accès anticipé aux annonces de nouveaux produits et à des avant-premières.

  • Réductions spéciales : Profitez de remises exclusives sur nos derniers produits.

  • Promotions festives et cadeaux : Participez à des concours et à des promotions pendant les fêtes.

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

Afficheur 7 segments à 4 chiffres

Introduction

Dans ce projet, nous allons apprendre à contrôler un afficheur 7 segments à 4 chiffres.

Composants

../_images/list_4_digit2.png

Note

Dans ce projet, nous utilisons un modèle BS pour l’afficheur 7 segments à 4 chiffres. Si vous utilisez un modèle AS, il se peut qu’il ne s’allume pas.

Schéma de câblage

../_images/schmatic_4_digit2.png

Procédures expérimentales

Étape 1 : Construire le circuit.

../_images/image802.png

Étape 2 : Accéder au dossier du code.

cd ~/davinci-kit-for-raspberry-pi/nodejs/

Étape 3 : Exécuter le code.

sudo node 4_digit_7_segment_display.js

Après l’exécution du code, le programme commence à compter, en augmentant de 1 chaque seconde, et l’afficheur 7 segments à 4 chiffres affiche le nombre correspondant.

Code

const Gpio = require('pigpio').Gpio;

var counter = 0;

const number = [0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90]; //for BS

const SDI = new Gpio(24, { mode: Gpio.OUTPUT });
const RCLK = new Gpio(23, { mode: Gpio.OUTPUT });
const SRCLK = new Gpio(18, { mode: Gpio.OUTPUT });

const pin1 = new Gpio(10, { mode: Gpio.OUTPUT });
const pin2 = new Gpio(22, { mode: Gpio.OUTPUT });
const pin3 = new Gpio(27, { mode: Gpio.OUTPUT });
const pin4 = new Gpio(17, { mode: Gpio.OUTPUT });
const placePin = [pin1, pin2, pin3, pin4];

function clearDisplay() {
    hc595_shift(0xff); //for BS
}

function hc595_shift(dat) {
    for (let j = 0; j < 8; j++) {
        let code = 0x80 & (dat << j);
        if (code != 0) {
            code = 1;
        }
        SDI.digitalWrite(code);
        SRCLK.trigger(1,1);
    }
    RCLK.trigger(1,1);
}

function pickDigit(digit) {
    for(let i=0;i<4;i++){
        placePin[i].digitalWrite(0);
    }
    placePin[digit].digitalWrite(1);
}


let digit = -1
setInterval(() => {
    digit = (digit +1)% 4
    clearDisplay();
    pickDigit(digit);
    switch(digit){
        case 0:
            hc595_shift(number[Math.floor(counter % 10)]);
            break;
        case 1:
            hc595_shift(number[Math.floor(counter % 100 / 10)]);
            break;
        case 2:
            hc595_shift(number[Math.floor(counter % 1000 / 100)]);
            break;
        case 3:
            hc595_shift(number[Math.floor(counter % 10000 / 1000)]);
            break;
    }
}, 5);

setInterval(() => {
    counter++;
}, 1000);

Explication du code

const pin1 = new Gpio(10, {mode: Gpio.OUTPUT});
const pin2 = new Gpio(25, {mode: Gpio.OUTPUT});
const pin3 = new Gpio(27, {mode: Gpio.OUTPUT});
const pin4 = new Gpio(17, {mode: Gpio.OUTPUT});
const placePin = [pin1,pin2,pin3,pin4];

Initialiser les broches 10, 25, 27 et 17 en mode sortie et les placer dans le tableau placePin pour faciliter le contrôle de l’anode commune de l’afficheur 7 segments à 4 chiffres.

const number = [0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90];

Définir un tableau constant number pour représenter les codes hexadécimaux des segments de 0 à 9 (anode commune).

function clearDisplay() {
    hc595_shift(0xff);
}

Écrire 0xff pour éteindre l’afficheur.

function pickDigit(digit) {
    for(let i=0;i<4;i++){
        placePin[i].digitalWrite(0);
    }
    placePin[digit].digitalWrite(1);
}

Sélectionner le chiffre à afficher. Une seule position doit être activée à la fois. La position activée sera définie à l’état haut.

let digit = -1
setInterval(() => {
    digit = (digit +1)% 4
    clearDisplay();
    pickDigit(digit);
    switch(digit){
        case 0:
            hc595_shift(number[Math.floor(counter % 10)]);
            break;
        case 1:
            hc595_shift(number[Math.floor(counter % 100 / 10)]);
            break;
        case 2:
            hc595_shift(number[Math.floor(counter % 1000 / 100)]);
            break;
        case 3:
            hc595_shift(number[Math.floor(counter % 10000 / 1000)]);
            break;
    }
}, 5);

Ce code est utilisé pour définir le chiffre affiché sur l’afficheur 7 segments à 4 chiffres.

Tout d’abord, on active le quatrième segment, puis on y écrit le chiffre des unités. Ensuite, on active le troisième segment et on y écrit le chiffre des dizaines. Puis on active le second et le premier segment respectivement pour y afficher les centaines et les milliers. Comme la vitesse de rafraîchissement est très rapide, on perçoit un affichage complet de quatre chiffres.

setInterval(() => {
    counter++;
}, 1000);

Ajouter une unité au counter chaque seconde qui passe (ce qui correspond à l’affichage incrémenté d’une unité chaque seconde).

Image du résultat

../_images/image811.jpeg