Note

Bonjour et bienvenue dans la communauté SunFounder dédiée aux passionnés de Raspberry Pi, Arduino et ESP32 sur Facebook ! Explorez en profondeur les possibilités offertes par ces technologies avec d’autres amateurs éclairés.

Pourquoi nous rejoindre ?

Support d’experts : Résolvez les problèmes après-vente et surmontez les défis techniques grâce à l’aide de notre communauté et de notre équipe.
Apprendre & Partager : Échangez des astuces et des tutoriels pour perfectionner vos compétences.
Aperçus exclusifs : Bénéficiez d’un accès anticipé aux nouvelles annonces de produits et aux avant-premières.
Réductions spéciales : Profitez de réductions exclusives sur nos produits les plus récents.
Promotions festives et cadeaux : Participez à des concours et des promotions spéciales à l’occasion des fêtes.

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

2.1.5 Pavé numérique

Introduction

Un pavé numérique est un tableau rectangulaire de boutons. Dans ce projet, nous allons l’utiliser pour saisir des caractères.

Composants nécessaires

Pour ce projet, nous aurons besoin des composants suivants.

Schéma de circuit

Procédure expérimentale

Étape 1 : Construisez le circuit.

Étape 2 : Ouvrez le fichier de code.

cd ~/davinci-kit-for-raspberry-pi/python-pi5

Étape 3 : Exécutez le code.

sudo python3 2.1.5_Keypad.py

Une fois le code lancé, les valeurs des boutons pressés sur le pavé numérique (valeur des boutons) s’afficheront à l’écran.

Avertissement

En cas d’erreur RuntimeError: Cannot determine SOC peripheral base address, veuillez consulter Si gpiozero ne fonctionne pas..

Code

Note

Vous pouvez Modifier/Réinitialiser/Copier/Exécuter/Arrêter le code ci-dessous. Mais avant cela, assurez-vous de vous rendre dans le répertoire source, tel que davinci-kit-for-raspberry-pi/python-pi5. Après modification, vous pouvez exécuter le code pour observer le résultat.

#!/usr/bin/env python3
from gpiozero import DigitalOutputDevice, Button
from time import sleep

class Keypad:
    def __init__(self, rows_pins, cols_pins, keys):
        """
        Initialize the Keypad with specified row and column pins and keypad layout.
        :param rows_pins: List of GPIO pins for the rows.
        :param cols_pins: List of GPIO pins for the columns.
        :param keys: List of keys in the keypad layout.
        """
        # Initialisation des broches de lignes comme DigitalOutputDevice
        self.rows = [DigitalOutputDevice(pin) for pin in rows_pins]
        # Initialisation des broches de colonnes comme Boutons
        self.cols = [Button(pin, pull_up=False) for pin in cols_pins]
        self.keys = keys  # Définir la disposition des touches du pavé

    def read(self):
        """
        Read the currently pressed keys on the keypad.
        :return: A list of pressed keys.
        """
        pressed_keys = []
        # Parcourt chaque ligne et colonne pour identifier les touches pressées
        for i, row in enumerate(self.rows):
            row.on()  # Activer la ligne actuelle
            for j, col in enumerate(self.cols):
                if col.is_pressed:  # Vérifier si le bouton de la colonne est pressé
                    # Calculer l'index de la touche en fonction de la ligne et de la colonne
                    index = i * len(self.cols) + j
                    pressed_keys.append(self.keys[index])
            row.off()  # Désactiver la ligne actuelle
        return pressed_keys

try:
    # Configuration des broches de lignes, colonnes et disposition des touches
    rows_pins = [18, 23, 24, 25]
    cols_pins = [10, 22, 27, 17]
    keys = ["1", "2", "3", "A",
            "4", "5", "6", "B",
            "7", "8", "9", "C",
            "*", "0", "#", "D"]

    # Crée une instance de la classe Keypad
    keypad = Keypad(rows_pins, cols_pins, keys)
    last_key_pressed = []

    # Lecture continue du pavé et affichage des touches nouvellement pressées
    while True:
        pressed_keys = keypad.read()
        if pressed_keys and pressed_keys != last_key_pressed:
            print(pressed_keys)  # Afficher la liste des touches pressées
            last_key_pressed = pressed_keys
        sleep(0.1)  # Petite pause pour réduire la charge du CPU

except KeyboardInterrupt:
    # Gérer une interruption clavier (Ctrl+C) pour une sortie propre
    pass

Explication du code

Importation des classes DigitalOutputDevice et Button de la bibliothèque gpiozero et de la fonction sleep pour les temporisations.
```
#!/usr/bin/env python3
from gpiozero import DigitalOutputDevice, Button
from time import sleep
```

Définition de la classe Keypad. La méthode __init__ initialise le pavé avec les broches de lignes, de colonnes et les touches spécifiées. La méthode read parcourt le pavé et retourne la liste des touches pressées.

class Keypad:
    def __init__(self, rows_pins, cols_pins, keys):
        """
        Initialize the Keypad with specified row and column pins and keypad layout.
        :param rows_pins: List of GPIO pins for the rows.
        :param cols_pins: List of GPIO pins for the columns.
        :param keys: List of keys in the keypad layout.
        """
        self.rows = [DigitalOutputDevice(pin) for pin in rows_pins]
        self.cols = [Button(pin, pull_up=False) for pin in cols_pins]
        self.keys = keys

    def read(self):
        """
        Read the currently pressed keys on the keypad.
        :return: A list of pressed keys.
        """
        pressed_keys = []
        # Scan each row and column to identify pressed keys
        for i, row in enumerate(self.rows):
            row.on()  # Enable the current row
            for j, col in enumerate(self.cols):
                if col.is_pressed:  # Check if the column button is pressed
                    # Calculate the key index based on row and column
                    index = i * len(self.cols) + j
                    pressed_keys.append(self.keys[index])
            row.off()  # Disable the current row
        return pressed_keys

Configure les broches GPIO pour les lignes et les colonnes, et définit la disposition du pavé.

try:
    # Configure rows, columns, and keypad layout
    rows_pins = [18, 23, 24, 25]
    cols_pins = [10, 22, 27, 17]
    keys = ["1", "2", "3", "A",
            "4", "5", "6", "B",
            "7", "8", "9", "C",
            "*", "0", "#", "D"]

Crée une instance de la classe Keypad avec la configuration spécifiée.

try:
    ...

    # Create an instance of the Keypad class
    keypad = Keypad(rows_pins, cols_pins, keys)
    last_key_pressed = []

Lecture continue du pavé pour détecter les nouvelles touches pressées et affichage des changements d’état des touches. Le script s’arrête proprement lors d’une interruption clavier (Ctrl+C).

try:
    ...

    # Continuously read the keypad and print newly pressed keys
    while True:
        pressed_keys = keypad.read()
        if pressed_keys and pressed_keys != last_key_pressed:
            print(pressed_keys)  # Print the list of pressed keys
            last_key_pressed = pressed_keys
        sleep(0.1)  # Short delay to reduce CPU load

except KeyboardInterrupt:
    # Handle a keyboard interrupt (Ctrl+C) for a clean exit
    pass