RASPBERRY PICO W

Le capteur de couleur TCS34725 (Gravity)

À quoi ça sert sur notre robot ?

Le TCS34725 est un capteur de couleur.
Sur la compétition Rescue Line, il sert principalement à :

• suivre la ligne noire
• repérer les carrés verts pour savoir quand tourner à droite ou à gauche

Comment “voit” le capteur ?

Il éclaire le sol

Le capteur possède quatre petites LEDs blanches.

• Elle éclaire le sol juste en dessous du robot
• La lumière rebondit sur le sol et revient vers le capteur

• Un sol clair renvoie beaucoup de lumière
• Un sol foncé (ligne noire) renvoie peu de lumière

Il sépare la lumière en couleurs

À l’intérieur du capteur, il y a 4 détecteurs :

• 🔴 Rouge (R)
• 🟢 Vert (G)
• 🔵 Bleu (B)
• ⚪ Luminosité totale (Clear)

Pour chaque couleur, le capteur donne un nombre.

Ces nombres sont envoyés au microcontrôleur (ex : Raspberry Pico, mBot, etc.).

Le multiplexeur I2C

Pourquoi on en a besoin avec plusieurs capteurs de couleur ?

Rappel : c’est quoi le bus I2C ?

Le bus I2C, c’est comme une route avec quatres fils :

• SDA : pour envoyer et recevoir les données
• SCL : pour donner le rythme (l’horloge)

Tous les capteurs sont branchés sur la même route et parlent avec le microcontrôleur.

Avec un bus I2C ont peut dialoguer avec plusieurs dispositifs sur le même bus.

Chaque capteur a une adresse

Sur cette route, chaque capteur a une adresse, comme un numéro de maison.

Exemple :

• Capteur température : adresse 0x48
• Capteur distance : adresse 0x29
• Capteur couleur TCS34725 : adresse 0x29

Quand le microcontrôleur veut parler à un capteur, il dit :

« Je parle au capteur numéro 0x29 »

Le problème avec plusieurs capteurs identiques

Dans notre robot, on utilise plusieurs capteurs de couleur identiques :

• gauche
• centre
• droite

Et ils ont tous la même adresse I2C

Résultat :

• Le microcontrôleur dit :
  « Capteur 0x29, réponds ! »
• Tous répondent en même temps
• Ça crée un conflit → le bus ne fonctionne plus

La solution : le multiplexeur I2C

Un multiplexeur I2C (ex : TCA9548A) est comme :

un aiguillage ou un feu de circulation pour le bus I2C

Il permet de choisir quel capteur est connecté au bus à un instant donné.

Comment fonctionne le multiplexeur ?

Le multiplexeur est lui-même un appareil I2C

• Il a sa propre adresse
• Le microcontrôleur peut lui parler

Il possède plusieurs “canaux” de 1 à 8 canaux

Par exemple :

• canal 0
• canal 1
• canal 2
• …
• jusqu’à 8 canaux

Chaque canal peut avoir :

• un capteur
• ou même plusieurs capteurs (s’ils ont des adresses différentes)

On ouvre un canal à la fois

Le microcontrôleur dit au multiplexeur :

« Ouvre le canal 2 »

Résultat :

• Seul le capteur branché sur le canal 2 est visible
• Les autres sont déconnectés temporairement

Pour programmer, le capteur TCS34725 utilise la librairie class tcs34725.py à télécharger sur le microcontroleur :

Dans ton programme importe ces bibliothèques :

from machine import I2C
import time
from tcs34725 import TCS34725

Recherche les adresses sur le bus i2c :

from machine import I2C
import time
from tcs34725 import TCS34725

print("Initialisation I2C...")
i2c = I2C(0)
print("Scan I2C en cours...")
devices = i2c.scan()
print("Adresses trouvées:", [hex(d) for d in devices])

• 0x29 : capteur de couleur
• 0x72 : multiplexeur i2c

Exemple d’un programme de test pour lire les valeurs de deux capteurs sur les port 0 et 1 :

from machine import I2C
import time
from tcs34725 import TCS34725

print("Initialisation I2C...")
i2c = I2C(0)
print("Scan I2C en cours...")
devices = i2c.scan()
print("Adresses trouvées:", [hex(d) for d in devices])
# Initialisation du capteur
# Si vous n'utilisez PAS de multiplexeur, laissez multiplexer_addr=None
# Si vous en utilisez un, changez multiplexer_addr=0x70 (ou autre) et le port=0-7
ADDRESS_MULTIPLEXER = const(0x72)
try:
    print("Initialisation TCS34725...")
    #sensor = TCS34725(i2c)
    # Pour un multiplexeur:
    sensor01 = TCS34725(i2c, ADDRESS_MULTIPLEXER, 0)
    sensor02 = TCS34725(i2c, ADDRESS_MULTIPLEXER, 1)

    print("Capteur trouvé !")

    # Configuration optionnelle
    sensor01.integration_time(50) # 50ms (plus rapide mais moins précis que 2.4ms * n)
    sensor01.gain(4) # Gain 4x (1, 4, 16, 60)
    sensor02.integration_time(50)
    sensor02.gain(4)
    while True:
        # Lecture brute
        r, g, b, c = sensor01.read(raw=True)

        # Lecture interprétée
        temp, lux = sensor01.read(raw=False) # Note: refait une lecture

        print(f"R:{r} G:{g} B:{b} C:{c} | Temp:{temp}K Lux:{lux}")

        gray01 = sensor01.read_grayscale()
        gray02 = sensor02.read_grayscale()
        print("Read Gray : ", gray01)

        # Détection simple couleur
        if sensor01.is_red():
            print(" >> ROUGE détecté !")
        elif sensor01.is_green():
            print(" >> VERT détecté !")
        elif sensor01.is_blue():
            print(" >> BLEU détecté !")

        time.sleep(1)

except RuntimeError as e:
    print("ERREUR FATALE:", e)
except Exception as e:
    print("Erreur inattendue:", e)

Exemple initialisation capteur de couleur en direct sans le multiplexeur :

    sensor = TCS34725(i2c)

Exemple initialisation capteurs couleur via le multiplexeur :

    sensor01 = TCS34725(i2c, ADDRESS_MULTIPLEXER, 0)
    sensor02 = TCS34725(i2c, ADDRESS_MULTIPLEXER, 1)

Lecture de la nuance de gris :

        gray01 = sensor01.read_grayscale()
        print("Read Gray : ", gray01)

Détection d’une couleur :

if sensor01.is_red():
print( » >> ROUGE détecté ! »)
elif sensor01.is_green():
print( » >> VERT détecté ! »)
elif sensor01.is_blue():
print( » >> BLEU détecté ! »)

CARTE DE DEVELOPPEMENT RASPBERRY PICO W

C’est quoi un écran OLED SSD1306 ?

Un écran OLED SSD1306 est un petit écran que l’on branche à un microcontrôleur (comme une Raspberry Pi Pico) pour afficher du texte ou des dessins sur un port I2C.

OLED, ça veut dire quoi ?

• Chaque pixel s’allume tout seul
• Pas besoin de rétroéclairage
• Noir = pixel éteint → économie d’énergie

Taille courante :

• 128 × 64 pixels
• 128 × 32 pixels

Comment la Pico communique avec l’écran ?

La Pico communique avec l’écran grâce au bus I²C.

C’est comme une conversation :

• La Pico = celui qui parle
• L’écran = celui qui écoute

Les 2 fils importants du bus i2c

L’écran a une adresse (souvent 0x3C) pour qu’on sache à qui on parle.

À quoi sert la bibliothèque micropython-ssd1306 ?

La bibliothèque sert à :

• permettre d’écrire simplement :
  • du texte
  • des pixels
  • des formes

https://github.com/stlehmann/micropython-ssd1306

Comment fonctionne l’affichage ? (idée clé)

L’écran ne s’actualise pas tout seul.

1. La Pico dessine dans une image invisible (le buffer)
2. Quand tout est prêt, on dit :

oled.show()

Et l’image apparaît à l’écran

Comme dessiner sur une feuille, puis l’afficher d’un coup

Exemple simple de programme

# Création du bus I2C
i2c = I2C(0)

# Création de l'écran
oled = SSD1306_I2C(128, 64, i2c)

# Effacer l'écran
oled.fill(0)

# Écrire du texte
oled.text("Bonjour !", 0, 0)
oled.text("Initialisation", 0, 10)

# Afficher à l'écran
oled.show()

Les commandes principales (les plus utiles)

Écrire du texte

oled.text("Texte", x, y)

• x → position horizontale
• y → position verticale

🧹 Effacer l’écran

oled.fill(0)

Allumer tous les pixels

oled.fill(1)

Allumer un pixel

oled.pixel(x, y, 1)

Dessiner une ligne

oled.line(x1, y1, x2, y2, 1)

0 ou 1 pour éteindre ou allumer la ligne

Exemple amusant (point qui bouge)

for x in range(128):
    oled.fill(0)
    oled.pixel(x, 30, 1)
    oled.show()

Le point se déplace à l’écran