Dans cet article, nous branchons à un Raspberry Pi Pico un petit clavier numérique à 16 touches, et nous utilisons micropython pour interpréter correctement les touches qui ont été enfoncées.
Il s'agit d'un clavier matriciel: les 16 interrupteurs sont reliés entre eux par groupes de quatre, de façon à former des lignes et des colonnes.
Au moyen d'un multimètre, on peut facilement constater que les 4 connecteurs de gauche sont reliés aux lignes horizontales, alors que les 4 connecteurs de droite sont reliés aux colonnes verticales. Par exemple, si j'appuie sur la touche 1, la résistance électrique devient nulle entre le connecteur "ligne 1" et le connecteur "colonne 1":
L'avantage de cette disposition matricielle, c'est l'économie de connecteurs: on peut brancher les 16 touches du clavier avec 8 fils conducteurs alors qu'il faudrait au moins 17 fils pour brancher chaque touche à sa propre entrée du microcontrôleur. En contrepartie, la programmation est un petit peu plus compliquée car pour détecter et identifier une touche enfoncée, il faut modifier successivement le niveau logique de chaque ligne et vérifier, dans chaque cas, le niveau logique de toutes les colonnes.
Connexions du clavier au Raspberry Pi Pico
Le script montré à la prochaine section suppose que les 8 connecteurs du clavier numérique sont branchés, dans l'ordre, aux broches GP1 à GP8 du Raspberry Pi Pico:
- Broche 1 du clavier (à l'extrême gauche): Broche GP1 du Raspberry Pi Pico
- Broche 2 du clavier: Broche GP2 du Raspberry Pi Pico
- Broche 3 du clavier: Broche GP3 du Raspberry Pi Pico
- ...
- Broche 8 du clavier (à l'extrême droite): Broche GP8 du Raspberry Pi Pico
Il est parfaitement possible d'utiliser une connexion différente, mais il faudra alors modifier le script.
Script "mot de passe"
Le script en micropython présenté ci-dessous demande un mot de passe, et il exécute ensuite le programme principal si on a entré le bon mot de passe (dans ce cas, le "programme principal" se limite à faire clignoter la LED du Pico).
Pour que le script soit facile à utiliser peu importe votre matériel, j'ai choisi un affichage dans la console. Vous pourrez facilement adapter le script pour l'afficheur (OLED, LCD, etc.) de votre choix (ou, bien entendu, pour toute application où le clavier servirait à écrire autre chose qu'un mot de passe).
print('*', end='')
| ''' | |
| Clavier 4 X 4 branché à un Raspberry Pi Pico | |
| Il faut entrer le bon mot de passe | |
| Pour plus de détails: | |
| https://electroniqueamateur.blogspot.com/2022/07/clavier-numerique-et-raspberry-pi-pico.html | |
| ''' | |
| from machine import Pin | |
| import utime | |
| # les lignes du clavier sont branchées aux broches | |
| # GP1, GP2, GP3, GP4 du pico | |
| broches_lignes = [1,2,3,4] | |
| # les colonnes du clavier sont branchées aux broches | |
| # GP5, GP6, GP7, GP8 du pico | |
| broches_colonnes = [5,6,7,8] | |
| # matrice définissant chaque touche du clavier | |
| clavier = [["1","2","3","A"],["4","5","6","B"],\ | |
| ["7","8","9","C"],["*","0","#","D"]] | |
| # les lignes sont réglées en sorties, niveau logique haut | |
| for x in range(0,4): | |
| broches_lignes[x]=Pin(broches_lignes[x], Pin.OUT) | |
| broches_lignes[x].value(1) | |
| # les colonnes réglées en entrée | |
| for x in range(0,4): | |
| broches_colonnes[x] = Pin(broches_colonnes[x], Pin.IN, Pin.PULL_UP) | |
| # routine qui identifie la touche enfoncée: | |
| def lecture_touche (cols,lignes): | |
| for i in lignes: # une ligne à la fois | |
| i.value(0) # on met la ligne au niveau logique bas | |
| # on mesure chaque colonne de cette ligne | |
| resultat=[cols[0].value(),cols[1].value(),cols[2].value(),cols[3].value()] | |
| if min(resultat)==0: | |
| reponse = clavier[int(lignes.index(i))][int(resultat.index(0))] | |
| i.value(1) # au cas où une touche est maintenue enfoncée | |
| return(reponse) | |
| i.value(1) # retour au niveau logique haut | |
| # variables relatives à la demande de mot de passe: | |
| correct = '662607004' # le bon mot de passe | |
| tentative = '' # le mot de passe écrit par l'utilisateur | |
| autorisation = False # le mot de passe n'a pas encore été accepté | |
| led = Pin(25, Pin.OUT) # pour faire clignoter la LED embarquée | |
| print("Bonjour, veuillez entrer le mot de passe") | |
| print("(# pour terminer)") | |
| while not autorisation: | |
| touche = lecture_touche(broches_colonnes, broches_lignes) | |
| if touche != None: | |
| if (touche == '#'): # on vérifie le mot de passe | |
| if (tentative == correct): | |
| print('') | |
| print ("C'est le bon mot de passe!") | |
| autorisation = True | |
| else: | |
| print('') | |
| print("Ce n'est pas le bon mot de passe. Recommencez.") | |
| tentative = '' | |
| else: | |
| tentative = tentative + touche | |
| print(touche, end='') ## ou encore print('*', end='') | |
| utime.sleep(0.3) # delai anti-rebond | |
| while autorisation: | |
| # on peut maintenant exécuter le programme principal | |
| # ... faire clignoter la LED... | |
| led.value(1) | |
| utime.sleep(1) | |
| led.value(0) | |
| utime.sleep(1) | |
-
Pourquoi ce mot de passe?
Le choix du mot de passe "662607004" est une référence à la série télévisée Stranger Things: dans le dernier épisode de la troisième saison, Hopper et Joyce, qui sont à l'intérieur de la basse secrète russe, doivent entrer un code secret qui est la constante de Planck.
(Il semble toutefois que les chiffres utilisés correspondent à la constante de Planck telle que révisée en 2014, alors que l'action se déroule en 1985).
