Catégorie : Robotique

Catégories
MICRO PYTHON MICRO:BIT

Découverte de Python avec la MICRO:BIT

Découvrir le code en python :

Bienvenue dans ce livret qui va te permettre de découvrir le monde
passionnant de la programmation avec le langage Python et la carte
micro:bit ! Tu vas t’amuser à apprendre les bases du codage tout en
explorant les fonctionnalités géniales de la carte micro:bit. Python est un langage de programmation puissant, mais pas compliqué une fois qu’on le comprend bien. Avec lui, tu pourras créer des jeux, contrôler des robots, afficher des messages et bien plus encore sur ta carte micro:bit.

Contrôler la carte micro:bit en python :

Dans ce livret, tu vas découvrir pas à pas comment écrire des lignes de code en Python pour contrôler ta carte micro:bit. N’aie pas peur, on va commencer par les bases, et tu verras à quel point coder peut-être amusant et créatif ! Alors, prêt à plonger dans le monde magique de la programmation avec Python et la carte micro:bit ? C’est parti !

Editeur MU Python :

MU est choisi comme éditeur pour sa simplicité d’utilisation et sa
convivialité, spécialement conçu pour les débutants en programmation.
Son interface intuitive offre une plateforme idéale pour coder en Python pour la carte micro:bit. Avec ses fonctionnalités adaptées, MU facilite l’écriture, la modification et l’exécution du code, offrant ainsi une expérience d’apprentissage agréable et efficace dans le cadre de la robotique.

Partie 01 : Découverte de la MICRO:BIT et de PYTHON

Découverte de MU

Dans MU par le bouton Mode sélectionner BBC microbit :

Puis créé un nouveau fichier

Nouveau fichier

La première fonction, toute simple, de la carte micro:bit consiste à afficher un texte qui va défiler lettre par lettre sur l’écran :

from microbit import display 
display.show('Bonjour comment vas-tu ?')
Flasher pour tester puis bouton reset pour lancer

Que constates-tu après avoir téléversé le programme ?
Le texte doit défilé sur la carte micro :bit.

Tu peux simuler ton code sur le site : https://create.withcode.uk/
Copie et colle ton programme Python
Appuie ensuite sur les touches Ctrl+Entrée. Le simulateur démarre et affiche la carte micro:bit avec laquelle il est possible d’interagir.

Etape 2 Afficher un dessin

Il est possible d’afficher des icônes sur l’écran composé d’une matrice de 5×5 LEDs en utilisant la commande display.show().

from microbit import display
display.show(Image.ANGRY)

Utilise l’icône « Vérifier » pour ton code : il te manque l’objet « Image »

from microbit import display, Image 
display.show(Image.ANGRY)
Flasher pour tester puis bouton reset pour lancer

Que constates-tu après avoir téléversé le programme ?
L’icone s’affiche sur l’écran des 25 LEDs ?

Pour connaître toutes les images possibles deux solutions :

Solution 1 :

Solution 2 :

Utilise l’icône « REPL » et dans la fenêtre ouverte frappe les indications
suivantes :

from microbit import *
dir(display)
dir(Image)

Etape 3 Créer sa propre icône

Tu peux concevoir ta propre icône en spécifiant quelles LEDs doivent être allumées pour dessiner l’image désirée.

from microbit import display, Image
led_image = Image('00900:00900:99999:00900:00900')
display.show(led_image)
Flasher pour tester puis bouton reset pour lancer

Que constates-tu après avoir téléversé le programme ?
A quoi correspond les 0 et les 9 de led_image ?
Comment modifier led_image pour avoir ton icône ?
Tu as la possibilité de contrôler l’intensité de chaque LED en ajustant la valeur de chacune sur une échelle de 1 à 9.

from microbit import display, Image
led_image = Image( '00900:00500:95959:00500:00900')
display.show(led_image)
Flasher pour tester puis bouton reset pour lancer

Que constates-tu après avoir téléversé le programme ?
Vois-tu des différences d’intensité entre chaque LED ?

Documentation sur Image

Etape 4 Faire clignoter une icône

Pour créer un effet de clignotement d’une icône, tu dois afficher cette dernière pendant une durée déterminée, puis éteindre la matrice de LEDs.

from microbit import display,Image
import time
while True:
    led_image = Image('00900:00900:99999:00900:00900')
    display.show(led_image)
    time.sleep(0.5)
    display.clear()
    time.sleep(0.5)
Flasher pour tester puis bouton reset pour lancer

Que constates-tu après avoir téléversé le programme ?
Comment peux-tu modifier pour un clignotement plus rapide ou plus lent ?

Etape 5 Afficher un chronomètre en seconde

Afficher les aiguilles toutes les secondes.

from microbit import display,Image 
import time 
 
seconde=0 
while True: 
    if seconde==0: 
        display.show(Image.CLOCK12) 
    if seconde==1: 
        display.show(Image.CLOCK1) 
    if seconde==2: 
        display.show(Image.CLOCK2) 
    if seconde==3: 
        display.show(Image.CLOCK3)     
    if seconde==4: 
        display.show(Image.CLOCK4) 
    if seconde==5: 
        display.show(Image.CLOCK5) 
    if seconde==6: 
        display.show(Image.CLOCK6) 
    if seconde==7: 
        display.show(Image.CLOCK7) 
    if seconde==8: 
        display.show(Image.CLOCK8) 
    if seconde==9: 
        display.show(Image.CLOCK9) 
    if seconde==10: 
        display.show(Image.CLOCK10) 
    if seconde==11: 
        display.show(Image.CLOCK11) 
        seconde=-1 
    time.sleep(1) 
    seconde+=1
Flasher pour tester puis bouton reset pour lancer

Etape 6 Animer des images et jouer une note

La carte micro:bit dispose d’un buzzer. Programme le battement d’un cœur !

from microbit import * 
import time 
import music 
# Buzzer on pin_speaker 
while True: 
    display.show(Image.HEART) 
    time.sleep(1) 
    led_image = Image('00000:09090:09990:00900:00000') 
    display.show(led_image) 
    music.pitch(200, duration=500)
Flasher pour tester puis bouton reset pour lancer

Documentation sur music

Etape 7 Utiliser les boutons

La carte micro:bit dispose de deux boutons permettant de déclencher des actions : le bouton A à gauche de la carte, le bouton B à droite.
Programme en utilisant le bouton A :

from microbit import display, button_a, Image 
import time 
 
while True: 
    if button_a.is_pressed(): 
        led_image = Image("40004:06060:00900:06060:40004") 
        display.show(led_image) 
        time.sleep(0.5) 
        display.clear() 
        time.sleep(0.5) 
    led_image = Image("33333:30003:30003:30003:33333") 
    display.show(led_image)
Flasher pour tester puis bouton reset pour lancer

Optimise ton code :

from microbit import display, button_a, Image 
import time 
 
led_image_a = Image("40004:06060:00900:06060:40004") 
led_image = Image("33333:30003:30003:30003:33333") 
 
while True: 
    if button_a.is_pressed(): 
        display.show(led_image_a) 
        time.sleep(0.5) 
        display.clear() 
        time.sleep(0.5) 
    display.show(led_image)

Programme en utilisant le bouton A et le bouton B:

from microbit import display, button_a, button_b, Image 
import time 

led_image_a = Image("90009:09090:00900:09090:90009") 
led_image_b = Image("99999:99999:99999:99999:99999") 
led_image = Image("33333:30003:30003:30003:33333") 

while True: 
    if button_a.is_pressed(): 
        display.show(led_image_a) 
        time.sleep(0.5) 
        display.clear() 
        time.sleep(0.5) 
    if button_b.is_pressed(): 
        display.show(led_image_b) 
        time.sleep(0.5) 
        display.clear() 
        time.sleep(0.5) 
    display.show(led_image)
Flasher pour tester puis bouton reset pour lancer

Documentation sur les boutons

Etape 8 Utiliser la touche sensitive

Touche la touche sensitive pour changer les LEDs.

from microbit import display, Image, pin_logo
import time
while True:
    # Détection de la zone sensible  
    if pin_logo.is_touched(): 
        led_image = Image('90009:09090:00900:09090:90009') 
        display.show(led_image) 
        # Affichage tant que la zone sensible est touchée
        while pin_logo.is_touched():
          pass
    led_image = Image('00900:00900:99999:00900:00900') 
    display.show(led_image)
Flasher pour tester puis bouton reset pour lancer

Que constates-tu après avoir téléversé le programme ?
Les LEDs changent quand tu passes ton doigt sur la zone sensitive ?

Documentation zone_sensible

Etape 9 Utiliser la touche sensitive et les boutons

Modifie ton programme sur le battement du cœur pour augmenter ou baisser la note par les touches A et B, activer ou éteindre le son avec la zone sensitive.

from microbit import display, Image, button_a, button_b, pin_logo 
import time 
import music 
 
note = 200 
on = True 
start = time.time() 

while True:
    # Battement du coeur toutes les 1 seconde
    if time.time() - start > 1:
        start = time.time()
        display.clear()
        if on : 
            music.pitch(note, 200)
        time.sleep(0.1)
    else:  
        display.show(Image.HEART) 
              
    # Modification de la note avec la touche A  
    if button_a.is_pressed(): 
        if note > 0 : 
            note -= 10 
        while button_a.is_pressed(): 
            pass  
        on = True 
         
    # Modification de la note avec la touche B  
    if button_b.is_pressed(): 
        if note < 600 : 
            note += 10 
        while button_b.is_pressed(): 
            pass  
        on = True 
         
    # Activer ou non le battement du coeur  
    if pin_logo.is_touched(): 
 
        if on : 
            on = False 
        else: 
            on = True 
        while pin_logo.is_touched() : 
            pass
Flasher pour tester puis bouton reset pour lancer

Etape 10 Secouer les LEDs

Secouer la carte pour allumer les LEDs.

from microbit import display, Image, accelerometer 
import time
while True: 
    if accelerometer.current_gesture() == 'shake' : 
        led_image = Image('90009:09090:00900:09090:90009') 
        display.show(led_image) 
        time.sleep(0.1)
    led_image = Image('00900:00900:99999:00900:00900') 
    display.show(led_image)
Flasher pour tester puis bouton reset pour lancer

Que constates-tu après avoir téléversé le programme ?
Tu peux essayer ces différentes possibilités :

  • « shake » : secoué
  • « up » : vers le haut
  • « down » : vers le bas
  • « face up » : écran vers le haut
  • « face down » : écran vers le bas
  • « left » : penché à gauche
  • « right » : penché à droite
  • « freefall » : chute libre
  • « 3g » : 3g
  • « 6g » : 6g
  • « 8g » : 8g

Documentation sur l’accéléromètre

from microbit import * 
led_image = Image("33333:30003:30003:30003:33333") 
while True: 
    if accelerometer.current_gesture() == 'face up': 
        display.show(Image.ARROW_N) 
    elif accelerometer.current_gesture() == 'face down': 
        display.show(Image.ARROW_S) 
    elif accelerometer.current_gesture() == 'left': 
        display.show(Image.ARROW_W) 
    elif accelerometer.current_gesture() == 'right': 
        display.show(Image.ARROW_E) 
    else: 
        display.show(led_image)
Flasher pour tester puis bouton reset pour lancer

Etape 11 Utiliser le microphone

Claque des mains pour allumer les LEDs.

from microbit import * 
 
microphone.set_threshold(SoundEvent.LOUD, 80) 
 
while True: 
    if microphone.current_event() == SoundEvent.LOUD: 
 
        led_image = Image('90009:09090:00900:09090:90009') 
        display.show(led_image) 
 
    led_image = Image('00900:00900:99999:00900:00900') 
    display.show(led_image)
Flasher pour tester puis bouton reset pour lancer
from microbit import * 
import time 
 
while True: 
    if microphone.sound_level() > 64: 
        led_image = Image('90009:09090:00900:09090:90009') 
        display.show(led_image) 
        time.sleep(0.3) 
    else: 
        led_image = Image('00900:00900:99999:00900:00900') 
        display.show(led_image)
Flasher pour tester puis bouton reset pour lancer

Que constates-tu après avoir téléversé le programme ?
Essaye d’allumer les LEDs d’un claquement de mains, elles doivent rester allumer. Puis claque des mains pour les éteindre.

Etape 12 Jouer de la musique

Joue différentes musiques en appuyant sur les boutons A et B et sur la zone sensitive.

from microbit import button_a, button_b, pin_logo, pin_speaker 
import time 
def pitch(pin, noteFrequency, noteDuration, silence_ms=10): 
    if noteFrequency != 0: 
        microsecondsPerWave = 1e6 / noteFrequency 
        millisecondsPerCycle = 1000 / (microsecondsPerWave * 2) 
        loopTime = noteDuration * millisecondsPerCycle 
        for x in range(int(loopTime)): 
            pin.write_digital(1) 
            time.sleep(int(microsecondsPerWave)) 
            pin.write_digital(0) 
            time.sleep(int(microsecondsPerWave)) 
    else: 
        time.sleep_ms(noteDuration) 
        time.sleep_ms(silence_ms) 

def BuzzerStarWars(pin): 
    NOTES = ([293.66, 293.66, 293.66, 392.0, 622.25, 554.37, 
            523.25, 454, 932.32, 622.25, 554.37, 523.25, 
            454, 932.32, 622.25, 554.37, 523.25, 554.37, 454]) 
    DURATIONS = ([180, 180, 180, 800, 800, 180, 180, 180, 800, 
        400, 180, 180, 180, 800, 400, 180, 180, 180, 1000]) 
    SILENCE_DELAYS = ([40, 40, 40, 100, 100, 40, 40, 40, 100, 50, 
        40, 40, 40, 100, 50, 40, 40, 40, 100]) 
    for i in range(len(NOTES)): 
        pitch(pin, NOTES[i], DURATIONS[i], SILENCE_DELAYS[i]) 

def BuzzerR2D2(pin): 
    R2D2_NOTES = ([3520, 3135.96, 2637.02, 2093, 2349.32, 
        3951.07, 2793.83, 4186.01, 3520, 3135.96, 
        2637.02, 2093, 2349.32, 3951.07, 2793.83, 4186.01]) 
    for i in range(len(R2D2_NOTES)): 
        pitch(pin, R2D2_NOTES[i], 80, 20) 

def BuzzerCarribeanPirates(pin): 
    NOTES_1 = ([330, 392, 440, 440, 0, 440, 494, 523, 523, 
        0, 523, 587, 494, 494, 0, 440, 392, 440, 0]) 
    DURATIONS_1 = ([125, 125, 250, 125, 125, 125, 125, 250, 
        125, 125, 125, 125, 250, 125, 125, 125, 125, 375, 125]) 
    NOTES_2 = ([330, 392, 440, 440, 0, 440, 523, 587, 587, 0, 
        587, 659, 698, 698, 0, 659, 587, 659, 440, 0, 
        440, 494, 523, 523, 0, 587, 659, 440, 0, 440, 
        523, 494, 494, 0, 523, 440, 494, 0]) 
    DURATIONS_2 = ([125, 125, 250, 125, 125, 125, 125, 250, 125, 
        125, 125, 125, 250, 125, 125, 125, 125, 125, 
        250, 125, 125, 125, 250, 125, 125, 250, 125, 
        250, 125, 125, 125, 250, 125, 125, 125, 125, 375, 375]) 
    for j in range(2): 
        for i in range(len(NOTES_1)): 
            pitch(pin, NOTES_1[i], DURATIONS_1[i]) 
    for k in range(len(NOTES_2)): 
        pitch(pin, NOTES_2[k], DURATIONS_2[k]) 

while True: 
    if button_a.is_pressed(): 
        BuzzerStarWars(pin_speaker) 
    if button_b.is_pressed(): 
        BuzzerR2D2(pin_speaker) 
    if pin_logo.is_touched(): 
        BuzzerCarribeanPirates(pin_speaker)
Flasher pour tester puis bouton reset pour lancer

Etape 13 Jouer aux dés

Secoue la micro :bit pour jouer aux dés.

from microbit import * 
import random 
import music 

de_1 = Image('00000:00000:00900:00000:00000') 
de_2 = Image('00009:00000:00000:00000:90000') 
de_3 = Image('00009:00000:00900:00000:90000') 
de_4 = Image('90009:00000:00000:00000:90009') 
de_5 = Image('90009:00000:00900:00000:90009') 
de_6 = Image('90009:00000:90009:00000:90009') 
display.show('?') 
nombre = 0

while True: 
    if accelerometer.current_gesture() == 'shake' : 
        nombre = random.randint(1, 6) 
        music.pitch(440, 50) 
    if nombre == 1: 
        display.show(de_1) 
    if nombre == 2: 
        display.show(de_2) 
    if nombre == 3: 
        display.show(de_3) 
    if nombre == 4: 
        display.show(de_4) 
    if nombre == 5: 
        display.show(de_5) 
    if nombre == 6: 
        display.show(de_6)
Flasher pour tester puis bouton reset pour lancer
Catégories
Robotique UNIHIKER

Portique de contrôle

Objectif du projet

Créer un portique de chronométrage pour mesurer le temps mis par un robot suiveur de ligne pour parcourir un circuit.
Le portique détecte le passage du robot grâce à des capteurs infrarouges et affiche le temps sur l’écran du microcontrôleur UNIHIKER.

Le robot passe une première fois sous le portique au départ, puis une deuxième fois à l’arrivée.

  • Premier passage : démarrage du chronomètre.
  • Deuxième passage : arrêt du chronomètre.

Les composants du portique

ÉlémentRôleDescription
🧠 Microcontrôleur UNIHIKERLe cerveau du portiqueIl gère les capteurs, mesure le temps et affiche les résultats sur son écran.
👀 Deux capteurs photoréflecteurs IRDétecter le robotPlacés en vis-à-vis de chaque côté du portique, ils détectent quand le robot passe (interruption du faisceau).
💡 LED verteIndiquer que le portique est prêtAllumée : le portique attend le départ du robot.
🔴 LED rougeIndiquer la mesure en coursAllumée : le portique mesure le temps du parcours.
📺 Écran intégré à l’UNIHIKERAffichage du résultatMontre le message “Prêt”, “Course en cours…” et le temps mesuré.

Le portique attend le robot (LED verte).
Le robot passe une première fois → démarrage du chrono.
Le robot passe une deuxième fois → arrêt du chrono et affichage.

Programmation de l’interface

Détail des instructions pour l’affichage du temps :

Lance pour vérifier l’affichage

Programmation de la détection des passages

⚙️ Principe de détection du robot par le portique

🔦 1. Comment le portique détecte le passage du robot

Le portique utilise un photoréflecteur infrarouge.
C’est un petit capteur qui envoie de la lumière invisible (infrarouge) et mesure la lumière qu’il reçoit en retour.

  • Quand rien ne passe, la lumière rebondit normalement :
    👉 le capteur reçoit beaucoup de lumière.
  • Quand le robot passe devant, il bloque ou réfléchit moins la lumière :
    👉 le capteur reçoit moins de lumière.

C’est ce changement de niveau de lumière que le portique utilise pour savoir qu’un robot vient de passer.

🧠 2. La variable mesure_en_cours

Pour que le portique sache s’il doit démarrer ou arrêter le chronomètre, on utilise une variable mémoire qu’on appelle ici :

Cette variable peut prendre deux valeurs :

ValeurSignificationÉtat du portique
0Attente du robot au départPortique prêt, LED verte allumée
1Chronométrage en coursLED rouge allumée, le portique mesure le temps
⏱️ 3. Les deux passages du robot
🟢 Premier passage : le départ
  1. Le portique attend (mesure_en_cours = 0).
  2. Le robot passe → le capteur détecte un changement de lumière.
  3. Le portique :
    • allume la LED rouge,
    • met mesure_en_cours = 1,
    • attente que le véhicule passe.
🔴 Deuxième passage : l’arrivée
  1. Le robot repasse sous le portique.
  2. Le capteur détecte à nouveau un changement de lumière.
  3. Le portique :
    • rallume la LED verte,
    • remet mesure_en_cours = 0 (prêt pour une nouvelle mesure),
    • attente que le véhicule passe.

Le programme avec la détection et le comptage des passages :

Lance pour vérifier

Programmation du chronomètre

🟢 Premier passage : le départ

  1. démarre le chronomètre,

⏱️ Affichage du temps

  1. affiche le temps sur l’écran,

Lance pour vérifier

Programmation en python

Bibliothèques conseillées

import time
import math
from unihiker import GUI
from pinpong.board import Board,Pin
from pinpong.extension.unihiker import *

Objets à instancier
# Interfaces
u_gui=GUI()
# Micro contrôleur
Board().begin()

# Photo réflecteur IR sur le port P1
p_p1_analog=Pin(Pin.P1, Pin.ANALOG)

# LED rouge
p_p14_out=Pin(Pin.P14, Pin.OUT)

# LED verte
p_p15_out=Pin(Pin.P15, Pin.OUT)

# Lecture du photo réflecteur IR
lumiere = p_p1_analog.read_analog()

# Gestion des LEDs
p_p14_out.write_digital(0)
p_p15_out.write_digital(1)

# Affichage du chronomètre
mm = 0
ss = 0
chrono=u_gui.draw_clock(
h=mm,m=0,s=ss,
x=120,y=200,r=50,
color= »#0000FF »)
text_chrono = u_gui.draw_text(
text= »Temps= »+
str(mm).zfill(2)+ »: »+str(ss).zfill(2), 
x=20,y=260,
font_size=20, color= »#0000FF »)

# Affichage d’un texte
u_gui.draw_text(
text= »texte à afficher »,
x=40,y=25,
font_size=20, color= »#0000FF »)

# Dessin d’une surface rectangle
u_gui.fill_rect(x=5,y=5,w=230,h=90,color= »#CCFFFF »)

# Dessin d’un pourtour d’un rectangle
u_gui.draw_rect(x=0,y=0,w=240,h=100,width=10,color= »#FF0000″)

# Gestion du temps (pour le chrono)
# Récupération du temps
start = time.time()
# Calcul d’une durée en minutes et secondes
duree = int(time.time() – start)
mm = int(duree / 60)
ss = int(duree – (mm * 60))

# Exemple pour l’affichage du temps
chrono.config(h=mm,m=0,s=ss)
text_chrono.config(text= »Temps= »+str(mm).zfill(2)+ »: »+str(ss).zfill(2))

Catégories
ALGORA Non classé Robotique

Barrière automatique

Construis ce robot barrière automatique avec un servomoteur :

Clique sur le menu Edition en haut de l’écran et choisis Paramètres des ports.

Clique ensuite sur le bouton Tout décocher .

Puis coche D9 pour indiquer l’installation du servomoteur :

Vérifie que l’instruction sur le servomoteur est couleur bleue :

Active le test pour contrôler le servomoteur :

Utilise deux instructions servomoteur pour connaitre la position de la barrière ouverte et celle de la barrière fermée :

En cliquant sur les instructions, tu commande le servomoteur, attention il doit être sous tension.

Si tu veux contrôler la vitesse d’ouverture de la barrière :

Donne un nom à aux deux actions :

Installe un bouton poussoir pour piloter l’ouverture de ta barrière :

Installe le connecteur du bouton poussoir sur A0 et modifie les paramètres des ports :

Vérifie que l’instruction sur le capteur de pression est bien de la couleur bleue :

Programme pour ouvrir la barrière sur l’appui du capteur de pression, puis attendre un certain avant de refermer automatiquement la barrière :

Transfert ton programme et test le bon fonctionnement :

Rajoute une LED rouge pour prévenir que la barrière est fermée :

Installe la LED sur A1 :

Programme pour allumer la LED rouge quand la barrière est fermée.

Introduis la possibilité de deux modes de fonctionnement :

  • un mode avec une ouverture puis une fermeture automatique
  • un mode avec juste une ouverture

Pour distinguer les deux modes, un appui rapide sur le bouton poussoir permet une ouverture puis une fermeture, un appui long permet une ouverture simple :

Transfert ton programme et test le bon fonctionnement :

Catégories
UNIHIKER

UNIHIKER premiers pas

BONjour emoji
Bouton A ou B lumineux
Détecteur de luminosité
Piano musical
Détecteur de luminosité
compteur de sauts

Bonjour et EMOJI

Ce projet utilise la classe GUI de la bibliothèque UNIHIKER et la fonction draw_emoji() pour générer des emojis émotionnels.

Importe les bibliothèques :

from unihiker import GUI
import time

Crée cet objet pour gérer les interfaces :

gui = GUI()

Instruction pour dessiner un cercle :

circle = gui.draw_circle(x = 120,y = 140,r = 50,width = 3,color = "#FF6666")
  • x et y position du centre du cercle sur l’écran
  • r le rayon du cercle
  • width et color la largeur et la couleur du dessin du cercle

Documentation draw_circle

Instruction pour créer un emoji

emj = gui.draw_emoji(emoji = "Wink", origin = "center", x=120, y=120, duration = 0.2, w=50)
  • emoji = type d’emoji
  • origin = arrangement de l’emoji par rapport à sa position
  • x, y = positionnement de l’emoji sur l’écran
  • duration = durée de l’animation
  • w = taille de l’emoji

Documentation draw_emoji

Instruction pour l’affichage du text :

Text = gui.draw_text(text='Hello , Patrick !',
                     x=15,y=260,
                     font_size=20)
  • text = texte à afficher
  • x,y = positionnement du texte à l’écran
  • font_size = taille de la police de caractère

Documentation gui.draw_text

from unihiker import GUI
import time 

gui = GUI()

# Dessin d'un cercle pour le visage
circle = gui.draw_circle(x = 120,y = 140,r = 50,width = 3,color = "#FF6666")

# Création de l'emoji 
emj = gui.draw_emoji(emoji = "Wink", origin = "center", x=120, y=120, duration = 0.2, w=50) 

# Affichage du prénom en bas de l'écran
Text = gui.draw_text(text='Hello , Patrick !',x=15,y=260,font_size=20)
Text.config(color='#0000FF')

width = 50
radius = 30
delta_radius = 2.5
delta_width = 5
while True:
    # Animation de l'emoji 
    time.sleep(0.3)
    width += delta_width
    radius += delta_radius
    circle.config(r=radius)
    emj.config(w = width) 
    if not (50 <= width <= 240):
        delta_width = -delta_width
        delta_radius = -delta_radius

Si tu veux une progression plus douce (effet oscillation)
Tu peux remplacer l’incrémentation linéaire par une fonction sinus :

from unihiker import GUI
import time, math

gui = GUI()

# Dessin d'un cercle pour le visage
circle = gui.draw_circle(x = 120,y = 140,r = 50,width = 3,color = "#FF6666")

# Création de l'emoji 
emj = gui.draw_emoji(emoji = "Wink", origin = "center", x=120, y=120, duration = 0.2, w=50) 

# Affichage du prénom en bas de l'écran
Text = gui.draw_text(text='Hello , Patrick !',x=15,y=260,font_size=20)
Text.config(color='#0000FF')

width = 50
radius = 30
delta_radius = 2.5
delta_width = 5

t = 0
while True:
    time.sleep(0.03)
    radius = 80 + 40 * math.sin(t)
    width = 120 + 60 * math.sin(t)
    circle.config(r=int(radius))
    emj.config(w=int(width))
    t += 0.1

Les différentes possibilité des emoji.

  • Angry,
  • Nerve,
  • Peace,
  • Shock,
  • Sleep,
  • Smile,
  • Sweat,
  • Think,
  • Wink

Changement des EMOJI avec les boutons A ou B

from unihiker import GUI
from pinpong.extension.unihiker import *
import time, math

gui = GUI()

# Dessin d'un cercle pour le visage
circle = gui.draw_circle(x = 120,y = 140,r = 50,width = 3,color = "#FF6666")

emoji_table = ["Angry", "Nerve", "Peace", "Shock", "Sleep", "Smile", "Sweat", "Think", "Wink"]
index = 0
# Création de l'emoji 
emj = gui.draw_emoji(emoji = emoji_table[index], origin = "center", x=120, y=120, duration = 0.2, w=50) 

# Affichage du prénom en bas de l'écran
Text = gui.draw_text(text='Hello , Patrick !',x=15,y=260,font_size=20)
Text.config(color='#0000FF')

width = 50
radius = 30
delta_radius = 2.5
delta_width = 5
import time, math

t = 0
while True:
    time.sleep(0.03)
    radius = 80 + 40 * math.sin(t)
    width = 120 + 60 * math.sin(t)
    circle.config(r=int(radius))
    emj.config(w=int(width))
    t += 0.1
    # Changement de l'emoji avec le bouton A ou B
    if (button_a.is_pressed()==True):
        index = index + 1 if index < 8 else 0
        emj.config(emoji = emoji_table[index])
    if (button_b.is_pressed()==True):
        index = index - 1 if index > 0 else 8
        emj.config(emoji = emoji_table[index])

Bouton A ou B lumineux

Les boutons A et B de l’UNIHIKER sont accessibles à l’utilisateur, ce qui permet de créer un projet impliquant une LED contrôlée par des boutons. Ce projet vérifie d’abord si les boutons A et B de l’UNIHIKER ont été enfoncés, puis contrôle l’allumage et l’extinction de la LED bleue située à l’arrière de l’UNIHIKER. La bibliothèque PinPong propose deux façons d’utiliser les boutons : la première consiste à lire directement la requête, la seconde à utiliser les rappels d’événements d’interruption. Voici un exemple de contrôle de l’allumage et de l’extinction de la LED à l’aide des boutons A et B.

Utilise ces librairies :

from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import GUI

Crée un objet pour les interfaces :

gui=GUI()

Initialise la carte du microcontrôleur :

Board().begin()

Instruction pour dessiner un cercle plein

ledUI = gui.fill_circle(x=120,y=100,r=50,color="#FFFF00")

Documentation fill_circle

Pour tester l’appui sur les boutons A ou B utilise cette instruction

if (button_a.is_pressed()==True):

Documentation sur la gestion des boutons

Test de l’appui de boutons dans le code :

from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import GUI

# Initialisation de l'interface et de la carte
gui=GUI()
Board().begin()

# Initialisation de la LED
ledUI = gui.fill_circle(x=120,y=100,r=50,color="#FFFF00")
led = Pin(Pin.P25, Pin.OUT)

while True:
    # Bouton A appuyé
    if (button_a.is_pressed()==True):
        led.write_digital(1)
        ledUI.config(color="#0000FF")

    # Bouton B appuyé
    if (button_b.is_pressed()==True):
        led.write_digital(0)
        ledUI.config(color="#FF0000")

Fonctions d’interception de l’événement de l’appui sur le bouton A ou B

from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import GUI

# Controle de l'appui du bouton A
def on_buttona_click_callback():
    led.write_digital(1)
    ledUI.config(color="#0000FF")

# Controle de l'appui du bouton B
def on_buttonb_click_callback():
    led.write_digital(0)
    ledUI.config(color="#FF0000")

# Initialisation de l'interface et de la carte
gui=GUI()
Board().begin()

ledUI = gui.fill_circle(x=120,y=100,r=50,color="#FFFF00")

# Eteindre la LED
led = Pin(Pin.P25, Pin.OUT)

# Intercpetion des boutons A et B
gui.on_a_click(on_buttona_click_callback)
gui.on_b_click(on_buttonb_click_callback)


while True:
    pass

LED externe sur le port 22

led = Pin(Pin.P22, Pin.OUT)

Détecteur de luminosité

UNIHIKER est équipé d’un capteur de lumière placé au-dessus de l’écran frontal, permettant de détecter l’intensité lumineuse ambiante. Grâce à cette fonctionnalité, un détecteur de luminosité peut être développé. Ce projet consiste à afficher la valeur lumineuse détectée par le capteur sur l’écran.

Documentation sur le dispositif light sensor

from unihiker import GUI
import time

from pinpong.board import Board 
from pinpong.extension.unihiker import *

# # initialization
Board().begin()

# Instantiate a GUI object
gui = GUI()
img = gui.fill_circle(x=120,y=100,r=50,color="#FFFF00")
value = gui.draw_text(x=145, y=28, text='0', font_size=18)

while True :
    # Update the displayed light value
    Light = light.read()
    value.config(text = Light)

    # Light value level
    if Light < 600:
        img.config(color="#FF6600")
    elif 600 <= Light < 1024:
        img.config(color="#FF9900")
    elif 1024 <= Light < 2048:
        img.config(color="#FFCC33")
    elif 2048 <= Light < 3072:
        img.config(color="#FFFF99")
    else:
        img.config(color="#FFFF00")

    time.sleep(1)

Dans cet exemple, UNIHIKER est initialisé avec Board().begin(). Ensuite, un objet GUI est instancié et un objet image et un objet texte sont créés à l’aide des méthodes draw_image() et draw_text(), respectivement. Dans la boucle principale, l’intensité lumineuse ambiante est obtenue grâce à la méthode light.read() de la bibliothèque PinPong, et la valeur lumineuse est affichée à l’écran grâce à la méthode draw_text() de la bibliothèque GUI.

L’intensité lumineuse ambiante est divisée en cinq niveaux en moyenne, et différents niveaux de luminosité sont représentés par des cercles de couleurs différentes, selon les conditions d’éclairage.

Piano musical

L’UNIHIKER est équipé d’un buzzer capable d’émettre différentes tonalités en réglant différentes fréquences. Cette fonctionnalité permet de créer un piano électronique. Ce projet propose une interface utilisateur simple permettant aux utilisateurs de jouer différentes notes en appuyant sur des boutons à l’écran. Voici un exemple de piano électronique :

Documentation pour dessiner les touches du clavier

from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import GUI
import time

# Gestion des touches du piano
def button_click1():
    buzzer.pitch(262,1)
    text.config(text="C4")
def button_click2():
    buzzer.pitch(294,1)
    text.config(text="D4")
def button_click3():
    buzzer.pitch(330,1)
    text.config(text="E4")
def button_click4():
    buzzer.pitch(349,1)
    text.config(text="F4")
def button_click5():
    buzzer.pitch(392,1)
    text.config(text="G4")
def button_click6():
    buzzer.pitch(440,1)
    text.config(text="A4")
def button_click7():
    buzzer.pitch(494,1)
    text.config(text="B4")
def button_click8():
    buzzer.pitch(277,1)
    text.config(text="C#4")
def button_click9():
    buzzer.pitch(311,1)
    text.config(text="D#4")
def button_click10():
    buzzer.pitch(370,1)
    text.config(text="F#4")
def button_click11():
    buzzer.pitch(415,1)
    text.config(text="G#4")
def button_click12():
    buzzer.pitch(466,1)
    text.config(text="A#4")

# Initialisation de l'interface et de la carte
u_gui=GUI()
Board().begin()
# Affichage du titre
bg=u_gui.fill_rect(x=0,y=0,w=240,h=320,color="#CCCCFF")
text = u_gui.draw_text(x=185,y=160,text="Clavier musical",origin="center",font_size=28,angle=270)

# Zones sensibles du clavier musical (touches blanches)
do=u_gui.fill_rect(x=0,y=3,w=130,h=43,color="#FFFFFF",onclick=button_click1)
re=u_gui.fill_rect(x=0,y=48,w=130,h=43,color="#FFFFFF",onclick=button_click2)
mi=u_gui.fill_rect(x=0,y=93,w=130,h=43,color="#FFFFFF",onclick=button_click3)
fa=u_gui.fill_rect(x=0,y=138,w=130,h=43,color="#FFFFFF",onclick=button_click4)
so=u_gui.fill_rect(x=0,y=183,w=130,h=43,color="#FFFFFF",onclick=button_click5)
la=u_gui.fill_rect(x=0,y=228,w=130,h=43,color="#FFFFFF",onclick=button_click6)
xi=u_gui.fill_rect(x=0,y=273,w=130,h=43,color="#FFFFFF",onclick=button_click7)

# Zones sensibles du clavier musical (touches noires)
bian1=u_gui.fill_rect(x=50,y=32,w=80,h=30,color="#000000",onclick=button_click8)
bian2=u_gui.fill_rect(x=50,y=77,w=80,h=30,color="#000000",onclick=button_click9)
bian3=u_gui.fill_rect(x=50,y=167,w=80,h=30,color="#000000",onclick=button_click10)
bian4=u_gui.fill_rect(x=50,y=212,w=80,h=30,color="#000000",onclick=button_click11)
bian5=u_gui.fill_rect(x=50,y=257,w=80,h=30,color="#000000",onclick=button_click12)

while True:
    time.sleep(0.1)

Dans cet exemple, UNIHIKER est initialisé avec Board().begin().

Ensuite, un objet GUI est instancié, sur un fond bleu plusieurs rectangles noirs et blancs (représentant différentes touches de piano) sont créés à l’aide de la fonction fill_rect().

Ensuite, une série de fonctions d’événements sur le click de chaque touche sont définies, chacune correspondant à une note de musique.

Dans les fonctions appelées par un click sur la touche, le buzzer est contrôlé pour émettre un son d’une fréquence et d’une durée spécifiques à l’aide de la fonction buzzer.pitch (frequency, duration).

Chaque note de musique est liée à une touche de piano, et lorsque la touche est enfoncée, la fonction de rappel correspondante est exécutée et le buzzer joue la note correspondante.

De plus, une zone de texte affiche le nom de la note jouée, permettant ainsi à l’utilisateur d’identifier la note jouée.

Sonde sonore

L’UNIHIKER est également équipé d’un microphone capable de capter l’intensité du bruit ambiant. Cette fonctionnalité permet de créer un dispositif de surveillance du bruit, affichant l’intensité du bruit ambiant à l’écran. De plus, un seuil de bruit peut être défini ; lorsqu’il est dépassé, un signal sonore retentit pour vous avertir. Voici un exemple de dispositif de surveillance du bruit :

Documentation sur la sonde sonore

from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import Audio
from unihiker import GUI

Board().begin()

# Instantiation des objets audio et interface
audio = Audio()
gui = GUI()
# Titre du dispositif
gui.draw_text(text="Sonde sonore",x=120,y=50,font_size=20, color="#0000FF", origin="center")
# Affichage du niveau sonore
sound_text = gui.draw_text(text="",x=120,y=170,font_size=55, color="#0000FF", origin="center")

while True:
    # Récupération du niveau sonore et son affichage
    sound_value = audio.sound_level()
    sound_text.config(text=sound_value, color="#0000FF")

    # Déctection du niveau sonore
    if (sound_value > 50):
        # Alerte visuelle et sonore
        sound_text.config(color="#FF0000")
        buzzer.pitch(392)
        time.sleep(0.1)
        buzzer.stop()
        # On laisse le niveau sonore retomber avant de le mesurer à nouveau
        time.sleep(1)

Dans cet exemple, l’UNIHIKER est initialisé avec la fonction Board().begin().

Ensuite, un objet Audio et un objet GUI sont instanciés, et deux objets texte sont créés avec la fonction draw_text(). Ces objets texte affichent respectivement la surveillance du bruit et les valeurs de bruit correspondantes.

Dans la boucle principale, la méthode sound_level() de l’objet Audio permet d’obtenir l’intensité sonore ambiante, puis la méthode config() de l’objet texte permet de mettre à jour la valeur de luminosité à l’écran. Parallèlement, l’intensité sonore est vérifiée pour vérifier si elle dépasse le seuil défini. Si tel est le cas, la fonction buzzer.pitch(frequency) émet une alarme sonore, puis la fonction buzzer.stop() désactive le buzzer.

Compteur de sauts

L’UNIHIKER est également équipé d’un accéléromètre et d’un gyroscope 6 axes, capables de lire les valeurs x, y et z de l’accéléromètre et du gyroscope individuellement. Cette fonctionnalité permet de créer un compteur de saut : les valeurs de l’accéléromètre et du gyroscope s’affichent à l’écran, et le nombre de saut est calculé et affiché en fonction de l’intensité de l’accélération.

Documentation sur l’accéléromètre et le gyroscope

from pinpong.extension.unihiker import *
from pinpong.board import Board,Pin
from unihiker import GUI
import time

# Chronomètre du temps du jeu
chrono = 0
# Compteur de sauts
value = 0

# Réinitialisation des compteurs avec le bouton A
def on_buttona_click_callback():
    global chrono
    global value
    chrono = 0
    value = 0

# Initialisation de la carte et de l'interface
Board().begin()
gui = GUI()

# Affichage des données
gui.draw_text(text="Accéléromètre",x=10,y=5,font_size=16, color="#0000FF")
gui.draw_text(text="Gyroscope",x=10,y=105,font_size=16, color="#0000FF")
gui.draw_text(text="Compteur de sauts",x=10,y=210,font_size=16, color="#0000FF")
accelerometer_x = gui.draw_text(text="X：",x=30,y=35,font_size=12, color="#000000")
accelerometer_y = gui.draw_text(text="Y：",x=30,y=60,font_size=12, color="#000000")
accelerometer_z = gui.draw_text(text="Z：",x=30,y=85,font_size=12, color="#000000")
gyroscope_x = gui.draw_text(text="X：",x=30,y=135,font_size=12, color="#000000")
gyroscope_y = gui.draw_text(text="Y：",x=30,y=160,font_size=12, color="#000000")
gyroscope_z = gui.draw_text(text="Z：",x=30,y=185,font_size=12, color="#000000")
pedometer=gui.draw_text(text=value,x=30,y=230,font_size=45, color="#000000")

# Attente appui bouton A pour commmencer
gui.wait_a_click()

# Initialisation pour interception l'appui sur le bouton A
gui.on_a_click(on_buttona_click_callback)

while True:
    # Récupération des mouvements par l'accéléromètre et le gyroscope
    accelerometer_x.config(text=(str("X：") + str(accelerometer.get_x())))
    accelerometer_y.config(text=(str("Y：") + str(accelerometer.get_y())))
    accelerometer_z.config(text=(str("Z：") + str(accelerometer.get_z())))
    gyroscope_x.config(text=(str("X：") + str(gyroscope.get_x())))
    gyroscope_y.config(text=(str("Y：") + str(gyroscope.get_y())))
    gyroscope_z.config(text=(str("Z：") + str(gyroscope.get_z())))

    # Comptage de sauts
    if (accelerometer.get_strength() > 1.5):
        value = (value + 1)
    
    # Affichage des sauts et du chronomètre
    pedometer.config(text=str(value) + "/" + str(int(chrono)))
    time.sleep(0.1)
    chrono +=0.1

Dans cet exemple, l’UNIHIKER est initialisé avec la fonction Board().begin() et un objet GUI est instancié.
Ensuite, grâce à la méthode draw_text(), plusieurs objets texte sont créés pour afficher les valeurs d’accélération, de gyroscope et de nombre de pas, ainsi que leurs valeurs correspondantes.

Le programme principal utilise accelerometer.get_x(), accelerometer.get_y() et accelerometer.get_z() pour obtenir les valeurs x, y et z de l’accélération, et gyroscope.get_x(), gyroscope.get_y() et gyroscope.get_z() pour les valeurs x, y et z du gyroscope. Ces valeurs sont ensuite affichées à l’écran grâce à la méthode config() de l’objet texte.

De plus, le nombre de saut est calculé à l’aide de la fonction accelerometer.get_strength() et incrémenté de 1 lorsque l’intensité d’accélération dépasse 1,5.

Le nombre de sauts est affiché à l’écran avec le chronomètre via la méthode config() de l’objet texte.

Catégories
MICRO PYTHON MICRO:BIT

Bataille navale Micro:bit

🚀 Mission : Détruire les navires ennemis et rester le dernier survivant !

Principe du jeu
exemple en mode bloc
exemple en python

Principe du jeu

Votre objectif ? Couler les navires adverses et être le dernier joueur encore en lice ! Chaque micro:bit représente un champ de bataille : à vous de viser juste.

Comment ça marche ?

  • Un navire caché : Dès que vous allumez votre micro:bit, un navire apparaît aléatoirement sur la grille de LEDs (reconnaissable à sa lumière plus faible).
  • Un missile à guider : La LED la plus brillante, c’est votre missile ! Inclinez votre micro:bit (avant/arrière, gauche/droite) pour le déplacer et viser l’ennemi.
  • Prêt à tirer ?
    • Bouton A : Figez la position de votre missile pour ajuster votre tir.
    • Bouton B : FEU ! Envoyez votre missile vers les adversaires.
  • Touché ! Si votre missile atteint un navire, la micro:bit de la victime joue une musique de défaite… mais attention, elle reviendra en jeu après un délai ! À vous de la neutraliser à nouveau.

💻 À vous de coder ! Pour créer ce jeu, voici les fonctionnalités clés à programmer :

  1. Communication radio : Envoyez et recevez les coordonnées (ligne/colonne) des tirs entre toutes les micro:bits du jeu.
  2. Contrôle du missile : Utilisez l’accéléromètre pour déplacer le missile en inclinant la carte.
  3. Gestion des tirs :
    • Bouton A : Verrouillez la position du missile.
    • Bouton B : Lancez le tir et transmettez les coordonnées aux autres joueurs.
  4. Position aléatoire du navire : À chaque début de partie, le navire apparaît à un endroit aléatoire.
  5. Détection de collision : Si un missile touche un navire, affichez une croix et déclenchez une musique de défaite.
  6. Temps de réapparition : Un navire touché réapparaît après quelques secondes : soyez prêt à recommencer !

💡 Pourquoi c’est génial ?

  • Un jeu multijoueur : Affrontez vos amis en temps réel !
  • De la stratégie : Mémorisez les tirs et neutralisez vos adversaires.
  • Un projet complet : Codez la logique, l’affichage des LEDs, les sons et la communication entre cartes.

🛠️ Prêt à relever le défi ? Avec la micro:bit, vous allez apprendre à : ✔ Utiliser des capteurs (accéléromètre, boutons). ✔ Programmer l’affichage des LEDs et des sons. ✔ Faire communiquer plusieurs cartes entre elles.

À vos micro:bits ! Qui sera le dernier survivant ? 🎮💥

Le champ de bataille :

Ton navire : LED reconnaissable à sa lumière plus faible.

Ton missile : la LED la plus brillante

Déplace ton missile penche à droite/gauche

En avant / en arrière

Bouton A : fige le tir

Bouton B : Lance le missile

Touché

Programme en mode bloc

sous vittascience : https://fr.vittascience.com/microbit

Un exemple de programmation pour émettre les coordonnées x, y du missile et les recevoir :

Pour tester si le bouton B est relâché :

Pour gérer le roulis (droite/gauche) :

Pour gérer le tangage (avant/arrière) :

Pour gérer l’affichage de la position du missile :

Pour gérer l’affichage aléatoire du navire :

Puis dans Répéter indéfiniment :

Si touché :

Pour figer la cible avec le bouton A, avec une variable emettre :

  • emettre = 0 : réglage de la cible
  • emettre = 1 : cible figée

Le bouton A fige la position du tir :

Programme en python

Librairie à importer :

from microbit import *
import radio
import random
import math
import music

Pour configurer la radio :

radio.on()
radio.config(channel = 83, power = 6, length = 32, group=5)

Fonction pour émettre les coordonnées pour correspondre au programme en mode bloc :

def radio_sendValue(name, value):
    radio.send("&&&" + "int:" + "[" + name + ";" + str(value) + "]&&&")

Fonction pour recevoir les coordonnées pour correspondre au programme en mode bloc :

def radio_receiveValue():
    data = radio.receive()

    if data:
        print("receive", data)
        parseData = data[8:-4].split(';')
        return parseData[0], int(parseData[1])
    else:
        return None, None

Pour afficher une image de LEDs :

led_image = Image('00000:00000:00000:00000:00000')
display.show(led_image)

Affichage d’une LED :

 display.set_pixel(x, y, 9)
 display.set_pixel(x_cible, y_cible, 4)

pour générer un nombre aléatoire :

x_cible = random.randint(0, 4)
y_cible = random.randint(0, 4)

Affichage d’une croix :

display.show(Image.NO)

Affichage signe envoyé :

display.show(Image.YES)

Gestion des boutons A et B :

if button_a.is_pressed():
    while not (not button_a.is_pressed()):
        pass

Gestion de l’accéléromètre :

if (
   math.atan2(
       accelerometer.get_x(),
       math.sqrt(accelerometer.get_y()**2 + accelerometer.get_z()**2)
       ) * 180.0 / math.pi > 30
   ):
   x = 4

if (
   math.atan2(
       accelerometer.get_y(), -accelerometer.get_z()) *
       180.0 / math.pi > 30
   ):
   y = 4

Lancement de la musique :

music.play(music.JUMP_DOWN, loop=False)
Catégories
MBOT

Organisation pour notre participation 2025 à Robocup junior

Introduction

Dans le cadre de notre participation à la RoboCup Junior, notre association a organisé la conception et la programmation de robots adaptés pour la compétition. Ce rapport détaille notre organisation, les rôles de chacun, et les étapes de notre travail pour préparer la compétition.

Présentation des Équipes

Notre association présente 7 équipes composées d’enfants âgés de 8 à 16 ans. Les équipes sont organisées en fonction de l’âge et des compétences des participants :

  • Les plus jeunes (8-14 ans) travaillent sur une base de robot MBOT avec une programmation en mode block. Les moins expérimentés optent pour RESCUE LINE ENTRY, les plus expérimentés pour RESCUE LINE.
  • L’équipe des plus grands (14-16 ans) choisissent de réaliser leur propre robot en utilisant le langage Python pour la RESCUE LINE.

Répartition des Tâches

Travail des Plus Jeunes

Les moins expérimentés se sont concentrés sur la programmation en mode block, ce qui leur a permis de comprendre les bases de la programmation et de la robotique. Ils ont travaillé sur des tâches simples mais essentielles, comme le déplacement du robot, la détection de couleurs et le suivi de ligne. Ils sont utilisés différents robots au plus simple jusqu’au MBOT :

Un robot avec deux capteurs de suivi de ligne :

Puis un robot avec cinq capteurs de suivi de ligne

Travail des plus expérimentés

Les plus expérimentés ont pris en charge la compréhension des problématiques techniques et l’élaboration de solutions pour la conception des robots. Ils ont travaillé sur des aspects plus complexes, comme la gestion du capteur de ligne, l’équilibrage du robot et l’optimisation globale des performances du robot en fonction des exigences du parcours pour la compétition de la Robocup junior.

Collaboration et Tests

Travail en Commun entre les différentes équipes

Bien que les plus grands aient été principalement responsables de la conception technique, un travail en commun a été essentiel. Les solutions techniques élaborées par les plus grands ont été testées par tous les membres des équipes. Cela a permis de valider les solutions et de faire des choix éclairés sur les meilleures options à adopter.

Tests et Validation

Nous avons organisé des sessions de tests régulières où chaque équipe pouvait tester les solutions proposées. Les retours des plus jeunes ont été précieux pour ajuster et améliorer les solutions techniques. Cette collaboration a permis de s’assurer que les robots étaient performants et prêts pour la compétition.

Catégories
MBOT

MBOT V2 Prise en main

Le dispositif CyberPi

  • Écran couleur, offrant des interfaces utilisateur conviviales pour l’interaction homme-machine
  • Système CyberOS, vous permettant d’exécuter les programmes prédéfinis, de définir la langue du système et de mettre à jour le système via le joystick et les boutons intégrés
  • Un port Micro USB (Type-C) pour la connexion aux PC pour l’alimentation et la communication
  • Un port de module électronique pour connecter des modules électroniques
  • Un port de carte d’extension pour la connexion aux cartes d’extension
  • Plusieurs capteurs intégrés, tels qu’un capteur de lumière et un gyroscope, qui fournissent plusieurs types de sortie de données

Capteur RVB pour le suivi de la ligne noire

Plage de détection : 5 à 15 mm de l’objet à détecter :

Double pression : lorsque vous appuyez deux fois sur le bouton, le capteur quad RVB commence à mémoriser les valeurs des couleurs de l’arrière-plan (le blanc) et de la ligne noire pour le suivi de ligne. Pour effectuer cette opération, placez les capteurs de lumière sur le parcours avec une ligne noire et appuyez deux fois sur le bouton. Lorsque vous voyez les LED clignoter rapidement, faites glisser les capteurs RVB d’un côté à l’autre au-dessus de la ligne noire sur le fond blanc du parcours pendant environ 2,5 secondes. Les valeurs des paramètres obtenues sont automatiquement stockées.

Si l’apprentissage échoue, les LED clignotent lentement et vous devez recommencer l’apprentissage.

Capteur ultrasons

Le capteur à ultrasons 2 peut être utilisé pour détecter la distance entre un obstacle et celui-ci. L’émetteur de gauche transmet les ondes ultrasonores et le récepteur de droite reçoit les ondes ultrasonores réfléchies.
Les êtres humains peuvent entendre des sons de 20 à 20 000 Hz. Les ondes sonores dont les fréquences sont supérieures à 20 000 Hz sont appelées ondes ultrasonores.
Les ondes sonores sont réfléchies par les obstacles rencontrés et sont reçues par le récepteur du capteur à ultrasons. En fonction du temps écoulé entre l’émission et la réception, les distances entre le capteur à ultrasons et les obstacles peuvent être
calculées.

Distance avec un obstacle :

Gestion des deux moteurs encodeurs

Un moteur électrique encodeur est un moteur équipé d’un dispositif appelé encodeur.
L’encodeur est un capteur qui mesure la position angulaire ou la vitesse de rotation du moteur. Il fournit des informations précises sur la position du moteur, ce qui est essentiel pour contrôler avec précision le mouvement du robot.

  • EM1 : correspond au moteur gauche
  • EM2 : correspond au moteur droit (attention il est monté à l’envers, pour le faire avancer mettre un nombre négatif)

Catégories
MBOT

Adhérence et équilibrage du robot

Rapport Technique : Adaptation du Robot MBOT 2 pour la RoboCup

Introduction

Dans le cadre de notre participation à la RoboCup, nous avons adapté le robot MBOT 2 pour améliorer ses performances, notamment pour le passage des pentes et son équilibrage. Ce rapport détaille les modifications apportées, les défis rencontrés et les solutions mises en place pour atteindre nos objectifs.

Objectifs du Projet

  • Améliorer l’adhérence du robot pour le passage des pentes.
  • Optimiser l’équilibrage du robot pour une meilleure stabilité.
  • Assurer une performance optimale lors de la compétition.

Modifications Apportées

Changement des Roues

Nous avons opté pour des roues avec une bande de caoutchouc afin que le robot adhère mieux au sol, surtout lors du passage des pentes. Ces roues offrent une meilleure traction et permettent au robot de monter et descendre les pentes sans glisser.

Équilibrage du Robot

Pour améliorer l’équilibrage du robot, nous avons inversé la coque du robot afin de placer la pile plus au centre. Cette modification a permis de répartir le poids de manière plus uniforme et d’améliorer la stabilité globale du robot.

Ajout d’un Caisson avec Poids

Nous avons imaginé un caisson sous le robot, à l’avant, pour ajouter un poids. Après plusieurs essais, nous avons trouvé qu’un gros écrou était la solution idéale. Ce poids supplémentaire aide à maintenir l’avant du robot au sol, ce qui est crucial pour le passage des pentes.

Tests et Validation

Nous avons effectué plusieurs tests pour valider nos modifications. Les résultats ont montré que le robot MBOT 2 est maintenant capable de monter et descendre les pentes avec une meilleure adhérence et une stabilité accrue.

Catégories
MBOT

Adaptateur rotule

  • Rapport Technique : Conception d’un Adaptateur pour la roue bidirectionnelle

Introduction

Dans le cadre de notre projet, nous avons conçu un adaptateur pour le robot MBOT 2 afin d’améliorer sa capacité à suivre une ligne noire et à franchir des obstacles. Ce rapport détaille les étapes de conception, les défis rencontrés et les solutions mises en place pour atteindre nos objectifs.

Objectifs du Projet

  • Permettre au robot MBOT 2 de suivre une ligne noire de manière précise.
  • Assurer le franchissement des obstacles.
  • Améliorer la stabilité et la maniabilité du robot.

Conception de l’Adaptateur

Remplacement de la Rotule par une Roue Bidirectionnelle

Le robot MBOT 2 dispose de base d’une rotule lui permettant de tourner. Cependant, cette rotule ne permet pas au robot de passer les obstacles. Nous avons donc choisi de remplacer la rotule par une roue bidirectionnelle. L’avantage de cette roue est qu’elle permet de tourner dans toutes les directions comme la rotule de base, tout en permettant le franchissement des obstacles.

Première version : deux roues bidirectionnelles

Nous avons conçu une première version avec deux roues bidirectionnelles. Cependant, après réflexion, nous avons réalisé que cette configuration n’était pas optimale.

Deuxième version : une roue bidirectionnelle centrale

Nous avons donc réalisé une deuxième version avec une seule roue bidirectionnelle au centre du robot. Cette version a donné de bons résultats et nous a permis d’économiser une roue par robot. Dans cette version, nous avons installé la roue avec l’axe vers l’avant du robot, la roue contre l’avant du robot.

Troisième version : roue parallèle au robot

Nous avons remarqué que dans la disposition précédente, la roue bidirectionnelle avait tendance à rouler sur le côté sur les obstacles et dans le bas de la pente. Nous avons donc réalisé une troisième version avec la roue parallèle au robot. Cette configuration a amélioré la stabilité et la maniabilité du robot.

Intégration de capteurs

Traqueur de Ligne

Nous avons intégré un traqueur de ligne pour améliorer le suivi de ligne du robot, notamment pour qu’il puisse se redresser sur les lignes droites afin que le robot soit bien parallèle à la ligne noire pour une meilleur prise en compte des carrés verts.

Capteur ultrasons

Un capteur ultrasons a été ajouté pour la détection des obstacles, permettant au robot de les éviter.

Dispositif de détection de bande Conductrice

Nous avons également intégré un dispositif pour détecter la bande conductrice d’électricité afin d’avoir la connaissance de l’arrivée dans la zone de survie.

Conception des Adaptateurs avec Blender

Utilisation de Blender

Le travail de conception des adaptateurs du MBOT 2 a été réalisé avec l’outil Blender. Juliette, qui avait déjà une maîtrise de cet outil, a pris en charge le dessin des pièces suite à nos échanges, constatations et idées.

Organisation du Travail

Afin de bien organiser son travail, Juliette a mis en place sous Blender des collections en fonction des configurations de nos adaptateurs. Cette organisation a permis de structurer les différentes pièces et de faciliter les modifications et les ajustements.

Modification des Unités

Juliette a également modifié les unités de base dans Blender pour se mettre à l’unité millimètre. Cette modification a été essentielle pour assurer la précision des dimensions des pièces conçues.

Tests et Validation

Nous avons effectué plusieurs tests pour valider nos modifications. Les résultats ont montré que les adaptateurs conçus avec Blender permettent au robot MBOT 2 de mieux répondre aux exigences de la compétition. Les pièces dessinées par Juliette ont été fabriquées et intégrées au robot, améliorant ainsi ses performances.

Catégories
MBOT

Adaptateur RGB

  • Conception d’un Adaptateur RGB pour le Robot MBOT 2

Introduction

Dans le cadre de notre projet, nous avons conçu un adaptateur RGB pour le robot MBOT 2 afin d’améliorer sa capacité à suivre une ligne noire dans diverses conditions, notamment sur des pentes et des angles droits. Ce rapport détaille les étapes de conception, les défis rencontrés et les solutions mises en place pour atteindre nos objectifs.

Objectifs du Projet

  • Permettre au robot MBOT 2 de suivre une ligne noire de manière précise.
  • Assurer une bonne mesure de la ligne noire même sur des pentes.
  • Adapter la position du capteur RGB pour qu’il soit au plus proche du sol sans dépasser les roues.

Conception de l’Adaptateur RGB

Positionnement du Capteur

Pour que le robot suive correctement la ligne noire, notamment sur des angles droits, nous avons dû rapprocher le capteur RGB des roues. Nous avons déterminé une distance optimale entre l’axe des roues et la position du capteur RGB. Cette distance permet au capteur de détecter la ligne noire avec précision.

Réglage de la Distance

Dans la conception de l’adaptateur, nous avons prévu une fente qui permet de régler cette distance. Cette fente offre une flexibilité nécessaire pour ajuster la position du capteur en fonction des conditions spécifiques de la piste.

Adaptation pour les Pentes

Nous avons constaté que dans les pentes, le capteur RGB s’éloignait du sol, ce qui rendait la mesure de la ligne noire imprécise. Pour résoudre ce problème, nous avons conçu l’adaptateur de manière à ce que le capteur RGB soit positionné sous les roues, au plus proche du sol. Nous avons également donné un angle au capteur pour qu’il reste proche du sol lors de l’attaque de la pente.

Contraintes Mécaniques

Le capteur RGB ne doit pas dépasser les roues pour éviter les obstacles. Nous avons donc veillé à ce que l’adaptateur respecte cette contrainte tout en permettant une mesure précise de la ligne noire.

Tests et Validation

Nous avons produit plusieurs adaptateurs à l’imprimante 3D et effectué de nombreux tests pour valider la conception de l’adaptateur. Les résultats ont montré que l’adaptateur permet au robot de suivre la ligne noire avec précision, même sur des pentes et des angles droits. Le réglage de la distance via la fente s’est avéré très utile pour optimiser la performance du capteur dans différentes conditions.

Conclusion

La conception de cet adaptateur RGB pour le robot MBOT 2 a été un défi technique intéressant. Grâce à notre travail, le robot peut maintenant suivre une ligne noire de manière précise dans diverses conditions. Nous avons compris l’importance de l’ajustement et de l’adaptation dans la conception des adaptateurs avec l’impression 3D pour répondre aux exigences de la compétition.

Le robot à l’horizontale, le capteur RGB mesure correctement la ligne noire.

Lorsque le robot attaque une pente, le capteur RGB s’éloigne de la ligne noire. Si la distance est trop importante entre le capteur RGB et le sol, la mesure devient imprécise et fausse.

Avec l’adaptateur que nous avons conçu, le capteur RGB est sous les roues pour une distance optimum entre les capteurs et l’axe des roues pour un suivi des angles droits de la ligne noire et pour une mesure optimum lors du passage des pentes.

La fente permet un réglage fin de l’adaptateur sur le MBOT2 et l’inclinaison permet au capteur RGB d’être au plus près du sol lors de la montée de la pente.