RESSOURCES TEEN RASPBERRY – Les composants Grove

Raspberry & Grove

Connecter ses composants

Tous nos composants vont être reliés à la carte par des cables.

Les couleurs de câbles indiquent leur type.

Pour ces composants tu peux lire les types d’entrées sorties sur le composant, sinon par couleur : noir avec noir (ou marron!), rouge avec rouge, etc.

On va connecter nos composants à notre shield Grove.

Les composants peuvent être numériques, analogiques ou pseudo-analogiques(PWM) et selon leur type on ne les branchera pas sur les mêmes port de notre shield Grove.

Un composant numérique n’aura que deux valeurs possibles (0 ou 1), un composant analogique ou pseudo-analogique pourra avoir plein de valeur différentes intermédiaire. Bien souvent les composants peuvent avoir un fonctionnement différent selon la librairie qu’on utilise pour les programmer.

Entrées Numériques

Une “entrée” est un composant qui envoie une information à la carte : l’information “entre” dans la carte.

-> Un bouton est une entrée car il capte une information extérieure et la fait entrer dans le système, par exemple pour ensuite allumer une LED.

Un composant est “numérique” ou “digital” lorsque son état ne peut prendre que deux valeurs : 0 ou 1, allumé ou éteint, Vrai ou faux.

-> Le bouton est un composant numérique car il ne peut être que pressé ou relâché

Les composants numériques se branchent sur les ports D5, D16, D18, D22, D24 et D26 du shield Grove

Bouton

Le bouton & ses branchements

Lorsque tu connectes le bouton poussoir avec un adaptateur, regarde bien le câble que tu connectes sur le composant. Si c’est le jaune ou le blanc cela ne correspondra pas à la même entrée/sortie sur ta carte !

(jaune/blanc = OUT / rouge = VCC / noir = GND)

Certains boutons se branchent directement avec le cable Grove

Le bouton & sa programmation en Python

On commence par importer la librairie : Factory

from grove.factory import Factory

On va ensuite définir le port sur lequel le bouton est branché et définir une variable pour manipuler notre bouton. Par exemple :

pin_bouton = 12
bouton = Factory.getButton("GPIO-HIGH", pin_bouton)

On peut maintenant utiliser la commande is_pressed() pour savoir si le bouton est pressé ou non :

if bouton.is_pressed():
 print('Le bouton est appuyé')
else:
 print('Le bouton est relaché')

Sorties - les LED

Une “sortie” est un composant qui reçoit une information de la carte pour fonctionner : l’information “sort” de la carte et va vers le composant.

-> La LED est une sortie car c’est vous/la carte qui lui envoyez du courant pour qu’elle s’allume ou s’éteigne.

Il existe différents types de LED:

La LED simple est un composant numérique car on ne peut que l’allumer et l’éteindre.
La Led variable RGB est un composant PWM ou pseudo analogique, car on peut varier son intensité

Un composant est « pseudo-analogique » quand sa valeur varie entre 0 et 255. Il n’est pas seulement allumé ou éteints mais peut-être 10% allumé et 90% éteints.

Les composants pseudo-analogiques se branchent sur les ports PWM (D12), D18 et D26 du shield Grove

La LED variable RGB

La LED Variable RGB & ses branchements

La LED variable RGB se branche directement via un cable grove.

Pour changer sa couleur, la LED est équipée de 3 petits potentiomètres à son dos que l’on peut tourner avec un tournevis.

Si ta LED ne s’allume pas vérifie, que les potentiomètres sont bien réglés.

La LED & sa programmation en Python

On commence par importer la librairie : GroveVariableLed

from grove_variable_led import GroveVariableLed

Note : tu peux trouver ICI la librairie spécifique à cette LED.

On va ensuite définir le port sur lequel la LED est branchée et définir une variable pour manipuler notre LED. Par exemple :

pin_led= 18  
led = GroveVariableLed(pin_led)

On peut maintenant utiliser les commandes on() et off() pour éteindre et allumer la LED

led.on()

On va aussi pouvoir choisir l’intensité de la LED (entre 0 et 255) :

led.setValue(255)

Entrées - Analogique

Les composants analogiques sont associés à des données qui varient : la température, la lumière, la vitesse, l’inclinaison, etc.

Un composant est “analogique ” lorsque son état peut prendre plusieurs valeurs entre 0 et 1024 : c’est plus précis qu’un composant “pseudo-analogique” dont les valeurs varient entre 0 et 255. Les composants analogiques sont associés à des données qui varient : la position d’un moteur, le sens d’un moteur…

-> Le potentiomètre est analogique car en le tournant on envoie des valeurs plus ou moins grandes (entre 0 et 1024) à la carte.

-> Le capteur est pseudo analogique car il va détecter une distance entre 0 et 255 à la carte (on a une super fonction qui transforme directement ça en distance)

C’est important de savoir si un composant est analogique ou pseudo analogique pour savoir comment le brancher :

Les composants analogiques se branchent sur les ports A0 A2 A4 et A6 du shield Grove
Les composants pseudo-analogiques se branchent sur les ports PWM (D12), D18 et D26 du shield Grove

Potentiomètre

Le potentiomètre & ses blocs

Le potentiomètre prends des valeurs comprises entre 0 et 1024

Tu peux brancher un potentiomètre avec un câble Grove classique ! Tu as juste à le clipser à la broche P que tu souhaites !

Le potentiomètre & sa programmation en Python

On commence par importer la librairie : GroveRotaryAngleSensor

from grove.grove_rotary_angle_sensor import GroveRotaryAngleSensor

On va ensuite définir le port sur lequel le potentiomètre est branché et définir une variable pour manipuler notre potentiomètre. Par exemple :

pin_potar= 2
potar = GroveRotaryAngleSensor(pin_potar)

On peut maintenant utiliser la commande value() pour récupérer la valeur du capteur :

print(potar.value)

Pense à marquer une pause pour pouvoir lire plus facilement les valeurs si tu les affiches dans une boucle ‘toujours’ par exemple !

Capteur de distance

Le capteur de distance & ses branchements

Un capteur de distance (ultrasons) envoie un signal, puis mesure le temps que le signal met à revenir. Plus le temps est long plus la distance est grande.

L’envoi du signal correspond à la broche ECHO (le capteur émet un “echo”), la broche TRIG déclenche la mesure, elle correspond à l’arrivée du signal.

Plage de mesure : de 2cm à 4 m !

Tu peux brancher un capteur de distance Grove avec un câble Grove classique ! Tu as juste à le clipser à la broche P que tu souhaites !

Le capteur de distance & sa programmation en Python

On commence par importer la librairie : GroveUltrasonicRanger

from grove.grove_ultrasonic_ranger import GroveUltrasonicRanger

On va ensuite définir le port sur lequel le capteur est branché et définir une variable pour manipuler notre capteur. Par exemple :

pin_capteur = 12
capteur = GroveUltrasonicRanger(pin_capteur)

On peut maintenant utiliser la commande get_distance() pour récupérer la valeur du capteur :

print(capteur.get_distance())

Pense à marquer une pause pour pouvoir lire plus facilement les valeurs si tu les affiches dans une boucle ‘toujours’ par exemple !

Sorties - Analogique

Le moteur est un comportement pseudo analogique car pour le faire tourner on va lui transmettre un angle qui sera converti en une valeur entre 0 et 255

Les composants pseudo-analogiques se branchent sur les ports PWM (D12), D18 et D26 du shield Grove

Servomoteurs

Le servomoteur & ses branchements

-> Un servomoteur “classique” ne peut faire qu’un demi-tour, c’est à dire tourner entre 0 et 180°.

Attention : évite les valeurs proches des extrêmes, qui ont tendance à faire grincer les servos, l’utiliser entre 20 et 160°

Le servomoteur & sa programmation en Python

On commence par importer la librairie : GroveServo

from grove.grove_servo import GroveServo

On va ensuite définir le port sur lequel le servo est branché et définir une variable pour manipuler notre servo. Par exemple :

pin_moteur = 12
moteur = GroveServo(pin_moteur)

On peut maintenant utiliser la commande setAngle() pour aller à un angle précis :

moteur.setAngle(50)

Autres composants

Nous allons voir ici quelques composants plus complexes que tu ne trouvera peut-être pas dans ton kit.

Le capteur piezo électrique

Le capteur de son & ses branchements
Un capteur de son est un composant qui détecte les vibrations du son. On va l’utiliser de manière numérique pour savoir s’il y a du son ou pas. On pourra utiliser un tournevis pour régler le seuil de détection.

Pour le brancher, utilise un câble grove femelle et branche:

le cable jaune sur OUT
le cable rouge sur VCC
le cable noir sur GND

Le capteur de son & sa programmation en Python

On commence par importer la librairie : GrovePiezoVibrationSensor

from grove.grove_piezo_vibration_sensor import GrovePiezoVibrationSensor

On va ensuite définir le port sur lequel le servo est branché et définir une variable pour manipuler notre servo. Par exemple :

pin = 22
capteur = GrovePiezoVibrationSensor(pin)

On va créer une fonction callback qui sera appelée à chaque fois qu’un son est détecté et rattacher cette fonction à l’événement qui détecte le son.

def callback():

print('Son detecté')

capteur.on_detect = callback

Et on lance une boucle infinie pour que le programme continue de détecter les sons.

while True:

   time.sleep(1)

EXPERIMENTER

EXPERIMENTER

PARTAGER