Ludik Hat

François Mocq aime partager sa passion pour le Raspberry Pi. Il a créé le blog Framboise 314 et a écrit de nombreux livres sur le sujet. Avant les restriction liées au COVID, il animait régulièrement des séances de découverte des possibilités du Raspberry Pi. Ces derniers temps il a conçu avec Dominique Meurisse (un autre auteur des Editions ENI) une carte Hat pédagogique inspirée de la carte multifonction Arduino.

Ludik Hat pour Raspberry Pi

Le Ludik Hat m’a été envoyé gratuitement par Dominique lors de ma dernière commande dans sa boutique (MCHobby). Nous pouvons donc considérer qu’il s’agit d’un article sponsorisé, mais je conserve une totale liberté. Je n’hésiterai donc pas à vous dire franchement ce que je pense de cette carte (même si Dominique et François sont des amis).

Le Ludik Hat fait la même taille qu’un Raspberry pi, il possède :

  • 4 LED classiques (verte, orange, rouge, jaune)
  • 4 boutons poussoirs
  • 1 buzzer
  • 1 module relais (250V)
  • 1 potentiomètre
  • 1 joystick analogique
  • 1 photorésistance
  • 4 LED RGB (Neopixel)
  • 1 capteur de température DS18B20
  • 2 connecteurs StemmaQt ou Qwiic
  • 2 Connecteurs Gravity
  • 1 Connecteur Grove
  • De nombreux connecteurs pour breadboard (entrées analogiques, GPIO, 3.3V, 5V, GND)

Voilà un petit aperçu en vidéo

La carte est destinée au Raspberry Pi. François et Dominique ont déjà commencé à en parler et je vais les laisser continuer parce qu’ils le feront mieux que moi.

J’ai choisi de tester le Ludik Hat avec le Raspberry Pico et pour cela, le PicoHat (que j’ai présenté dans le précèdent article) fera parfaitement l’affaire puisqu’il possède justement un connecteur compatible. Le branchement est extrêmement simple puisqu’il suffit d’insérer le Ludik Hat dans le connecteur HAT du PicoHat.

Branchement du Ludik Hat sur le PicoHat (avec un Raspberry Pi Pico)

Programmation

Commençons par une petite mise à jour du Raspberry Pico (voir mon article de présentation du Raspberry Pico).

Mise à jour du Raspberry Pi Pico

Conversion des numéro de Pin en GPIO

La carte est auto documentée (les numéros GPIO sont inscrit sur la carte). C’est très pratique pour les utilisateurs du Raspberry Pi, puisqu’il n’est pas nécessaire d’avoir en permanence la documentation sous les yeux. Mais les GPIO ne correspondent pas toujours aux ports du Raspberry Pico. Pour résoudre le problème, j’ai créé une liste qui contient les numéro de port correspondant aux GPIO. Ajoutez simplement cette ligne au début de votre programme :

GPIO = [None,None,8,9,2,3,14,10,5,4,7,6,20,21,0,1,16,17,18,19,27,28,22,11,12,13,26,15]

Ensuite, vous pouvez indiquez le numéro de GPIO (inscrit sur la carte) sous cette forme :

GPIO[12] # Le GPIO 12 (LED verte) correspond au port 20 du Raspberry Pico

Et il sera automatiquement converti en numéro de pin du Raspberry Pico.

LED classiques

Les LED Verte, Orange, Rouge et Jaune sont reliées aux GPIO 12, 26, 27 et 6. Voilà un petit exemple d’animation avec les 4 LED.

# Appel des bibliothèques
from machine import Pin
import time
#Conversion des numéro de Pin du Pico en numéro de GPIO
GPIO = [None,None,8,9,2,3,14,10,5,4,7,6,20,21,0,1,16,17,18,19,27,28,22,11,12,13,26,15]
# Définition des éléments reliés aux ports du Pico
ledVerte = Pin(GPIO[12], Pin.OUT)
ledOrange = Pin(GPIO[26], Pin.OUT)
ledRouge = Pin(GPIO[27], Pin.OUT)
ledJaune = Pin(GPIO[6], Pin.OUT)
# Boucle infinie
while True:
  # Allumer la LED Verte
  ledVerte.value(1)
  # Attends 1 seconde
  time.sleep(1)
  # Allumer la LED Orange
  ledOrange.value(1)
  # Attends 1 seconde
  time.sleep(1)
  # Allumer la LED Rouge
  ledRouge.value(1)
  # Attends 1 seconde
  time.sleep(1)
  # Allumer la LED Jaune
  ledJaune.value(1)
  # Attends 1 seconde
  time.sleep(1)
  # Eteindre toutes les LED
  ledVerte.value(0)
  ledOrange.value(0)
  ledRouge.value(0)
  ledJaune.value(0)
  # Attends 1 seconde 
  time.sleep(1)

J’aime beaucoup simuler un feu tricolore avec des LED. Et bien, c’est très facile avec le Ludik Hat puisque les LED sont dans le bon ordre (il suffit simplement d’oublier la LED jaune).

# Appel des bibliothèques
from machine import Pin
import time
#Conversion des numéro de Pin du Pico en numéro de GPIO
GPIO = [None,None,8,9,2,3,14,10,5,4,7,6,20,21,0,1,16,17,18,19,27,28,22,11,12,13,26,15]
# Définition des éléments reliés aux ports du Pico
ledVerte = Pin(GPIO[12], Pin.OUT)
ledOrange = Pin(GPIO[26], Pin.OUT)
ledRouge = Pin(GPIO[27], Pin.OUT)
# Boucle infinie
while True:
  # Feu vert
  ledRouge.value(0)
  ledOrange.value(0)
  ledVerte.value(1)
  # Attends 5 secondes 
  time.sleep(5)
  # Feu orange
  ledRouge.value(0)
  ledOrange.value(1)
  ledVerte.value(0)
  # Attends 1 seconde
  time.sleep(1)
  # Feu rouge
  ledRouge.value(1)
  ledOrange.value(0)
  ledVerte.value(0)
  # Attends 5 secondes
  time.sleep(5)

Boutons poussoirs

Les 4 boutons poussoirs sont situés en face des 4 LED, ils reliés aux GPIO 22, 23, 24 et 25 avec une résistance de Pull Up. Au repos, ils renvoient la valeur True (1) et lorsqu’ils sont appuyés, ils renvoient la valeur False (0). Voilà comment allumer les LED avec les boutons correspondants.

# Appel des bibliothèques
from machine import Pin
import time
#Conversion des numéro de Pin du Pico en numéro de GPIO
GPIO = [None,None,8,9,2,3,14,10,5,4,7,6,20,21,0,1,16,17,18,19,27,28,22,11,12,13,26,15]
# Définition des éléments reliés aux ports du Pico
led1 = Pin(GPIO[12], Pin.OUT)
led2 = Pin(GPIO[26], Pin.OUT)
led3 = Pin(GPIO[27], Pin.OUT)
led4 = Pin(GPIO[6], Pin.OUT)
bouton1 = Pin(GPIO[22], Pin.IN, Pin.PULL_UP)
bouton2 = Pin(GPIO[23], Pin.IN, Pin.PULL_UP)
bouton3 = Pin(GPIO[24], Pin.IN, Pin.PULL_UP)
bouton4 = Pin(GPIO[25], Pin.IN, Pin.PULL_UP)
# Boucle infinie
while True:
    if bouton1.value()==False:
      led1.value(1)
    else:
      led1.value(0)
    if bouton2.value()==False:
      led2.value(1)
    else:
      led2.value(0)
    if bouton3.value()==False:
      led3.value(1)
    else:
      led3.value(0)
    if bouton4.value()==False:
      led4.value(1)
    else:
      led4.value(0)
    time.sleep(0.1)

Mais il est possible de simplifier un peu le code. L’opérateur not inverse simplement la valeur retournée par le bouton pour l’allumer lorsqu’on appuie et l’éteindre quand on le relâche.

# Appel des bibliothèques
from machine import Pin
import time
#Conversion des numéro de Pin du Pico en numéro de GPIO
GPIO = [None,None,8,9,2,3,14,10,5,4,7,6,20,21,0,1,16,17,18,19,27,28,22,11,12,13,26,15]
# Définition des éléments reliés aux ports du Pico
led1 = Pin(GPIO[12], Pin.OUT)
led2 = Pin(GPIO[26], Pin.OUT)
led3 = Pin(GPIO[27], Pin.OUT)
led4 = Pin(GPIO[6], Pin.OUT)
bouton1 = Pin(GPIO[22], Pin.IN, Pin.PULL_UP)
bouton2 = Pin(GPIO[23], Pin.IN, Pin.PULL_UP)
bouton3 = Pin(GPIO[24], Pin.IN, Pin.PULL_UP)
bouton4 = Pin(GPIO[25], Pin.IN, Pin.PULL_UP)
# Boucle infinie
while True:
    led1.value(not bouton1.value())
    led2.value(not bouton2.value())
    led3.value(not bouton3.value())
    led4.value(not bouton4.value())
    time.sleep(0.1)

Relais

Le relais est relié au GPIO 5, il se pilote comme une LED, mais il permet d’allumer ou d’éteindre un appareil électrique. C’est un peu comme si le Raspberry Pico appuyait sur un interrupteur. Dans cet exemple je vais utiliser le bouton 1 pour allumer ou éteindre un appareil. Dans le cadre d’une utilisation pédagogique, il vaut mieux utiliser un appareil basse tension (LED, ventilateur 5 V ou 12 V…) mais avec un boitier et en respectant les règles élémentaires de sécurité, vous pouvez éventuellement piloter des appareils en 230V (Lampe, ordinateur, TV…).

# Appel des bibliothèques
from machine import Pin
import time
#Conversion des numéro de Pin du Pico en numéro de GPIO
GPIO = [None,None,8,9,2,3,14,10,5,4,7,6,20,21,0,1,16,17,18,19,27,28,22,11,12,13,26,15]
# Définition des éléments reliés aux ports du Pico
bouton1 = Pin(GPIO[22], Pin.IN, Pin.PULL_UP)
led1 = Pin(GPIO[12], Pin.OUT)
relais = Pin(GPIO[5], Pin.OUT)
# Définition des variables
etatRelais = False
# Boucle infinie
while True:
    if bouton1.value()==False:
        etatRelais = not etatRelais
        time.sleep(0.3)
    led1.value(etatRelais)
    relais.value(etatRelais)
    time.sleep(0.1)

Buzzer

Le Buzzer est relié au GPIO 13. Il est possible affecter une note à chaque bouton (pour fabriquer un piano rudimentaire).

# Appel des bibliothèques
from machine import Pin, PWM
import time
#Conversion des numéro de Pin du Pico en numéro de GPIO
GPIO = [None,None,8,9,2,3,14,10,5,4,7,6,20,21,0,1,16,17,18,19,27,28,22,11,12,13,26,15]
# Définition des éléments reliés aux ports du Pico
bouton1 = Pin(GPIO[22], Pin.IN, Pin.PULL_UP)
bouton2 = Pin(GPIO[23], Pin.IN, Pin.PULL_UP)
bouton3 = Pin(GPIO[24], Pin.IN, Pin.PULL_UP)
bouton4 = Pin(GPIO[25], Pin.IN, Pin.PULL_UP)
buzzer = PWM(Pin(GPIO[13]))
# Fréquences des notes
do3 = 277
re3 = 294
mi3 = 330
fa3 = 349
temps = 0.3
while True:
    buzzer.duty_u16(1000)
    if bouton1.value()==False:        
        buzzer.freq(do3)
        time.sleep(temps)
    if bouton2.value()==False:
        buzzer.freq(re3)
        time.sleep(temps)
    if bouton3.value()==False:
        buzzer.freq(mi3)
        time.sleep(temps)
    if bouton4.value()==False:
        buzzer.freq(fa3)
        time.sleep(temps)
    buzzer.duty_u16(0)
    time.sleep(0.1)

Mais vous pouvez également composer un morceau de musique (et créer un mini jukebox).

# Appel des bibliothèques
from machine import Pin, PWM
import time
#Conversion des numéro de Pin du Pico en numéro de GPIO
GPIO = [None,None,8,9,2,3,14,10,5,4,7,6,20,21,0,1,16,17,18,19,27,28,22,11,12,13,26,15]
# Définition des éléments reliés aux ports du Pico
bouton1 = Pin(GPIO[22], Pin.IN, Pin.PULL_UP)
buzzer = PWM(Pin(GPIO[13]))
# Fréquences des notes
re3 = 294
mi3 = 330
solb3 = 370
sol3 = 392
la3 = 440
si3 = 494
do4 = 523
re4 = 587
temps = 0.3
# Fonction note
def note(frequence, duree):
    buzzer.duty_u16(1000)
    buzzer.freq(frequence)
    time.sleep(duree)
    buzzer.duty_u16(0)
    time.sleep(temps/16)

while True:
    if bouton1.value()==False:
        # Morceau de musique
        note(re3, temps / 2)
        note(re3, temps)
        note(re3, temps / 2)
        note(sol3, temps)
        note(sol3, temps)
        note(la3, temps)
        note(la3, temps)
        note(re4, temps * 2)
        note(si3, temps / 2)
        note(sol3, temps)
        time.sleep(temps / 2)
        note(sol3, temps / 2)
        note(si3, temps)
        note(sol3, temps / 2)
        note(mi3, temps)
        note(do4, temps * 2)
        note(la3, temps)
        note(solb3, temps / 2)
        note(sol3, temps * 2)
    time.sleep(0.1)

LED RGB (Neopixel)

Les 4 LED RGB adressables (Neopixel) sont reliées au GPIO 18. Pour les contrôler, vous devez installer la bibliothèque correspondante. Rendez-vous à l’adresse suivante et téléchargez le fichier neopixel.py (en cliquant sur le bouton vert Code et en sélectionnant Download ZIP).

Décompressez le fichier ZIP et ouvrez le fichier neopixel.py avec Thonny (Fichier-Ouvrir…) , connectez le Raspberry Pico. Si un script est en cours d’exécution arrêtez-le en cliquant sur le bouton rouge Stop. Allez dans Fichier-Enregistrer sous…, sélectionnez Raspberry Pi Pico, inscrivez le nom du fichier « neopixel.py » et cliquez sur OK.

Installation de la bibliothèque neopixel.py sur le Raspberry Pi Pico

Vous pouvez fermer le fichier neopixel.py et ouvrir le fichier main.py (pour le modifier). Au début du programme, appelez la bibliothèque.

from neopixel import Neopixel

Créez l’objet « ledNeopixels » en indiquant comme paramètres : le nombre de LED, la valeur « 0 » (j’avoue que je ne sais pas à quoi ça correspond, mais ça marche comme ça…), le numéro de port et le type de LED Neopixel.

ledNeopixels = Neopixel(4, 0, GPIO[18], "GRB")

Les LED sont numérotées de 0 à 3, pour programmer une LED il suffit d’indique son numéro et une valeur (comprise entre 0 et 255) pour chaque couleur (rouge, vert, bleu). Attention, les LED sont très lumineuses, une valeur de 255 est très éblouissante. Pour tester le fonctionnement des LED Neopixel, une valeur de 5 (ou de 10) est suffisante.

ledNeopixels.set_pixel(0, (5, 0, 0)) # LED n°0, valeur de rouge 5
ledNeopixels.set_pixel(1, (0, 5, 0)) # LED n°1, valeur de vert 5
ledNeopixels.set_pixel(2, (0, 0, 5)) # LED n°2, valeur de bleu 5
ledNeopixels.set_pixel(3, (5, 5, 5)) # LED n°3, valeur de rouge, vert, bleu 5 (ce qui fait du blanc)

Une fois la couleur de chaque LED définie, utilisez l’instruction suivante pour rafraichir l’affichage.

ledNeopixels.show()

N’oubliez pas de prévoir une pause entre chaque modification (sinon on aura pas le temps de la voir).

time.sleep(0.5)

Les boucles sont souvent utilisées avec les LED Neopixel, elles permettent d’alléger le code. Avec 4 LED c’est déjà très pratique, alors imaginez si vous aviez des dizaines (ou des centaines) de LED à gérer…
Voilà par exemple comment afficher une couleur aléatoire :


# Appel des bibliothèques
from machine import Pin
import time
from neopixel import Neopixel
import random
#Conversion des numéro de Pin du Pico en numéro de GPIO
GPIO = [None,None,8,9,2,3,14,10,5,4,7,6,20,21,0,1,16,17,18,19,27,28,22,11,12,13,26,15]
# Définition de l'objet "ledNeopixels"
nombre_de_LED = 4
ledNeopixels = Neopixel(nombre_de_LED, 0, GPIO[18], "GRB")
while True:
    for i in range(0, nombre_de_LED):
        # Définition d'une couleur aléatoire
        rouge = random.randint(0, 10)
        vert = random.randint(0, 10)
        bleu = random.randint(0, 10)
        ledNeopixels.set_pixel(i, (rouge, vert, bleu))
        # Affichage de la couleur
        ledNeopixels.show()
        time.sleep(0.3)
    time.sleep(0.5)
    # Extinction de toutes LED
    for i in range(0, nombre_de_LED):        
        ledNeopixels.set_pixel(i, (0, 0, 0))
    ledNeopixels.show()
    time.sleep(0.3)

Si vous le souhaitez vous pouvez ajouter une bande ou un anneau de LED en utilisant la sortie Neopixel (l’emplacement est prévu, il faudra seulement souder les connecteurs).

Capteur de température DS18B20

Ce capteur est beaucoup plus précis que celui du Raspberry Pico. Il utilise le bus 1-Wire et est relié au GPIO 4. Il faut appeler les bibliothèques onewire et ds18x20 au début du programme (mais il n’est pas nécessaire de les installer). Voilà un exemple de code qui affiche la température dans la console et allume les LED Neopixels s’il fait trop chaud ou trop froid :

# Appel des bibliothèques
from machine import Pin, SPI
import onewire, ds18x20, time
from neopixel import Neopixel

# Conversion des numéro de Pin du Pico en numéro de GPIO
GPIO = [None,None,8,9,2,3,14,10,5,4,7,6,20,21,0,1,16,17,18,19,27,28,22,11,12,13,26,15]
# Définition de l'objet "ledNeopixels"
nombre_de_LED = 4
ledNeopixels = Neopixel(nombre_de_LED, 0, GPIO[18], "GRB")
# Paramètres du capteur de température DS18B20
ds_sensor = ds18x20.DS18X20(onewire.OneWire(machine.Pin(GPIO[4])))
roms = ds_sensor.scan()
while True:
    ds_sensor.convert_temp()
    time.sleep(1)
    for rom in roms:
        temp = round(ds_sensor.read_temp(rom))
    print("Température :",temp ,"degrés")
    if temp < 19:
        for i in range(0, nombre_de_LED):        
            ledNeopixels.set_pixel(i, (0, 0, 10))
    elif temp > 25:
        for i in range(0, nombre_de_LED):        
            ledNeopixels.set_pixel(i, (10, 0, 0))
    else:
        for i in range(0, nombre_de_LED):        
            ledNeopixels.set_pixel(i, (0, 0, 0))
    ledNeopixels.show()
LED Neopixel du Ludik Hat (en rouge)

Vous pouvez éventuellement ajouter un second thermomètre (sous forme de soude), pour mesurer la température intérieure/extérieure ou d’autres modules compatibles avec le bus 1-Wire (comme pour les LED Neopixel, l’emplacement est prévu, mais il faudra souder les connecteurs).

Potentiomètre

Le Ludik Hat est conçu pour fonctionner avec un Raspberry Pi qui (contrairement au Raspberry Pico) ne possèdent pas d’entrées analogiques. La carte intègre donc un convertisseur ADC (MCP3008) à 8 canaux (entrées analogiques). Certains canaux sont reliés aux composants de la carte (potentiomètre, joystick, photorésistance) mais il en reste 4 disponibles (pour brancher d’autres capteurs).

Pour accéder aux données du convertisseur ADC, vous devez installer la bibliothèque correspondante. Rendez-vous à l’adresse suivante et téléchargez la bibliothèque (en cliquant sur le bouton vert Code et en sélectionnant Download ZIP).

Dézippez le fichier pico-code-master.zip et récupérez le fichier mcp3008.py (contenu dans le répertoire pico-code-master\src\pico_code\pico\mcp3008). Ouvrez-le avec Thonny (Fichier-Ouvrir…) et connectez le Raspberry Pico. Si un script est en cours d’exécution arrêtez-le en cliquant sur le bouton rouge Stop. Allez dans Fichier-Enregistrer sous…, sélectionnez Raspberry Pi Pico, inscrivez le nom du fichier « mcp3008.py » et cliquez sur OK.

Installation de la bibliothèque mcp3008.py sur le Raspberry Pi Pico

Le convertisseur ADC utilise les GPIO 8, 9, 10 et 11 pour communiquer à travers un bus SPI. Le canal (entrée analogique) n° 3 est relié au potentiomètre. Pour vérifier que cela fonctionne, vous utilisez le code suivant :

# Appel des bibliothèques
from machine import Pin, SPI
import time
from mcp3008 import MCP3008
# Conversion des numéro de Pin du Pico en numéro de GPIO
GPIO = [None,None,8,9,2,3,14,10,5,4,7,6,20,21,0,1,16,17,18,19,27,28,22,11,12,13,26,15]

# Configuration du bus SPI
spi = SPI(0, sck=Pin(GPIO[11]),mosi=Pin(GPIO[10]),miso=Pin(GPIO[9]), baudrate=100000)
analog = MCP3008(spi, Pin(GPIO[8], Pin.OUT))

while True:
    print(analog.read(3))
    time.sleep(1)

Le programme affiche toutes les secondes sur la console, la valeur analogique (comprise entre 0 et 1023) renvoyée par le potentiomètre. Evidement, lorsque vous tournez le potentiomètre, la valeur change (c’est là tout l’intérêt).

Affichage de la valeur du potentiomètre sur la console

C’est un peu contre-intuitif, parce que la valeur augmente lorsqu’on tourne le potentiomètre dans le sens inverse des aiguilles d’une montre. Mais ce n’est pas très grave, il suffit d’en tenir compte dans le programme. Passons maintenant à une application plus amusante. Nous pouvons par exemple, modifier l’état des LED en fonction de la valeur du potentiomètre.

# Appel des bibliothèques
from machine import Pin, SPI
import time
from mcp3008 import MCP3008
# Conversion des numéro de Pin du Pico en numéro de GPIO
GPIO = [None,None,8,9,2,3,14,10,5,4,7,6,20,21,0,1,16,17,18,19,27,28,22,11,12,13,26,15]
# Définition des éléments reliés aux ports du Pico
led1 = Pin(GPIO[12], Pin.OUT)
led2 = Pin(GPIO[26], Pin.OUT)
led3 = Pin(GPIO[27], Pin.OUT)
led4 = Pin(GPIO[6], Pin.OUT)
# Configuration du bus SPI
spi = SPI(0, sck=Pin(GPIO[11]),mosi=Pin(GPIO[10]),miso=Pin(GPIO[9]), baudrate=100000)
analog = MCP3008(spi, Pin(GPIO[8], Pin.OUT))

while True:
    pot = analog.read(3) # Valeur du potentiomètre
    if pot < 900:
      led1.value(1)
    else:
      led1.value(0)
    if pot < 634:
      led2.value(1)
    else:
      led2.value(0)
    if pot < 367:
      led3.value(1)
    else:
      led3.value(0)
    if pot < 100:
      led4.value(1)
    else:
      led4.value(0)
    time.sleep(0.1)
Contrôle des LED avec le potentiomètre

Joystick analogique

Le joystick est composé de 2 potentiomètres (pour l’axe X et l’axe Y). Ils sont reliés aux canaux 0 et 1 du convertisseur ADC. La valeur renvoyée pour chaque axe permet de connaitre la position de la manette. Au repos les valeurs de X et de Y s’approchent de 512 (ce n’est jamais aussi précis, sur le mien, cela fluctue entre 511 et 530, alors disons entre 490 et 540 pour être tranquille). En haut et à gauche, on se rapproche de 0, en bas et à droite on se rapproche de 1023. Cet exemple de code permet d’afficher la position du joystick sur la console (évidement, les valeurs changent quand on le manipule).

# Appel des bibliothèques
from machine import Pin, SPI
import time
from mcp3008 import MCP3008
# Conversion des numéro de Pin du Pico en numéro de GPIO
GPIO = [None,None,8,9,2,3,14,10,5,4,7,6,20,21,0,1,16,17,18,19,27,28,22,11,12,13,26,15]
# Définition des éléments reliés aux ports du Pico
led1 = Pin(GPIO[12], Pin.OUT)
led2 = Pin(GPIO[26], Pin.OUT)
led3 = Pin(GPIO[27], Pin.OUT)
led4 = Pin(GPIO[6], Pin.OUT)
# Configuration du bus SPI
spi = SPI(0, sck=Pin(GPIO[11]),mosi=Pin(GPIO[10]),miso=Pin(GPIO[9]), baudrate=100000)
analog = MCP3008(spi, Pin(GPIO[8], Pin.OUT))

while True:
    x = analog.read(0) # Joystick horizontal
    y = analog.read(1) # Joystick vertical
    print( "Joystick : X =%4i et Y =%4i" % (x,y) )
    time.sleep(1)
Affichage de la position du joystick sur la console

Photorésistance

Comme son nom l’indique, c’est un composant électronique dont la résistance électrique change en fonction de la lumière. Il suffit donc de mesurer la valeur renvoyée au canal n°2 du convertisseur ADC pour mesurer la luminosité.

# Appel des bibliothèques
from machine import Pin, SPI
import time
from mcp3008 import MCP3008
# Conversion des numéro de Pin du Pico en numéro de GPIO
GPIO = [None,None,8,9,2,3,14,10,5,4,7,6,20,21,0,1,16,17,18,19,27,28,22,11,12,13,26,15]

# Configuration du bus SPI
spi = SPI(0, sck=Pin(GPIO[11]),mosi=Pin(GPIO[10]),miso=Pin(GPIO[9]), baudrate=100000)
analog = MCP3008(spi, Pin(GPIO[8], Pin.OUT))

while True:
    print(analog.read(2))
    time.sleep(1)

Pour afficher la différence de luminosité, j’ai utilisé les LED Neopixel, parce que les LED classiques sont trop proches, ce qui risque de fausser les mesures. N’oubliez pas d’installer la bibliothèque Neopixel (en plus de la bibliothèque MCP3008). Vous pouvez mettre votre main devant le capteur pour simuler une baisse de lumière mais évitez de le toucher (parce que la peau est conductrice).

# Appel des bibliothèques
from machine import Pin, SPI
import time
from neopixel import Neopixel
from mcp3008 import MCP3008
# Conversion des numéro de Pin du Pico en numéro de GPIO
GPIO = [None,None,8,9,2,3,14,10,5,4,7,6,20,21,0,1,16,17,18,19,27,28,22,11,12,13,26,15]
# Définition de l'objet "ledNeopixels"
nombre_de_LED = 4
ledNeopixels = Neopixel(nombre_de_LED, 0, GPIO[18], "GRB")
# Configuration du bus SPI
spi = SPI(0, sck=Pin(GPIO[11]),mosi=Pin(GPIO[10]),miso=Pin(GPIO[9]), baudrate=100000)
analog = MCP3008(spi, Pin(GPIO[8], Pin.OUT))

while True:
    lum = analog.read(2)
    if lum > 300:
      ledNeopixels.set_pixel(3, (20, 0, 0))
    else:
      ledNeopixels.set_pixel(3, (0, 0, 0))
    if lum > 500:
      ledNeopixels.set_pixel(2, (20, 0, 0))
    else:
      ledNeopixels.set_pixel(2, (0, 0, 0))
    if lum > 700:
      ledNeopixels.set_pixel(1, (20, 0, 0))
    else:
      ledNeopixels.set_pixel(1, (0, 0, 0))
    if lum > 900:
      ledNeopixels.set_pixel(0, (20, 0, 0))
    else:
      ledNeopixels.set_pixel(0, (0, 0, 0))
    ledNeopixels.show()
    time.sleep(0.2)
Modification de l'affichage des LED Neopixel en fonction de la luminosité

Breadboard

Le LudikHat dispose de 4 entrées analogique supplémentaires (canaux 4 à 7), pour y branchez des modules analogiques (potentiomètres, capteur d’humidité…).
Mais surtout, ne pas dépasser une tension de 3,3V sur les entrées analogiques.

Vous disposez également de nombreux connecteurs femelles (3,3V, 5V, GND et GPIO 14 à 21) pour relier les composants électroniques ou des modules de votre choix.
Cependant la liberté a un prix, en cas d’erreur vous pouvez endommager votre matériel, alors vérifiez soigneusement vos branchements avant de mettre sous tension.

Connecteurs Grove, Gravity et Qwiic / StemmaQT

Vous avez aussi la possibilité de piloter des modules utilisant le bus I2C (en 3,3V), puisque le ludikHat possède 1 connecteur Grove, 2 connecteurs Gravity et 2 connecteurs Qwiic / StemmaQT. Le GPIO 2 est relié au port SDA et le GPIO 3 au port SCL.

Bien sûr vous pouvez aussi vous en servir pour faire clignoter une simple LED (mais d’après Dominique, cela serait un pur gâchis)…

from machine import Pin
import time

# Conversion des numéro de Pin du Pico en numéro de GPIO
GPIO = [None,None,8,9,2,3,14,10,5,4,7,6,20,21,0,1,16,17,18,19,27,28,22,11,12,13,26,15]
# Définition des éléments reliés aux ports du Pico
led = Pin(GPIO[3], Pin.OUT)
while True:
  led.value(1)
  time.sleep(0.5)
  led.value(0)
  time.sleep(0.5)
Branchement d'une LED externe Grove sur le Ludik Hat

Au niveau des connecteurs la carte est plutôt gâtée, cependant, j’aurais bien aimé trouver quelques connecteurs males (3 broches) pour brancher des servomoteurs 9g.

Servomoteur 9g

Conclusion

Le Ludik Hat est très agréable à utiliser, il est compact et regroupe la plupart des modules de base. La carte a été imaginée par un formateur et ça se voit. Elle permet de gagner énormément de temps en évitant les problèmes de branchement (faux contact, court circuits, mauvais port GPIO).
Si vous avez déjà animé ce type d’initiation sur breadboard avec des adolescents vous savez de quoi je parle :

– M’sieur, ça marche pas !
– Oui, j’arrive… Alors là il faut brancher le fil à cet endroit, comme sur le schéma, au tableau
– M’sieur, ben moi non plus ça marche pas !!!
– Oui, alors c’est la même chose, il faut suivre le schéma que j’ai mis au tableau et donc le fil, il va là..
– Hé M’sieur pourquoi, moi ça marche pas ???
– Alors si on suit le schéma, on voit qu’il faut brancher le fil ici…
– Meusieeeeeeu !!! on fait quoi maintenant ??
– Attendez, il faut encore que j’aide les autres groupes qui n’ont encore réussi cette étape…

Quand aux débutants, ils apprécieront dans un premier temps la simplicité d’une carte « Plug and play » et pourront ensuite la faire évoluer en ajoutant de nouveaux modules aux connecteurs du Ludik Hat.

Alors si la carte vous intéresse vous la trouverez en exclusivité dans la boutique MCHobby.

Fiche produit du Ludik-Hat (MCHobby)

Sources et liens utiles


Votre commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l’aide de votre compte WordPress.com. Déconnexion /  Changer )

Photo Google

Vous commentez à l’aide de votre compte Google. Déconnexion /  Changer )

Image Twitter

Vous commentez à l’aide de votre compte Twitter. Déconnexion /  Changer )

Photo Facebook

Vous commentez à l’aide de votre compte Facebook. Déconnexion /  Changer )

Connexion à %s