Category: MR25 Robot

Gestion de 2 cameras avec le robot MR25

Le robot MR25 est équipé d’une carte Raspberry Pi 5 disposant de deux connecteurs dédiés aux caméras. Il est donc possible d’utiliser simultanément deux caméras sur le robot.

Ce tutoriel présente les étapes nécessaires pour configurer et utiliser deux caméras avec le robot MR25, ainsi que la réalisation de captures d’images avec chacune d’elles.

Détecter les 2 cameras

Listez les cameras avec cette commande :

$ rpicam-hello --list-cameras

Vous devez voir la détection des 2 cameras :

Prendre une photo avec les 2 cameras

Voici un exemple de la prise d’une photo sur chaque cameras :

#!/usr/bin/env python3

# Import de la bibliothèque Picamera2 pour contrôler les caméras Raspberry Pi
from picamera2 import Picamera2

# Fonction permettant de mettre le programme en pause
from time import sleep

# Permet de récupérer la date et l'heure actuelles
from datetime import datetime

# Permet de gérer facilement les chemins et dossiers
from pathlib import Path


# ============================================================
# DOSSIER DE SAUVEGARDE
# ============================================================

# Création du dossier "photos" s'il n'existe pas déjà
output_dir = Path("photos")
output_dir.mkdir(exist_ok=True)


# ============================================================
# HORODATAGE
# ============================================================

# Création d'un horodatage commun aux deux photos
# Format : AAAAMMJJ_HHMMSS
# Exemple : 20260918_112530
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")


# ============================================================
# CAMÉRA 0
# ============================================================

# Création de l'objet correspondant à la caméra 0
cam0 = Picamera2(0)

# Création de la configuration pour une photo fixe
#
# Résolution utilisée :
# 4608 x 2592 pixels
#
# Cette résolution correspond à la résolution souhaitée
# pour la caméra 0.
config0 = cam0.create_still_configuration(
main={"size": (4608, 2592)}
)

# Application de la configuration à la caméra
cam0.configure(config0)

# Démarrage de la caméra
cam0.start()

# Petite attente afin de laisser la caméra s'initialiser
# et stabiliser l'image avant la capture.
sleep(2)

# Création du nom du fichier de sortie
#
# Exemple :
# photos/camera0_20260918_112530.jpg
file0 = output_dir / f"camera0_{timestamp}.jpg"

# Affichage dans le terminal du fichier qui va être créé
print(f"Capture caméra 0 : {file0}")

# Capture d'une photo et sauvegarde directement au format JPEG
cam0.capture_file(str(file0))

# Arrêt de la caméra 0
cam0.stop()

# Libération complète des ressources utilisées par la caméra 0
#
# Cette étape est particulièrement importante ici :
# elle permet de libérer les buffers mémoire DMA avant
# de configurer la deuxième caméra.
cam0.close()


# ============================================================
# CAMÉRA 1
# ============================================================

# Création de l'objet correspondant à la caméra 1
cam1 = Picamera2(1)

# Création de la configuration pour une photo fixe
#
# Résolution utilisée :
# 3280 x 2464 pixels
#
# Cette résolution correspond à la résolution souhaitée
# pour la caméra 1.
config1 = cam1.create_still_configuration(
main={"size": (3280, 2464)}
)

# Application de la configuration à la caméra
cam1.configure(config1)

# Démarrage de la caméra
cam1.start()

# Petite attente afin de laisser la caméra s'initialiser
# et stabiliser l'image avant la capture.
sleep(2)

# Création du nom du fichier de sortie
#
# Exemple :
# photos/camera1_20260918_112530.jpg
file1 = output_dir / f"camera1_{timestamp}.jpg"

# Affichage dans le terminal du fichier qui va être créé
print(f"Capture caméra 1 : {file1}")

# Capture d'une photo et sauvegarde directement au format JPEG
cam1.capture_file(str(file1))

# Arrêt de la caméra 1
cam1.stop()

# Libération complète des ressources utilisées par la caméra 1
cam1.close()


# ============================================================
# FIN DU PROGRAMME
# ============================================================

# Message indiquant que les deux captures sont terminées
print("Captures terminées.")

Fin du tuto !

Nicolas

 

 

 

Robot MR25 – Détecter le frappement de main avec le microphone

On souhaite programmer le robot MR25 afin de contrôler ces mouvements via la détection des frappements de main :

👏 =>  Le robot MR25 avance

👏👏 =>  Le robot MR25 tourne à gauche

👏👏👏 =>  Le robot MR25 tourne à droite

👏👏👏👏 =>  Le robot MR25 s’arrête

Le microphone détecte les frappements en analysant le niveau sonore.

Algorithme

Voici un exemple de programme pour contrôler le robot avec le frappement de main :

import subprocess # permet de lancer le programme arecord pour récupérer le son du microphone.
import numpy as np # permet de traiter les données audio et de calculer le RMS.
import MR25
import time

DEVICE = "hw:0,0"
RATE = 48000
CHANNELS = 1
CHUNK = 1024

THRESHOLD = 0.01 # le seuil sonore.

# Temps minimum entre deux frappes
DEBOUNCE_TIME = 0.20

# Temps maximum pour regrouper les frappes
GROUP_TIMEOUT = 0.80
# Le programme attend au maximum 0,8 seconde après la dernière frappe.

cmd = [
"arecord",
"-D", DEVICE,
"-f", "S16_LE",
"-r", str(RATE),
"-c", str(CHANNELS),
"-t", "raw",
"-"
]

process = subprocess.Popen(
cmd,
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL
)

nombre_frappes = 0
derniere_frappe = 0
dernier_signal = 0

print("Écoute du microphone...")
print("1 frappe = LED rouge")
print("3 frappes = LED verte")
print("Ctrl+C pour arrêter.\n")

try:
while True:

data = process.stdout.read(CHUNK * 2)

if len(data) != CHUNK * 2:
break

audio = np.frombuffer(data, dtype=np.int16)
audio = audio.astype(np.float32) / 32768.0

volume = np.sqrt(np.mean(audio ** 2))

maintenant = time.time()

# Affichage du volume
bar = min(50, int(volume * 50))

print(
f"\rVolume : {volume:.3f} "
f"[{'#' * bar:<50}] "
f"Frappes : {nombre_frappes}",
end="",
flush=True
)

# Détection d'une frappe
if volume > THRESHOLD:

# Évite de compter plusieurs fois la même frappe
if maintenant - derniere_frappe > DEBOUNCE_TIME:

nombre_frappes += 1
derniere_frappe = maintenant

print(f"\n>>> Frappe {nombre_frappes}")

# Si le délai entre les frappes est dépassé,
# on analyse le nombre de frappes
if (
nombre_frappes > 0
and maintenant - derniere_frappe > GROUP_TIMEOUT
):

if nombre_frappes == 1:
print(">>> 1 FRAPPE : avancer")
MR25.ledRGB("100")
MR25.forward(30)
time.sleep(0.5)
MR25.ledRGB("000")

elif nombre_frappes == 2:
print(">>> 2 FRAPPES : tourner à gauche")
MR25.ledRGB("010")
MR25.turnLeft(30)
time.sleep(0.5)
MR25.ledRGB("000")

elif nombre_frappes == 3:
print(">>> 3 FRAPPES : tourner à droite")
MR25.ledRGB("001")
MR25.turnRight(30)
time.sleep(0.5)
MR25.ledRGB("000")

elif nombre_frappes == 4:
print(">>> 4 FRAPPES : STOP")
MR25.ledRGB("111")
MR25.stop()
time.sleep(0.5)
MR25.ledRGB("000")

else:
print(f">>> {nombre_frappes} frappes : aucune action")

# Réinitialisation
nombre_frappes = 0

except KeyboardInterrupt:
print("\n\nArrêt du robot.")
MR25.stop()

finally:
process.terminate()

Fin du tuto !

Le robot éducatif MR25, tuto sur les encodeurs

Aujourd’hui, une petit tutoriel sur la lecture des encodeurs du robot MR25. Le robot MR25 est un robot basé sur une carte Raspberry Pi. Ce robot MADE IN FRANCE est disponible en boutique.

 

« MR25 est prêt à être programmé en moins de 5 minutes »

Un exemple pour lire les 2 encodeurs magnétique du robot en langage Python :

#!/usr/bin/python
import MR25
import time, sys

print("Reset encodeur : ")
MR25.encoderReset()

while True :
coderRight = MR25.encoderRight() # lecture de l'encodeur du moteur droit
coderLeft = MR25.encoderLeft() # lecture de l'encdoeur du moteur gauche
print("Encoder Right =", coderRight)
print("Encoder Left =", coderLeft)
time.sleep(2)

#End of file

Fin !

Le robot MR25 est disponible en Boutique

Le robot MR25 basé sur une carte Raspberry Pi 5 est disponible en Boutique, en TP de robotique, le plus long c’est rarement le code.

C’est le temps perdu à faire fonctionner le matériel.

Le MR-25 a été conçu pour changer ça.

  • 🎓 Sorti de la boîte, il tourne. OS préinstallé, zéro config
  • 📡 Programmable en WiFi depuis les postes étudiants
  • 🐍 Python natif — le langage que vos étudiants connaissent déjà
  • 🤖 5 capteurs ToF pour l’évitement d’obstacles, led RGB, Buzzer
  • 📖 Documentation PDF complète en français + GitHub
  • 🇫🇷 Assemblé et testé en France

Les étudiants passent leur temps à coder, pas à déboguer du matériel.

  • Compatible IUT, BTS, Licence Pro, école d’ingénieurs.
    Commandes administratives acceptées.
  • 349 € · Livraison 48h · Support en français

 

Un robot basé sur la puissance d’une Raspberry Pi 5 !

Mise à jour du robot MR25

Une mise à jour logiciel du robot MR25 pour la calibration des moteurs :

  • Mise à jour du firmware du microcontrôleur Raspberry Pico
  • Mise à jour de la librairie python
  • Mise à jour de la documentation PDF

Calibration des moteurs

Les deux moteurs du robot MR25 nécessitent une calibration. Car il n’est pas possible de garantir que la vitesse des deux moteurs du robot soit exactement identique. Ainsi, certains robots MR25 ne vont pas totalement droit.

Voir page 21 de la documentation du robot : lien

Lien github :

https://github.com/macerobotics/MR-25