Grâce au bras robotisé « Grab-it » de JOY-IT, les bricoleurs amateurs, les élèves et les étudiants peuvent acquérir une première expérience de la programmation en Python et réaliser des projets simples avec le Raspberry Pi ou un Arduino.
La première partie de cet article traitait de la construction du bras robotisé, du calibrage des servomoteurs, ainsi que des premiers mouvements du bras et de leur programmation. Dans cette deuxième partie, les développeurs trouveront de brefs exemples et des idées d’extensions leur permettant d’exploiter davantage le Grab-it.
Projets créatifs et applications
Matériel nécessaire :
- Kit de bras robotisé Grab-it de JOY-IT, y compris les accessoires tels que Raspberry Pi et Moto Pi.
Autres accessoires recommandés :
- Arduino UNO R3
- JOY-IT Motorino : commande de moteur pour Arduino
- Câble HDMI
- Câble Raspberry Pi USB-C vers USB avec interrupteur
- Jeu de câbles pour cartes enfichables.
Projet créatif : empilement de composants
Dans ce premier projet créatif, le bras robotisé est programmé pour saisir des blocs de construction imprimés en 3D et les empiler dans une boîte prévue à cet effet (image 1).
Pour ce faire, il faut d’abord suivre les étapes indiquées dans la partie 1 :
- Installer le Raspberry Pi avec Moto Pi (ou, à défaut, avec Arduino Uno et Motorino) et le connecter au bras robotisé.
- Installer le système d’exploitation Raspberry Pi.
- Installer les bibliothèques et calibrer les servomoteurs.
Le programme d’empilement des composants peut ensuite être exécuté sur le Raspberry Pi.
Voici un extrait du code qui permet à Grab-it d’exécuter des mouvements via le Raspberry Pi en liaison avec le Moto Pi :
"programs": {
"Wuerfel stapeln": [
{
"M1": 1.5,
"M2": 1.35,
"M3": 1.486,
"M4": 1.45,
"M5": 1.5,
"M6": 1.1
},
{
"M1": 2.126,
"M2": 1.425,
"M3": 0.942,
"M4": 1.39,
"M5": 2.1,
"M6": 1.1
},
{
"M1": 2.123,
"M2": 0.774,
"M3": 0.942,
"M4": 1.122,
"M5": 2.1,
"M6": 1.1
},
{
"M1": 2.112,
"M2": 0.786,
"M3": 1.05,
"M4": 1.082,
"M5": 2.1,
"M6": 1.1
},
{
"M1": 2.112,
"M2": 0.663,
"M3": 1.05,
"M4": 1.082,
"M5": 2.1,
"M6": 1.1
},
{
"M1": 2.112,
"M2": 0.663,
"M3": 1.05,
"M4": 1.082,
"M5": 2.1,
"M6": 0.872
},
{
"M1": 2.112,
"M2": 0.876,
"M3": 1.05,
"M4": 1.082,
"M5": 2.1,
"M6": 0.872
},
{
"M1": 2.112,
"M2": 1.524,
"M3": 0.71,
"M4": 1.082,
"M5": 1.125,
"M6": 0.872
},
Grab-it passe à l’IoT
Commande via une interface web et une application
L’étape suivante consiste à préparer le Grab-it pour l’IoT. À l’instar d’une maison intelligente, le bras robotisé doit pouvoir être commandé via une interface web. Pour ce faire, le célèbre serveur Web Flask est utilisé comme interface entre l’interface HTML et la commande du moteur. L’interface web permet ensuite de commander facilement le bras robotisé.
Outre la commande via PC, il est également possible de commander le bras robotisé via une application et un smartphone. Associé au Raspberry Pi, le Grab-it peut ainsi être facilement commandé via un smartphone. L’idée est la suivante :
- Le Raspberry Pi commande le Grab-it via le servomoteur PCA9685. Ce composant permet de commander jusqu’à 16 servomoteurs simultanément avec précision à partir du Raspberry Pi, et ce, à l’aide de seulement deux câbles, car il génère lui-même les signaux PWM nécessaires, soulageant ainsi le Pi.
- Un serveur Web Flask fonctionne sur le Raspberry Pi. Il s’agit d’un framework web léger pour Python qui permet de créer rapidement des applications web ou des interfaces simples permettant de contrôler des appareils tels que le Grab-it via un navigateur.
- Le bras peut ainsi être facilement commandé via une interface dans le navigateur (ordinateur ou application smartphone).
Pour cela, le système doit d’abord être préparé pour l’installation. Ensuite, la commande servo est mise en œuvre en Python, puis le serveur Web Flask et l’interface HTML sont créés.
1. Préparer le système :
- Activer I2C :
sudo raspbi-config
sudo reboot- Installer les paquets de pilotes pour SMBus :
sudo apt update;
sudo apt install python3-flask python3-smbus i2c-tools- Vérifier si le PCA9685 est détecté :
sudo i2cdetect -y 12. Préparer la commande servo :
- Créez un fichier nommé
pca9685_control.py.- Ce fichier encapsule la commande du Grab-it (voir extrait de code) :
# pca9685_control.py
import smbus
import time
import math
PCA9685_ADDR = 0x40
bus = smbus.SMBus(1)
MODE1 = 0x00
PRESCALE = 0xFE
LED0_ON_L = 0x06
def set_pwm_freq(freq_hz=50):
prescaleval = 25000000.0 / (4096.0 * freq_hz) - 1.0
prescale = int(math.floor(prescaleval + 0.5))
oldmode = bus.read_byte_data(PCA9685_ADDR, MODE1)
newmode = (oldmode & 0x7F) | 0x10
bus.write_byte_data(PCA9685_ADDR, MODE1, newmode)
bus.write_byte_data(PCA9685_ADDR, PRESCALE, prescale)
bus.write_byte_data(PCA9685_ADDR, MODE1, oldmode)
time.sleep(0.005)
bus.write_byte_data(PCA9685_ADDR, MODE1, oldmode | 0xA1)
def set_pwm(channel, on, off):
bus.write_byte_data(PCA9685_ADDR, LED0_ON_L + 4 * channel, on & 0xFF)
bus.write_byte_data(PCA9685_ADDR, LED0_ON_L + 4 * channel + 1, on >> 8)
bus.write_byte_data(PCA9685_ADDR, LED0_ON_L + 4 * channel + 2, off & 0xFF)
bus.write_byte_data(PCA9685_ADDR, LED0_ON_L + 4 * channel + 3, off >> 8)
def angle_to_pwm(angle):
pulse_min = 150 # ggf. an deine Servos anpassen
pulse_max = 600
return int(pulse_min + (pulse_max - pulse_min) * angle / 180)
def set_servo_angle(channel, angle):
angle = max(0, min(180, angle))
pwm_val = angle_to_pwm(angle)
set_pwm(channel, 0, pwm_val)
# Beispiel-Kanäle (anpassen falls nötig)
BASE = 0
SHOULDER = 1
ELBOW = 2
WRIST = 3
GRIPPER = 4
# Startposition (optional)
def home_position():
set_servo_angle(BASE, 90)
set_servo_angle(SHOULDER, 90)
set_servo_angle(ELBOW, 90)
set_servo_angle(WRIST, 90)
set_servo_angle(GRIPPER, 60)
# Beim Import einmal Frequenz setzen
set_pwm_freq(50)
3. Créer le serveur web Flask :
- Le fichier
app.pyest créé pour permettre la commande de Flask (image 3).
4. Créer une interface web HTML :
- Créez un dossier templates à côté du fichier
app.pyet y placez le fichier index.html (figure 4).
5. Un JavaScript est également enregistré :
- Le JavaScript active les fonctions des boutons (figure 5).
Le serveur peut maintenant être démarré et contrôlé depuis le navigateur. Pour ce faire, il suffit d’exécuter la commande suivante dans le dossier contenant le fichier app.py :
python3 app.pyVous pouvez ensuite ouvrir le navigateur sur un PC ou un smartphone connecté au même réseau Wi-Fi pour accéder au Raspberry Pi :
par exemple : http://DEINE_PI_IP:5000c'est-à-dire :http://192.168.0.23:5000Le Grab-it peut alors être facilement et confortablement commandé comme un appareil domotique via l’interface Web sur un PC ou un smartphone (image 6).
Vous pouvez également choisir de démarrer l’application Flask manuellement ou automatiquement. Cette option n’est pas spécifiée dans le code, mais dans le système Raspberry Pi.
1. Démarrage manuel :
cd /home/pi/grab-it-web
Python3 app.py2. Démarrage automatique :
app.py Ausführungsrechte geben: sudo chmod +x app.py
Servicedatei erstellen: sudo nano /etc/systemd/system/roboterarm.service
Inhalt:
[Unit]
Description=Roboterarm Steuerung App
After=network.target
[Service]
ExecStart=/usr/bin/python3 /home/pi/V3/app.py
WorkingDirectory=/home/pi/V3/
User=root
# Setze Restart auf 'always', damit der Service bei einem Absturz neu startet
Restart=always
# Optional: Setze eine kleine Verzögerung vor dem ersten Neustart
RestartSec=5
[Install]
WantedBy=multi-user.target
===================
daemon-Dienst neu laden: sudo systemctl daemon-reload
Autostart aktivieren: sudo systemctl enable roboterarm.service
Commande via un contrôleur
Outre la commande depuis un smartphone ou un PC, il est également possible de commander le bras robotisé à l’aide d’un joystick ou d’un contrôleur. Un contrôleur Xbox a été connecté au Raspberry Pi via une interface USB. Le serveur Flask déjà installé permet de commander facilement le bras avec le contrôleur.
- Pour installer le contrôleur Xbox, utilisez la commande suivante :
sudo apt install python3-evdev. - Installez ensuite le script Python:
XboxController.py(image 7).
Le Grab-it peut ainsi être déplacé facilement et rapidement dans n’importe quelle position.
Un extrait de code montre comment procéder pour activer la manette Xbox :
import threading
import time
from evdev import InputDevice, categorize, ecodes, list_devices
# Robotersteuerung importieren - NEUE IMPORT-METHODE
try:
import roboter_arm_steuerung as RAS
ARM_CONTROLLER = RAS.ARM_CONTROLLER
MIN_MAX_PULSES = RAS.MIN_MAX_PULSES
except ImportError:
print("FEHLER: roboter_arm_steuerung.py konnte nicht importiert werden.")
ARM_CONTROLLER = None
# -------------------------------------------------
# Controller Maps & Einstellungen
# -------------------------------------------------
SENSITIVITY_FACTOR = 0.005 # Pulsänderung pro Tick für M1-M4
SENSITIVITY_FACTOR_M5_M6 = 0.025 # NEU: Pulsänderung pro Tick für M5-M6 (5x schneller)
DEADZONE = 0.15 # Stick Drift Filter
# Achsen
ABS_X_LEFT = ecodes.ABS_X
ABS_Y_LEFT = ecodes.ABS_Y
ABS_X_RIGHT = ecodes.ABS_RX
ABS_Y_RIGHT = ecodes.ABS_RY
ABS_LT_TRIGGER = ecodes.ABS_Z
ABS_RT_TRIGGER = ecodes.ABS_RZ
# Buttons
BTN_START = ecodes.BTN_START
BTN_BACK = ecodes.BTN_SELECT
BTN_X = ecodes.BTN_SOUTH
BTN_Y = ecodes.BTN_NORTH
BTN_LB = ecodes.BTN_TL # NEU
BTN_RB = ecodes.BTN_TR # NEU
# Motor-Mapping
AXIS_MAPPING = {
ABS_X_LEFT: 'Motor1',
ABS_Y_LEFT: 'Motor2',
ABS_Y_RIGHT: 'Motor3',
ABS_X_RIGHT: 'Motor4',
ABS_LT_TRIGGER: 'Motor6', # Greifer (Öffnen)
ABS_RT_TRIGGER: 'Motor6', # Greifer (Schließen)
}
Extensions et modifications
Si vous souhaitez aller plus loin et tirer davantage parti de votre Grab-it, vous pouvez considérablement améliorer le bras robotisé grâce à des optimisations mécaniques et logicielles ciblées.
Améliorations mécaniques pour le Grab-it de JOY-IT
Le bras robotisé peut être adapté et optimisé de manière ciblée grâce à des améliorations mécaniques simples. Les accessoires de préhension, les bras allongés et les supports de caméra, qui peuvent être fabriqués à l’aide d’une imprimante 3D, sont particulièrement efficaces.
Différents préhenseurs, telles que des pointes caoutchoutées pour les objets ronds ou des mâchoires larges pour les pièces plates, permettent d’améliorer la polyvalence et la précision de la préhension. Les segments de bras allongés élargissent le rayon d’action, mais doivent être soutenus par des servomoteurs plus stables ou par des matériaux légers, comme le carbone, afin d’éviter les vibrations.
Un support de caméra situé au-dessus de la pince permet d’utiliser la vision par intelligence artificielle ou la reconnaissance des couleurs via OpenCV. Pour plus de stabilité, il est recommandé de remplacer les connexions en plastique instables par des articulations métalliques ou des roulements à billes. Si vous souhaitez connecter une caméra au Grab-it, vous pouvez utiliser ce code pour vérifier si la caméra est correctement intégrée, puis l’utiliser pour la reconnaissance des couleurs ou des objets :
# camera_test.py
import cv2
# 0 = erste Kamera (USB-Webcam oder PiCam über /dev/video0)
cap = cv2.VideoCapture(0)
if not cap.isOpened():
print("Kamera konnte nicht geöffnet werden!")
exit()
while True:
ret, frame = cap.read()
if not ret:
print("Kein Kamerabild empfangen!")
break
# Bild anzeigen
cv2.imshow("Grab-it Kamera – Livebild", frame)
# ESC zum Beenden
if cv2.waitKey(1) == 27:
break
cap.release()
cv2.destroyAllWindows()
Le support du servomoteur peut également être renforcé ou amorti afin de réduire les vibrations. Grâce à ces modifications, le Grab-it devient plus précis, plus stable et plus polyvalent, ce qui le rend parfait pour les projets de fabrication ambitieux.
Mises à jour logicielles pour le Grab-it : plus d’intelligence grâce à OpenCV
Grâce à ces mises à jour, le bras robotisé Grab-it de JOY-IT devient nettement plus intelligent et autonome. L’intégration d’OpenCV est particulièrement efficace pour mettre en œuvre la reconnaissance des couleurs, des formes ou des objets à l’aide d’une caméra USB ou Raspberry Pi.
Grâce à des fonctions simples d’OpenCV, le robot peut analyser des données vidéo en direct, filtrer des plages de couleurs et déterminer la position d’objets. Associé à un servomoteur, il peut par exemple se déplacer automatiquement vers les objets détectés et les saisir. Des filtres simples suffisent pour la reconnaissance des couleurs, tandis que la reconnaissance des contours ou les modèles basés sur l’intelligence artificielle (IA), par exemple avec TensorFlow Lite, permettent d’obtenir des résultats plus précis.
Exemple (détection d’objets avec OpenCV) :
import cv2
cap = cv2.VideoCapture(0)
while True:
ret, frame = cap.read()
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv, (100,150,0), (140,255,255))
cv2.imshow("Erkennung", mask)
if cv2.waitKey(1) == 27:
break
cap.release()
cv2.destroyAllWindows()
Une autre mise à niveau consiste à insérer, par exemple, des profils de mouvement qui réagissent de manière flexible en fonction des données de la caméra. De plus, une API ou une interface Web Flask peut être utilisée pour prendre en charge les commandes provenant d’applications Web ou d’applications pour smartphones. Grâce à ces extensions logicielles, le Grab-it devient un système capable d’apprendre, qui exécute non seulement des tâches, mais les « perçoit » également et y réagit.
Communauté et ressources
Même s’il existe peu de projets dédiés sur GitHub, la communauté des makers autour du bras robotisé Grab-it de JOY-IT propose des ressources précieuses que vous pouvez utiliser. Vous trouverez sur GitHub une petite sélection de référentiels, par exemple des exemples d’esquisses pour l’intégration d’OpenCV ou d’interfaces Web Flask.
Il est également intéressant de consulter des plateformes telles que Thingiverse ou MyMiniFactory pour trouver des fichiers STL de pinces ou de supports de caméra personnalisés. Les forums de makers et les blogs de bricolage, comme les fils de discussion Reddit ou les Insta-Stories, proposent également d’autres expériences et conseils, par exemple pour améliorer la mécanique, régler avec précision les servomoteurs ou intégrer une caméra.
Il n’existe actuellement pas de grande communauté centrale dédiée au Grab-it, mais une recherche ciblée par mots-clés tels que « JOY-IT Grab-it » permet de trouver des projets et tutoriels individuels. Utilisez ces ressources comme point de départ, adaptez-les à votre configuration et documentez votre propre développement pour rejoindre cette communauté en pleine expansion.
Grab-it en action et perspectives
La deuxième partie de l’article est consacrée au Grab-it de JOY-IT et montre comment mettre en œuvre les premiers projets avec ce bras robotisé. De plus, le Grab-it est désormais « compatible IoT » et peut être commandé via un contrôleur, un smartphone ou un PC.
La communauté ne cesse de s’agrandir et GitHub ainsi que d’autres forums de développeurs proposent de nombreux projets, mises à jour et autres ressources permettant d’étendre continuellement les capacités du Grab-it, de le rendre compatible avec l’intelligence artificielle et de le perfectionner.
Images : Adobe Stock, reichelt elektronik
Première partie de l’article :
Configuration et bases : Entrez dans l’univers de la robotique avec Grab-it – Partie 1
