Note

Bonjour et bienvenue dans la Communauté Facebook des passionnés de Raspberry Pi, Arduino et ESP32 de SunFounder ! Plongez plus profondément dans l’univers des Raspberry Pi, Arduino et ESP32 avec d’autres passionnés.

Pourquoi rejoindre ?

  • Support d’experts : Résolvez les problèmes après-vente et les défis techniques avec l’aide de notre communauté et de notre équipe.

  • Apprendre et partager : Échangez des astuces et des tutoriels pour améliorer 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 produits les plus récents.

  • Promotions festives et cadeaux : Participez à des cadeaux et des promotions de vacances.

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

1.1.5 Afficheur 7 segments 4 chiffres

Introduction

Ensuite, suivez-moi pour essayer de contrôler l’afficheur 7 segments à 4 chiffres.

Composants nécessaires

Dans ce projet, nous avons besoin des composants suivants.

../_images/list_4_digit.png

Il est certainement pratique d’acheter un kit complet, voici le lien :

Nom

ARTICLES DANS CE KIT

LIEN

Kit Raphael

337

Raphael Kit

Vous pouvez également les acheter séparément en suivant les liens ci-dessous.

PRÉSENTATION DU COMPOSANT

LIEN D’ACHAT

Carte d’extension GPIO

ACHETER

Plaque d’expérimentation (Breadboard)

ACHETER

Fils de Liaison

ACHETER

Résistance

ACHETER

Affichage à 7 segments 4 chiffres

-

74HC595

ACHETER

Schéma de connexion

Nom T-Board

physique

wiringPi

BCM

GPIO17

Pin 11

0

17

GPIO27

Pin 13

2

27

GPIO22

Pin 15

3

22

SPIMOSI

Pin 19

12

10

GPIO18

Pin 12

1

18

GPIO23

Pin 16

4

23

GPIO24

Pin 18

5

24
../_images/schmatic_4_digit.png

Procédures expérimentales

Étape 1 : Construisez le circuit.

../_images/image80.png

Étape 2 : Allez dans le dossier du code.

cd ~/raphael-kit/python/

Étape 3 : Exécutez le fichier exécutable.

sudo python3 1.1.5_4-Digit.py

Après l’exécution du code, le programme effectue un comptage, augmentant de 1 par seconde, et l’afficheur 4 chiffres affiche le compteur.

Code

Note

Vous pouvez Modifier/Réinitialiser/Copier/Exécuter/Arrêter le code ci-dessous. Mais avant cela, vous devez aller dans le chemin du code source comme raphael-kit/python. Après avoir modifié le code, vous pouvez l’exécuter directement pour voir l’effet.

import RPi.GPIO as GPIO
import time
import threading

SDI = 24
RCLK = 23
SRCLK = 18

placePin = (10, 22, 27, 17)
number = (0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90)

counter = 0
timer1 = 0

def clearDisplay():
    for i in range(8):
        GPIO.output(SDI, 1)
        GPIO.output(SRCLK, GPIO.HIGH)
        GPIO.output(SRCLK, GPIO.LOW)
    GPIO.output(RCLK, GPIO.HIGH)
    GPIO.output(RCLK, GPIO.LOW)

def hc595_shift(data):
    for i in range(8):
        GPIO.output(SDI, 0x80 & (data << i))
        GPIO.output(SRCLK, GPIO.HIGH)
        GPIO.output(SRCLK, GPIO.LOW)
    GPIO.output(RCLK, GPIO.HIGH)
    GPIO.output(RCLK, GPIO.LOW)

def pickDigit(digit):
    for i in placePin:
        GPIO.output(i,GPIO.LOW)
    GPIO.output(placePin[digit], GPIO.HIGH)

def timer():
    global counter
    global timer1
    timer1 = threading.Timer(1.0, timer)
    timer1.start()
    counter += 1
    print("%d" % counter)

def loop():
    global counter
    while True:
        clearDisplay()
        pickDigit(0)
        hc595_shift(number[counter % 10])

        clearDisplay()
        pickDigit(1)
        hc595_shift(number[counter % 100//10])

        clearDisplay()
        pickDigit(2)
        hc595_shift(number[counter % 1000//100])

        clearDisplay()
        pickDigit(3)
        hc595_shift(number[counter % 10000//1000])

def setup():
    GPIO.setmode(GPIO.BCM)
    GPIO.setup(SDI, GPIO.OUT)
    GPIO.setup(RCLK, GPIO.OUT)
    GPIO.setup(SRCLK, GPIO.OUT)
    for i in placePin:
        GPIO.setup(i, GPIO.OUT)
    global timer1
    timer1 = threading.Timer(1.0, timer)
    timer1.start()

def destroy():   # When "Ctrl+C" is pressed, the function is executed.
    global timer1
    GPIO.cleanup()
    timer1.cancel()  # cancel the timer

if __name__ == '__main__':
    setup()
    try:
        loop()
    except KeyboardInterrupt:
        destroy()

Explication du Code

placePin = (10, 22, 27, 17)

Ces quatre broches contrôlent les broches d’anode commune des affichages 7 segments à quatre chiffres.

number = (0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90)

Un tableau de codes de segments de 0 à 9 en hexadécimal (anode commune).

def clearDisplay():
    for i in range(8):
        GPIO.output(SDI, 1)
        GPIO.output(SRCLK, GPIO.HIGH)
        GPIO.output(SRCLK, GPIO.LOW)
GPIO.output(RCLK, GPIO.HIGH)
GPIO.output(RCLK, GPIO.LOW)

Écrire « 1 » huit fois dans SDI, de sorte que les huit LED de l’affichage à 7 segments s’éteignent afin de vider le contenu affiché.

def pickDigit(digit):
    for i in placePin:
        GPIO.output(i,GPIO.LOW)
    GPIO.output(placePin[digit], GPIO.HIGH)

Sélectionner l’emplacement de la valeur. Il ne doit y avoir qu’un seul emplacement activé à la fois. L’emplacement activé sera mis à HIGH.

def loop():
    global counter
    while True:
        clearDisplay()
        pickDigit(0)
        hc595_shift(number[counter % 10])

        clearDisplay()
        pickDigit(1)
        hc595_shift(number[counter % 100//10])

        clearDisplay()
        pickDigit(2)
        hc595_shift(number[counter % 1000//100])

        clearDisplay()
        pickDigit(3)
        hc595_shift(number[counter % 10000//1000])

La fonction est utilisée pour définir le nombre affiché sur l’affichage 7 segments à 4 chiffres.

Tout d’abord, démarrez le quatrième segment de l’affichage, écrivez le chiffre des unités. Ensuite, démarrez le troisième segment de l’affichage et tapez le chiffre des dizaines ; après cela, démarrez respectivement le deuxième et le premier segment de l’affichage et écrivez respectivement les chiffres des centaines et des milliers. Étant donné que la vitesse de rafraîchissement est très rapide, nous voyons un affichage complet à quatre chiffres.

timer1 = threading.Timer(1.0, timer)
timer1.start()

Le module threading est le module de threading courant en Python, et Timer en est une sous-classe. Le prototype du code est :

class threading.Timer(interval, function, args=[], kwargs={})

Après l’intervalle, la fonction sera exécutée. Ici, l’intervalle est de 1,0 et la fonction est timer(). start () signifie que le Timer commencera à ce moment-là.

def timer():
    global counter
    global timer1
    timer1 = threading.Timer(1.0, timer)
    timer1.start()
    counter += 1
    print("%d" % counter)

Après que le Timer atteigne 1,0 s, la fonction Timer est appelée ; ajouter 1 à counter, et le Timer est utilisé à nouveau pour s’exécuter lui-même de manière répétée toutes les secondes.

Image du Phénomène

../_images/image81.jpeg