Entrez dans l’univers de la robotique avec Grab-it – Partie 1

Le bras robotisé à 5 axes « Grab-it » du fabricant JOY-IT permet aux bricoleurs amateurs, aux élèves et aux étudiants de s’initier facilement à l’électronique, à la mécanique et à la programmation. Le bras robotisé « Grab-it » peut être utilisé avec tous les ordinateurs monocarte (SBC) et microcontrôleurs courants, ainsi qu’avec la plateforme de votre choix, ce qui permet de se lancer rapidement. Pour le projet suivant, nous nous sommes limités au Raspberry Pi 4, associé à un Moto Pi, ainsi qu’à un Arduino Uno avec un Motorino. Grâce aux servomoteurs à couple élevé et au préhenseur puissant, le brais robotisé peut saisir et déplacer sans difficulté de petites charges d’un point A à un point B.

Montage, calibrage des moteurs et remarques

• Bras robotisé en aluminium, numéro de série : Robot02
• Raspberry Pi modèle 4, 2 Go, bloc d’alimentation inclus
• Moto Pi pour commander les servomoteurs
• Bloc d’alimentation de 20 W pour alimenter la carte de commande
• Carte mémoire avec Noobs, outils et instructions
• Câble HDMI de 1,5 m (HDMI micro > HDMI) pour la lecture 4K

Le bras robotisé fonctionne avec les moteurs suivants :

• Couple : 21,5 kg·cm à 7,4 V
• Tension : 5 à 7,4 V CC
• Angle mécanique de 360°, plage de travail de 180°
• Engrenages métalliques
• Commande par modulation de largeur d’impulsion (PWM)

Autres accessoires recommandés :

• Arduino UNO R3
• JOY-IT Motorino : commande moteur pour Arduino
• Câble HDMI
• Câble Raspberry Pi USB-C vers USB avec interrupteur
• Jeu de câbles pour cartes enfichables

Le bras robotisé en aluminium est actionné par six moteurs commandables séparément. Il est également monté sur un plateau tournant à 360° sur roulements. La plaque de base en acrylique de 4,5 mm d’épaisseur est équipée de trous de fixation pour tous les SBC et microcontrôleurs courants. Des entretoises permettent de fixer facilement la plaque de base, par exemple sur un établi ou un bureau.

Montage étape par étape et calibrage des moteurs

Pour le montage, vous aurez besoin des éléments suivants :

• Matériel de montage : tournevis cruciforme, pince plate, clé Allen (fournie), éventuellement une pince à épiler
• ordinateur portable et Raspberry Pi avec Moto Pi ou Arduino avec Motorino pour calibrer les moteurs
• Instructions de montage de JOY-IT

Réalisation du montage :

• Retirez le film protecteur de la plaque de base.
• Fixez l’un des leviers servo ronds à l’aide de quatre vis sur l’une des plaques rondes.
• Ensuite, montez un servomoteur sur la plaque ronde. Pour ce faire, placez la plaque sur le servomoteur et fixez-la à l’aide de quatre vis et d’écrous. Assurez-vous que la roue dentée du servomoteur est parfaitement alignée au centre.
• La quatrième étape consiste à monter le palier. Insérez d’abord les quatre longues vis dans la première bague, puis placez le palier. Insérez ensuite la deuxième bague et vissez-la à l’aide des quatre longues douilles en laiton.
• Insérez ensuite la tôle ronde de l’étape 2 avec le support du servomoteur sur la tête du servomoteur de l’étape 3, puis fixez-la au centre à l’aide d’une vis.
• Placez la plaque avec le servomoteur sur le palier et vissez-la à l’aide de quatre écrous (image 03).

• Fixez ensuite un roulement dans la première cornière.
• Vissez ensuite la cornière à la tôle ronde.
• Vissez ensuite cette dernière au roulement.
• Vous pouvez maintenant la monter sur la plaque de base et la fixer sur la face inférieure à l’aide de douilles en laiton. Attention ! Veillez à ce que le filetage ne dépasse pas des douilles et fixez au préalable les écrous sur les tiges filetées. Ceux-ci sont ensuite serrés sur la face supérieure. Les entretoises en plastique peuvent maintenant être fixées sur la face inférieure (image 04).
• Enfoncez les leviers de servomoteur sur les servomoteurs restants (image 05).

ATTENTION : les servomoteurs doivent être calibrés dans leur position de base avant le montage ! (Instructions ci-dessous).

• Vissez ensuite les deux tôles en U à l’aide de quatre vis et écrous chacune.
• Insérez ensuite le servomoteur et fixez-le avec quatre vis et écrous. Reliez enfin le bras du servomoteur au bras du robot avec quatre vis (image 06).

• Vissez une autre tôle en U avec une équerre, puis fixez-la à un support de servomoteur.
• Fixez ensuite un roulement à l’emplacement habituel.
• Insérez ensuite un servomoteur et fixez-le comme d’habitude à l’aide de quatre vis et écrous. Fixez-le ensuite au bras du robot à l’aide de quatre vis.
• Superposez deux supports de servomoteur et reliez-les à l’aide de vis et d’écrous.
• Installez le palier et le servomoteur comme d’habitude.
• Fixez-le au bras du robot à l’aide de quatre vis, puis fixez le dernier servomoteur au grappin comme d’habitude (voir l’image 07).

• Il ne reste plus qu’à assembler le préhenseur du robot. Pour ce faire, vissez quatre doigts du préhenseur en alternance avec des entretoises courtes en laiton. Pour terminer, utilisez des écrous d’un côté et des vis de l’autre.
• Fixez ensuite quatre entretoises en laiton au servomoteur. Veillez à placer une rondelle au-dessus et en-dessous de chaque entretoise. Insérez ensuite une vis dans la tôle, puis vissez-la au servomoteur. Deux rondelles sont ensuite placées sur la vis.
• Un roulement est ensuite inséré dans le préhenseur.
• Le premier doigt est fixé au servomoteur à l’aide d’une rondelle et d’un écrou.
• Pour le deuxième doigt, fixez un levier de servomoteur à l’aide de quatre vis.
• Fixez ensuite le deuxième doigt et vissez-la.
• Fixez ensuite un levier de servomoteur à l’équerre, puis fixez-le au bras de préhension à l’aide d’une vis.
• Pour finir, vissez le préhenseur à l’équerre (image 8).

Calibrage des moteurs

Avant de les utiliser et de les installer, les servomoteurs doivent être calibrés dans leur position initiale. C’est la seule façon d’exploiter toute la zone de travail du bras du robot et d’obtenir la position de départ correcte du Grab-it. Pour un réglage optimal, la valeur de positionnement des moteurs doit être de 1 500. Seul le moteur du préhenseur est programmé sur la valeur 1 600. Pour le calibrage, le moteur correspondant est connecté à l’unité de commande, par exemple le MotoPi en liaison avec le Raspberry Pi, ou le Motorino avec l’Arduino.

• Le Raspberry Pi avec la carte MotoPi est connecté à son alimentation électrique (ou, en alternative, l’Arduino avec Motorino).
• L’alimentation externe de 5 V pour l’alimentation électrique des servomoteurs est ensuite connectée au MotoPi.
• Le « script d’étalonnage » est lancé comme décrit ci-dessous. (Attention, respecter les indentations dans Python)
• Les étapes suivantes doivent maintenant être effectuées pour chaque servomoteur à installer : connecter le servomoteur à sa position respective sur le MotoPi (image 09).

La bibliothèque modifiée est copiée sur le Raspberry Pi et les commandes suivantes sont exécutées :

sudo apt-get install python3-pip
sudo apt install python3-smbus

Dans le terminal, naviguez jusqu’au dossier, puis installez la bibliothèque à l’aide de la commande suivante :

sudo python3 setup.py install

Le nouveau fichier est alors créé à l’aide de la commande suivante :

sudo nano calibrate.py

Le code suivant est alors écrit dans le fichier :

from __future__ import division 
import time 
import Adafruit_PCA9685 
# Initialisierung mit alternativer Adresse 
pwm = Adafruit_PCA9685.PCA9685(address=0x41) 
# Einstellen der Minimal- und Maximal-Pulslaengen 
servo_min = 150 # Minimale Pulslaenge 
servo_max = 600 # Maximale Pulslaenge 
# Hilfsfunktion 
def set_servo_pulse(channel, pulse): 
pulse_length = 1000000 
pulse_length /= 50 
print('{0}us per period'.format(pulse_length)) 
pulse_length /= 4096 
print('{0}us per bit'.format(pulse_length)) 
pulse *= 1000 
print(pulse_length) 
pulse /= pulse_length 
print(pulse) 
pulse = round(pulse) 
print(pulse) 
pulse = int(pulse) 
print (pulse) 
pwm.set_pwm(channel, 0, pulse) 
# Frequenz auf 50Hz setzen 
pwm.set_pwm_freq(50) 
# Bewege Servo 0-4 auf Position 1500 
# Bewege Servo 5 auf Position 1600 
set_servo_pulse(0,1.5) 
time.sleep(1.5) 
set_servo_pulse(1,1.5) 
time.sleep(1.5) 
set_servo_pulse(2,1.5) 
time.sleep(1.5) 
set_servo_pulse(3,1.5) 
time.sleep(1.5) 
set_servo_pulse(4,1.5) 
time.sleep(1.5) 
set_servo_pulse(5,1.6) 
time.sleep(1.5)

Enregistrez le fichier avec CTRL+O, puis quittez l’éditeur avec CTRL+X. Lancez maintenant le calibrage avec la commande suivante :

sudo python3 calibrate.py

Effectuez les premiers mouvements avec le Raspberry Pi et le Moto Pi

Installation du système d’exploitation Raspberry Pi

• Installer le système d’exploitation Raspberry Pi
  • installer le système d’exploitation souhaité, par exemple OS Lite 64 bits (image 11)
  • copier le nom et le mot de passe du réseau Wi-Fi sur la carte SD
  • copier le fichier de routage sur la carte SD
  • insérer la carte SD dans le Pi
  • démarrer le Pi et exécuter le système d’exploitation (démarre automatiquement)

• copier la bibliothèque sur le Raspberry Pi
• créer un fichier
• saisir le code de calibrage (comme décrit ci-dessus)

Modulation de largeur d’impulsion (PWM)

La PWM est une méthode qui consiste à modifier la largeur d’une impulsion électrique afin de contrôler numériquement des valeurs analogiques, comme la position, la vitesse ou la luminosité. Un Arduino ne peut émettre que 0 V (LOW) ou 5 V (HIGH) ; il n’est pas possible d’émettre des valeurs intermédiaires réelles. Grâce à la PWM, on simule des valeurs intermédiaires en passant très rapidement de HIGH à LOW.

Les servomoteurs installés dans le Grab-it ne comprennent pas les signaux analogiques, mais des signaux PWM spéciaux à 50 Hz (toutes les 20 ms). Concrètement, une impulsion de commande est envoyée toutes les 20 ms, et la longueur de l’impulsion indique la position. Le servomoteur mesure la durée pendant laquelle l’impulsion est haute, et non sa fréquence. Il existe plusieurs façons de générer un signal PWM. Les variantes RPi.GPIO et pigpio conviennent au Grab-it.

Variante 1 :

import RPi.GPIO as GPIO
import time

# Pin-Nummer (z. B. GPIO 17)
servo_pin = 17

GPIO.setmode(GPIO.BCM)
GPIO.setup(servo_pin, GPIO.OUT)

# PWM mit 50 Hz (für Servos)
pwm = GPIO.PWM(servo_pin, 50)
pwm.start(0)

def set_angle(angle):
    # Umrechnen von Winkel (0–180) auf Duty-Cycle (2–12 %)
    duty = 2 + (angle / 18)
    GPIO.output(servo_pin, True)
    pwm.ChangeDutyCycle(duty)
    time.sleep(0.5)
    GPIO.output(servo_pin, False)
    pwm.ChangeDutyCycle(0)

# Beispielbewegung
try:
    set_angle(0)
    set_angle(90)
    set_angle(180)
finally:
    pwm.stop()
    GPIO.cleanup()

Variante 2 :

import pigpio
import time

pi = pigpio.pi()
servo_pin = 17

# Servo auf 90° (1.5 ms)
pi.set_servo_pulsewidth(servo_pin, 1500)
time.sleep(1)

# Servo auf 0°
pi.set_servo_pulsewidth(servo_pin, 1000)
time.sleep(1)

# Servo auf 180°
pi.set_servo_pulsewidth(servo_pin, 2000)
time.sleep(1)

# Servo stoppen
pi.set_servo_pulsewidth(servo_pin, 0)
pi.stop()

Exemple de code : mouvements simples, préhension, rotation

Une fois que tous les moteurs sont calibrés dans la bonne position, que le bras robotisé est monté et que tous les composants sont correctement connectés, il est possible d’effectuer les premiers mouvements du bras. Pour ce faire, il suffit d’exécuter le code approprié sur le Raspberry Pi, à condition que la bibliothèque ait été copiée lors du calibrage. Un code permettant d’effectuer ces premiers mouvements peut être téléchargé ici (image 12).

Cette commande permet d’exécuter le code et le bras se déplace :

sudo python3 RoboterArm.py 

Voici un extrait du code :

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import division
import time
import RPi.GPIO as GPIO
import Adafruit_PCA9685
import spidev
import time
import sys
import signal
import logging

# Standardadresse: (0x40).
#pwm = Adafruit_PCA9685.PCA9685()

# Initalisierung mit alternativer Adresse
pwm = Adafruit_PCA9685.PCA9685(address=0x41)

# Einstellen der Minimal- und Maximal-Pulslängen
servo_min = 150  # Minimale Pulslänge
servo_max = 600  # Maximale Pulslänge

# Hilfsfunktion
def set_servo_pulse(channel, pulse):
    pulse_length = 1000000
    pulse_length /= 50
    pulse_length /= 4096
    pulse *= 1000
    pulse /= pulse_length
    pulse = round(pulse)
    pulse = int(pulse)
    pwm.set_pwm(channel, 0, pulse)

Commande alternative avec Arduino

Connexion et câblage avec le Motorino

Le JOY-IT Motorino Shield est une carte enfichable pour l’Arduino Uno. Elle constitue une alternative à la combinaison Raspberry Pi et Moto Pi et comprend :

• 6 connexions pour servomoteurs (pour votre bras robotisé)
• une alimentation électrique supplémentaire pour les servos (jusqu’à 12 A)
• connexions pour boutons, LED et capteurs

Procédure :

• brancher le shield
• brancher les servomoteurs
• brancher l’alimentation électrique
• connecter l’Arduino au PC
• en option : connecter les connexions pour LED et boutons

Exemple de code avec la bibliothèque Servo.h :

Avec le code suivant, nous pouvons faire effectuer les premiers mouvements au Grab-it, comme dans l'exemple de code pour le Pi.

#include <Servo.h>  // Standardbibliothek zur Ansteuerung von Servomotoren

// === Servo-Objekte für die 6 Motoren des Grab-it Roboterarms ===
Servo baseServo;       // Dreht den Arm (Basis)
Servo shoulderServo;   // Schultergelenk
Servo elbowServo;      // Ellbogengelenk
Servo wristServo;      // Handgelenk
Servo clawServo;       // Greifklaue
Servo wristRotateServo;// Drehung des Handgelenks

// === Pinbelegung (Motorino Shield oder direkt am Arduino) ===
// Passen Sie die Pins ggf. an Ihre Verkabelung an
const int BASE_PIN        = 2;
const int SHOULDER_PIN    = 3;
const int ELBOW_PIN       = 4;
const int WRIST_PIN       = 5;
const int CLAW_PIN        = 6;
const int WRIST_ROT_PIN   = 7;

// === Anfangspositionen (in Grad) ===
int basePos        = 90;
int shoulderPos    = 90;
int elbowPos       = 90;
int wristPos       = 90;
int clawPos        = 90;
int wristRotatePos = 90;

// === Setup ===
void setup() {
  // Servos mit Pins verbinden
  baseServo.attach(BASE_PIN);
  shoulderServo.attach(SHOULDER_PIN);
  elbowServo.attach(ELBOW_PIN);
  wristServo.attach(WRIST_PIN);
  clawServo.attach(CLAW_PIN);
  wristRotateServo.attach(WRIST_ROT_PIN);

  // Servos auf Ausgangsposition fahren
  baseServo.write(basePos);
  shoulderServo.write(shoulderPos);
  elbowServo.write(elbowPos);
  wristServo.write(wristPos);
  clawServo.write(clawPos);
  wristRotateServo.write(wristRotatePos);

  delay(1000); // kurze Pause zum Stabilisieren
}

// === Hauptprogramm ===
void loop() {
  // Beispielbewegung 1: Objekt greifen und bewegen
  moveClaw(60);     // Klaue öffnen
  delay(500);
  
  moveBase(120);    // Arm nach rechts drehen
  delay(500);
  
  moveShoulder(70); // Arm absenken
  delay(500);
  
  moveClaw(100);    // Klaue schließen (Objekt greifen)
  delay(1000);
  
  moveShoulder(90); // Arm anheben
  delay(500);
  
  moveBase(60);     // Arm nach links drehen
  delay(500);
  
  moveClaw(60);     // Klaue öffnen (Objekt ablegen)
  delay(1000);
}

// === Hilfsfunktionen ===
void moveBase(int pos) {
  pos = constrain(pos, 0, 180);
  baseServo.write(pos);
}

void moveShoulder(int pos) {
  pos = constrain(pos, 0, 180);
  shoulderServo.write(pos);
}

void moveElbow(int pos) {
  pos = constrain(pos, 0, 180);
  elbowServo.write(pos);
}

void moveWrist(int pos) {
  pos = constrain(pos, 0, 180);
  wristServo.write(pos);
}

void moveWristRotate(int pos) {
  pos = constrain(pos, 0, 180);
  wristRotateServo.write(pos);
}

void moveClaw(int pos) {
  pos = constrain(pos, 50, 120); // Begrenzung, um Überlast zu vermeiden
  clawServo.write(pos);
}
Potentiometersteuerung oder einfache Buttonsteuerung
Servo über Potentiometer steuern:
#include <Servo.h>

Servo servo1;

const int potPin = A0;   // Potentiometer an analogem Pin A0
const int servoPin = 2;  // Servo-Signal an D2

void setup() {
  servo1.attach(servoPin);
}

void loop() {
  int sensorValue = analogRead(potPin);           // 0–1023 lesen
  int angle = map(sensorValue, 0, 1023, 0, 180);  // in 0–180° umrechnen
  servo1.write(angle);                            // Servo auf Winkel setzen
  delay(10);
}

Servos über 2 Buttons steuern:
#include <Servo.h>

Servo servo1;

const int buttonLeft = 7;
const int buttonRight = 8;
const int servoPin = 2;

int angle = 90; // Startposition

void setup() {
  servo1.attach(servoPin);
  servo1.write(angle);

  pinMode(buttonLeft, INPUT_PULLUP);
  pinMode(buttonRight, INPUT_PULLUP);
}

void loop() {
  // Button gedrückt = LOW (wegen INPUT_PULLUP)
  if (digitalRead(buttonLeft) == LOW) {
    angle--; // Winkel verringern
    angle = constrain(angle, 0, 180);
    servo1.write(angle);
    delay(100);
  }

  if (digitalRead(buttonRight) == LOW) {
    angle++; // Winkel erhöhen
    angle = constrain(angle, 0, 180);
    servo1.write(angle);
    delay(100);
  }
}

Commande simple à l’aide de potentiomètres ou de boutons

Les potentiomètres et les boutons sont un excellent moyen de commander le bras robotisé de manière simple et précise:

Buttons

Chaque bouton déclenche une action unique:

• déplacer le servomoteur vers la gauche ou la droite
• ouvrir / fermer le préhenseur
• enregistrer / rappel d’une position
• lancer une routine automatique

Potentiomètres

Un potentiomètre fournit une valeur analogique qui est convertie proportionnellement en un angle de servo :

• Potentiomètre à gauche → petit angle de servo
• Potentiomètre à droite → grand angle de servo

Les potentiomètres permettent de contrôler manuellement chaque axe avec précision.

Pour la commande par boutons, vous aurez besoin de deux à six boutons, selon le nombre d’axes à commander, ainsi que de résistances pull-down, de câbles et d’une maquette pour connecter les boutons.

Pour les potentiomètres, vous pouvez utiliser des potentiomètres rotatifs simples, un par axe servo, par exemple. Comme le Raspberry Pi ne peut pas traiter les entrées analogiques, vous devez également utiliser un convertisseur ADC pour convertir les signaux d’entrée en conséquence.

Un extrait de code pour une commande simple par boutons pourrait se présenter comme suit :

import RPi.GPIO as GPIO
import time
from adafruit_pca9685 import PCA9685
import busio, board

# PCA9685 Setup
i2c = busio.I2C(board.SCL, board.SDA)
pca = PCA9685(i2c)
pca.frequency = 50

def set_servo(channel, angle):
    pulse = int(150 + (angle / 180) * 450)
    pca.channels[channel].duty_cycle = pulse

GPIO.setmode(GPIO.BCM)

BTN_LEFT = 17
BTN_RIGHT = 27

GPIO.setup(BTN_LEFT, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(BTN_RIGHT, GPIO.IN, pull_up_down=GPIO.PUD_UP)

angle = 90

while True:
    if GPIO.input(BTN_LEFT) == 0:
        angle = max(0, angle - 5)
        set_servo(0, angle)
        time.sleep(0.1)

    if GPIO.input(BTN_RIGHT) == 0:
        angle = min(180, angle + 5)
        set_servo(0, angle)
        time.sleep(0.1)

Différences par rapport à la variante Pi

• L’Arduino fonctionne directement avec un matériel PWM : il génère lui-même les signaux de commande du servomoteur et réagit en temps réel, ce qui est idéal pour effectuer des mouvements précis.
• Le Raspberry Pi est un ordinateur à part entière qui génère les signaux PWM via un logiciel ou un module externe, comme le PCA9685.
• L’Arduino fonctionne de manière autonome, sans système d’exploitation, et le code démarre immédiatement à la mise sous tension.
• Le Raspberry Pi permet d’exécuter des programmes plus complexes en Python, de contrôler des caméras, etc., mais nécessite une gestion précise du timing.
• Le Motorino Shield s’adapte directement à l’Arduino, tandis que le Raspberry Pi est généralement connecté aux servomoteurs via I²C (PCA9685).

De la construction au contrôle : la prochaine étape

Le bras robotisé Grab-it vous permet de réaliser vos premiers projets avec le Raspberry Pi ou l’Arduino. La commande et l’utilisation des servomoteurs, qui font l’objet d’une attention particulière dans ce projet, sont particulièrement intéressantes. Après avoir fait effectuer les premiers mouvements au Grab-it dans la première partie, nous présentons dans la deuxième partie de cet article des idées de projets passionnants et nous programmons une interface Web pour commander le bras robotisé depuis un PC ou un smartphone.

Images : reichelt elektronik, JOY-IT, Adobe Stock

Deuxième partie de l’article :
Exemples et extensions : Entrez dans l’univers de la robotique avec Grab-it – Partie 2