Il y a au moins 4 ou 5 autres projets sur Instructables.com concernant la modification ou le contrôle du bras robotique OWI. L'objectif de ce projet est résumé dans ces points.

1. Mobilité - Ce projet installe le bras sur un véhicule à chenilles pour permettre à la mobilité d’augmenter l’utilisation du bras.

2. Sans fil - le bras est contrôlé sans fil avec Bluetooth.

3. Contrôle - avec la combinaison de la manette Wii et du nunchuck, nous avons des entrées de contrôle de mouvement, une manette de jeu, des boutons directionnels et de nombreux boutons-poussoirs avec lesquels travailler. La mise en œuvre du nunchuck dans ce projet permet à l'opérateur de manipuler tous les joints du bras en saisissant le nunchuck d'une main et en le déplaçant de manière intuitive afin de placer facilement le bras dans la position souhaitée. Certaines des articulations ont un contrôle proportionnel pour plus de précision.

Nous allons utiliser le Raspberry Pi pour contrôler ce robot. Nous allons le programmer avec le langage de programmation Python en utilisant la bibliothèque CWiiD et la bibliothèque Bluetooth pour le contrôleur Wii.

Voici quelques vidéos Youtube montrant le robot en fonctionnement. Mon objectif pour ce projet était de pouvoir contrôler le bras robotique avec précision et d’utiliser des mouvements de la main qui semblent naturels et qui soient étroitement liés au mouvement du bras robotique.

Provisions:

Étape 1: Pièces

Pièces nécessaires pour ce projet

1. Bord du bras robotisé OWI - il s’agit du bras robotisé en kit.

2. Kit de châssis de véhicule à chenilles Tamiya

3. Tamiya 70168 Double boîte de vitesses L / R Independ 4 vitesses

4. Module de carte contrôleur contrôleur d’entraînement moteur L298N double pont en H - Quantité 4 -

5. Ordinateur Raspberry Pi

6. Batterie de 5 volts / 1 ampère conçue pour charger un téléphone portable - Quantité 2 -

7. Télécommande Wii et contrôleur Nunchuck

J'ai acheté tout cela chez Amazon, à l'exception du contrôleur Wii que j'avais déjà

Étape 2: Commençons

J'ai commencé par assembler le kit de piste. Ceci est une image du kit de piste totalement mis en place. Assemblé de la sorte, la piste n’ira que vers l’avant ou l’arrière. Nous voulons pouvoir tourner à droite et à gauche également. Pour ce faire, vous devez acheter la boîte de vitesses double Tamiya 70168.

Étape 3: Assemblez la double boîte de vitesses

Vous devez assembler la double boîte de vitesses à partir d'un kit. Il peut être assemblé pour l’une des quatre vitesses. Je l'ai fait pour courir à la vitesse la plus lente qui a aussi le plus de couple.

Étape 4: Monter la boîte de vitesses double sur le kit de chenille

Les trous de montage de la double boîte de vitesses sont trop larges pour la base standard, de sorte que j'ai collé un bloc suffisamment large pour les vis mais pas assez large pour nuire aux rails. Vous pouvez maintenant monter la boîte de vitesses.

Étape 5: Ajouter des supports et une base

Le véhicule à chenilles est conçu pour rouler sur des pistes plus courtes au sol. Pour des raisons de stabilité, je l’ai retourné pour avoir la longue section de piste sur le sol. J'ai collé sur deux supports de montage, puis j'ai fabriqué une base sur laquelle le bras peut s'asseoir et également de la place pour les quatre contrôleurs d'entraînement de moteur à pont double L298N.

Étape 6: Conception de la base

La base permet au bras robotique de s'asseoir au milieu avec de la place pour une batterie et des pilotes de moteur des deux côtés.

Étape 7: Construire le bras robotique

Nous devons maintenant assembler le bras robotique du kit. Il y a déjà beaucoup d'instructables sur la construction du bras. Je suggère que vous recherchiez l'un d'eux si vous voulez plus d'aide. J'ai trouvé que le kit était de haute qualité et que tout allait bien ensemble.

Remarque importante: continuez et construisez le kit à l'exception de l'unité de contrôle câblée et du boîtier de batterie. Nous n'utiliserons ni l'un ni l'autre dans ce projet.

Étape 8: Faites de la place pour la batterie principale

Ensuite, j'ai utilisé mon outil Dremel pour retirer du plastique dans le boîtier de la batterie afin que mon groupe de batteries y rentre parfaitement. J'ai fini par couper complètement pour laisser de la place à la prise USB (non illustrée sur cette photo.

Étape 9: Câbler les pilotes de moteur

Il y a 5 moteurs dans le bras robotique et 2 moteurs dans l'entraînement par voie. Le L298N Dual H Bridge peut gérer 2 moteurs chacun, nous avons donc besoin de 4 d'entre eux avec un seul emplacement en réserve. Chaque pont double H est fourni avec 2 pilotes de moteur sur la même carte. Ils travaillent de manière totalement indépendante et sont regroupés sur le même tableau dans un but strictement pratique.

Voici comment brancher le pilote du moteur

Utilisons les moteurs de base et de rotation (verticaux) comme exemple

Couper le connecteur du groupe de fils 2 du moteur à la base. Un fil va à Out1 et l'autre à Out2.

Couper le connecteur du groupe de fils 2 du moteur de mouvement de base. Un fil va à Out3 et l'autre à Out4.

Regardez la photo et trouvez "Connecter le moteur ici" (2 places)

Connectez la batterie du moteur à l'endroit indiqué Terre et + 5V

Une note ici: Tous les moteurs de ce projet ont été conçus à l'origine pour fonctionner à 3 volts. Je les exécute à 5 volts. Avec la plupart de ces petits moteurs à courant continu, cela ne pose pas de problème, sauf si vous augmentez trop la tension.

Nous couvrirons l'entrée de contrôle à l'étape suivante

Étape 10: Contrôle des pilotes de moteur

Le contrôle du moteur de rotation de la base sera effectué par In1 et In2

Le contrôle du moteur de mouvement de base sera effectué par In3 et In4

Donc, dans cet exemple, les broches 10, 11, 12 et 13 seraient câblées comme suit

De plus, chaque ensemble (In1 et In2) - (In3 et In4) possède une broche d'activation.Le pilote est livré avec la broche de validation reliée à +5 volts, ce qui la permet à tout moment. Dans ce projet, nous souhaitons contrôler certains moteurs avec une modulation par impulsions, ce qui permet de contrôler la vitesse du moteur en activant et désactivant très rapidement la broche d'activation. Notez comment les broches 31 et 33 sont câblées aux broches d'activation respectives.

Liste de toutes les broches GPIO du code python

LeftMotorTrackA = 3

LeftMotorTrackB = 5

RightMotorTrackA = 7

RightMotorTrackB = 8

MotorBaseRotateA = 10 ----- In1

MotorBaseRotateB = 11 ----- In2

MotorBaseMotionA = 12 ----- In3

MotorBaseMotionB = 13 ----- In4

MotorElbowA = 15

MotorElbowB = 16

MoteurWristA = 18

MotorWristB = 19

MotorGripperA = 21

MotorGripperB = 22

BaseMotionEnable = 31 ----- Activer la broche pour In3-In4

BaseRotateEnable = 33 ----- Activer la broche pour In1-in2

GripperEnable = 35

Étape 11: Câbler le reste des pilotes de moteur

Selon les deux dernières étapes, vous devriez pouvoir répéter le processus sur les 3 pilotes restants. J'ai placé les pilotes dans le boîtier en fonction de la longueur des fils venant du bras. Je n'avais pas besoin d'étendre les fils au-delà de leur longueur d'origine. Vous devrez connecter la batterie pour tous les pilotes de moteur ensemble. Vous devrez également connecter la terre du Raspberry Pi à la broche de terre de l’un des pilotes. Leurs terrains sont tous reliés entre eux par le biais des connexions électriques, de sorte qu'ils fonctionneront tous. La photo 2 pas en arrière montre la connexion de masse au Raspberry Pi.

Étape 12: Configuration du Raspberry Pi

Nous allons utiliser le Raspberry Pi pour contrôler ce robot. Nous allons le programmer avec le langage de programmation Python en utilisant la bibliothèque CWiiD et la bibliothèque Bluetooth pour le contrôleur Wii.

Nous devons d'abord installer Bluetooth

Commencez par brancher votre clé USB Bluetooth sur votre Pi et redémarrez-le.

Vous pouvez vérifier le dongle en tapant lsusb

pi @ raspberrypi ~ $ lsusb

Bus 001 Dispositif 002: ID 0424: 9514 Standard Microsystems Corp.

Périphérique de bus 001: ID 1d6b: 0002 concentrateur racine Linux Foundation 2.0

Bus 001 Appareil 003: ID 0424: ec00 Standard Microsystems Corp.

Dispositif 004 ​​du bus 001: ID 0a12: 0001 Dongle Bluetooth Cambridge Silicon Radio, Ltd (mode HCI)

Pour vous assurer que Bluetooth est installé, exécutez la procédure suivante:

sudo apt-get update

sudo apt-get install bluetooth

installer une bibliothèque Python appelée CWiiD

Pour obtenir des informations de la Wiimote via Bluetooth, nous devons installer une bibliothèque Python appelée CWiiD, c’est comme un "pilote" si vous le souhaitez. Pour l'installer, c'est très simple, il suffit de taper:

sudo apt-get install python-cwiid

Étape 13: À propos du code

Ok pour le code:

1. Nous allons d’abord assigner toutes les broches GPIO qui contrôleront les pilotes du moteur.

2. Ensuite, créez des fonctions pour tous les mouvements possibles du bras et de la voie.

3. Recherchez le contrôleur Wii et connectez-vous à celui-ci.

4. Configurez la modulation de largeur d'impulsion (PWM) pour la rotation de base, le mouvement de base et le préhenseur. Cela nous permet de ralentir les moteurs pour une sensation précise en modifiant le cycle de service de l'impulsion.

Voici un très bon article sur PWM

raspi.tv/2013/rpi-gpio-0-5-2a-now-has-software-pwm-how-to-use-it

5. Le reste du code est une grosse boucle à la recherche des entrées de la manette Wii et de Nunchuck

Pour en savoir plus sur la programmation Wii, voici un tableau explicatif qui montre l'utilisation de chaque bouton de la Wii que j'ai utilisé à titre de référence.

www.instructables.com/id/Raspberry-P-and-Wiimote-controlled-Robot-Arm/step5/The-Code/

importation cwiid

temps d'importation

importation os

importer RPi.GPIO en tant que GPIO

à partir de l'heure d'importation sommeil

GPIO.cleanup ()

#assigner les broches GPIO

LeftMotorTrackA = 3

LeftMotorTrackB = 5

RightMotorTrackA = 7

RightMotorTrackB = 8

MotorBaseRotateA = 10

MotorBaseRotateB = 11

MotorBaseMotionA = 12

MotorBaseMotionB = 13

MotorElbowA = 15

MotorElbowB = 16

MoteurWristA = 18

MotorWristB = 19

MotorGripperA = 21

MotorGripperB = 22

BaseMotionEnable = 31

BaseRotateEnable = 33

GripperEnable = 35

GripperLED = 40

#set broches GPIO à la sortie

GPIO.setmode (GPIO.BOARD)

GPIO.setup (LeftMotorTrackA, GPIO.OUT)

GPIO.setup (LeftMotorTrackB, GPIO.OUT)

GPIO.setup (RightMotorTrackA, GPIO.OUT)

GPIO.setup (RightMotorTrackB, GPIO.OUT)

GPIO.setup (MotorBaseRotateA, GPIO.OUT)

GPIO.setup (MotorBaseRotateB, GPIO.OUT)

GPIO.setup (MotorBaseMotionA, GPIO.OUT)

GPIO.setup (MotorBaseMotionB, GPIO.OUT)

GPIO.setup (MotorElbowA, GPIO.OUT)

GPIO.setup (MotorElbowB, GPIO.OUT)

GPIO.setup (MotorWristA, GPIO.OUT)

GPIO.setup (MotorWristB, GPIO.OUT)

GPIO.setup (MotorGripperA, GPIO.OUT)

GPIO.setup (MotorGripperB, GPIO.OUT)

GPIO.setup (BaseMotionEnable, GPIO.OUT)

GPIO.setup (BaseRotateEnable, GPIO.OUT)

GPIO.setup (GripperEnable, GPIO.OUT)

GPIO.setup (GripperLED, GPIO.OUT)

def TrackDriveForward ():

GPIO.output (LeftMotorTrackA, GPIO.HIGH)

GPIO.output (LeftMotorTrackB, GPIO.LOW)

GPIO.output (RightMotorTrackA, GPIO.HIGH)

GPIO.output (RightMotorTrackB, GPIO.LOW)

def TrackDriveReverse ():

GPIO.output (LeftMotorTrackA, GPIO.LOW)

GPIO.output (LeftMotorTrackB, GPIO.HIGH)

GPIO.output (RightMotorTrackA, GPIO.LOW)

GPIO.output (RightMotorTrackB, GPIO.HIGH)

def TrackDriveLeft ():

GPIO.output (LeftMotorTrackA, GPIO.LOW)

GPIO.output (LeftMotorTrackB, GPIO.HIGH)

GPIO.output (RightMotorTrackA, GPIO.HIGH)

GPIO.output (RightMotorTrackB, GPIO.LOW)

def TrackDriveRight ():

GPIO.output (LeftMotorTrackA, GPIO.HIGH)

GPIO.output (LeftMotorTrackB, GPIO.LOW)

GPIO.output (RightMotorTrackA, GPIO.LOW)

GPIO.output (RightMotorTrackB, GPIO.HIGH)

def TrackDriveStop ():

GPIO.output (LeftMotorTrackA, GPIO.LOW)

GPIO.output (LeftMotorTrackB, GPIO.LOW)

GPIO.output (RightMotorTrackA, GPIO.LOW)

GPIO.output (RightMotorTrackB, GPIO.LOW)

def BaseRotateRight ():

GPIO.output (MotorBaseRotateA, GPIO.HIGH)

GPIO.output (MotorBaseRotateB, GPIO.LOW)

def BaseRotateLeft ():

GPIO.output (MotorBaseRotateA, GPIO.LOW)

GPIO.output (MotorBaseRotateB, GPIO.HIGH)

def BaseMotionUp ():

GPIO.output (MotorBaseMotionA, GPIO.HIGH)

GPIO.output (MotorBaseMotionB, GPIO.LOW)

def BaseMotionDown ():

GPIO.output (MotorBaseMotionA, GPIO.LOW)

GPIO.output (MotorBaseMotionB, GPIO.HIGH)

def BaseXStop ():

GPIO.output (MotorBaseRotateA, GPIO.LOW)

GPIO.output (MotorBaseRotateB, GPIO.LOW)

def BaseYStop ():

GPIO.output (MotorBaseMotionA, GPIO.LOW)

GPIO.output (MotorBaseMotionB, GPIO.LOW)

def ElbowUp ():

GPIO.output (MotorElbowA, GPIO.LOW)

GPIO.output (MotorElbowB, GPIO.HIGH)

def ElbowDown ():

GPIO.output (MotorElbowA, GPIO.HIGH)

GPIO.output (MotorElbowB, GPIO.LOW)

def ElbowStop ():

GPIO.output (MotorElbowA, GPIO.LOW)

GPIO.output (MotorElbowB, GPIO.LOW)

def WristDown ():

GPIO.output (MotorWristA, GPIO.HIGH)

GPIO.output (MotorWristB, GPIO.LOW)

def WristUp ():

GPIO.output (MotorWristA, GPIO.LOW)

GPIO.output (MotorWristB, GPIO.HIGH)

def WristStop ():

GPIO.output (MotorWristA, GPIO.LOW)

GPIO.output (MotorWristB, GPIO.LOW)

def GripperOpen ():

GPIO.output (MotorGripperA, GPIO.HIGH)

GPIO.output (MotorGripperB, GPIO.LOW)

def GripperClose ():

GPIO.output (MotorGripperA, GPIO.LOW)

GPIO.output (MotorGripperB, GPIO.HIGH)

def GripperStop ():

GPIO.output (MotorGripperA, GPIO.LOW)

GPIO.output (MotorGripperB, GPIO.LOW)

#set modulation de largeur d'impulsion à 50 hz

BMpw = GPIO.PWM (BaseMotionEnable, 50)

BRpw = GPIO.PWM (BaseRotateEnable, 50)

GRpw = GPIO.PWM (GripperEnable, 50)

Base de démarrage à 50%

BMpw.start (50)

BRpw.start (50)

#fixez la pince à 40% pour qu'elle fonctionne plus lentement

GRpw.start (40)

#Faire découvrir le dongle Bluetooth

os.system ("sudo hciconfig hci0 piscan")

# connexion à la Wiimote. Cela permet plusieurs tentatives

# comme les premiers échouent souvent.

print 'Appuyez sur 1 + 2 sur votre Wiimote maintenant …'

wm = None

i = 2

bien que non wm:

essayer:

wm = cwiid.Wiimote ()

sauf RuntimeError:

si (i> 10):

print "Abandonner la connexion"

quitter()

Pause

print "Erreur lors de l'ouverture de la connexion Wi-Fi"

print "tentative" + str (i)

i + = 1

#Pause un peu

temps.sommeil (0.2)

# Ici, dites à l'utilisateur

print "Succès - nous sommes connectés!"

# configurer les entrées que nous recherchons

wm.rpt_mode = cwiid.RPT_BTN | cwiid.RPT_ACC | cwiid.RPT_EXT

#Attends un peu

temps.sommeil (0.5)

#Fait un grondement

wm.rumble = True

temps.sommeil (0.5)

wm.rumble = False

#Maintenant, commencez à vérifier les appuis sur les boutons

print "Prêt à recevoir des appuis de bouton et une entrée d'accéléromètre"

#Loop pour toujours détecter

essayer:

alors que vrai:

# Configurez un objet bouton pour vérifier

boutons = wm.state 'boutons'

si les boutons & cwiid.BTN_UP:

imprimer "bouton haut"

TrackDriveForward ()

boutons elif & cwiid.BTN_DOWN:

imprimer "bouton BAS"

TrackDriveReverse ()

boutons elif & cwiid.BTN_LEFT:

imprimer "bouton GAUCHE"

TrackDriveLeft ()

boutons elif & cwiid.BTN_RIGHT:

print "bouton DROIT"

TrackDriveRight ()

autre:

print "track stop"

TrackDriveStop ()

si (boutons & cwiid.BTN_MINUS):

print 'Moins pressé'

PinceClose ()

elif (boutons et cwiid.BTN_PLUS):

imprimer 'Plus pressé'

GripperOpen ()

elif (boutons et cwiid.BTN_1):

print '1 pressé'

elif (boutons et cwiid.BTN_2):

imprimer '2 pressé'

autre:

GripperStop ()

print "sinon arrêter"

#le voyant est utilisé directement hors tension GPIO. Tous les moteurs utilisent un pilote

si (boutons & cwiid.BTN_A):

GPIO.output (GripperLED, GPIO.HIGH)

imprimer 'un pressé'

autre:

GPIO.output (GripperLED, GPIO.LOW)

# arrêter tout en appuyant sur le bouton B - arrêt d'urgence

si (boutons & cwiid.BTN_B):

print 'b pressé'

GPIO.cleanup ()

#Ici on s'occupe du nunchuk, du joystick et des boutons

tandis que (1):

si wm.state.has_key ('nunchuk'):

essayer:

#Voici les données pour le bâton de nunchuk:

Axe #X: LeftMax = 25, Middle = 125, RightMax = 225

NunchukStickX = (wm.state 'nunchuk' 'stick' cwiid.X)

Axe Y: DownMax = 30, Milieu = 125, UpMax = 225

NunchukStickY = (wm.state 'nunchuk' 'stick' cwiid.Y)

#Les variables 'NunchukStickX' et 'NunchukStickY' stockent maintenant les valeurs du stick

imprimer NunchukStickX

imprimer NunchukStickY

si (NunchukStickY> 160):

imprimer "coude en bas"

#fine régler les mouvements des bras en changeant le cycle de travail

BMpw.ChangeDutyCycle (20)

ElbowDown ()

elif (NunchukStickY <110):

imprimer "coude levé"

BMpw.ChangeDutyCycle (40)

ElbowUp ()

autre:

ElbowStop ()

imprimer "ystop"

#Ici on s'occupe de toutes nos données pour l'accéléromètre

#Le nunchuk a un accéléromètre qui enregistre de manière similaire à la Wiimote, mais la plage de nombres est différente

#La plage X est: 70 si incliné de 90 degrés à gauche et 175 si incliné de 90 degrés à droite

#La plage Y est la suivante: 70 si incliné à 90 degrés vers le bas (les boutons pointant vers le bas) et 175 si incliné à 90 degrés vers le haut (boutons $

numchkX = wm.state 'nunchuk' 'acc' cwiid.X

numchkY = wm.state 'nunchuk' 'acc' cwiid.Y

#faire le mouvement du bras proportionnel au nunchuck en changeant PWM

si (nombre> 160):

si (numchkY <170):

BMpw.ChangeDutyCycle (20)

BaseMotionDown ()

autre:

BMpw.ChangeDutyCycle (40)

BaseMotionDown ()

elif (nombre <120):

si (nombre> 110):

BMpw.ChangeDutyCycle (60)

BaseMotionUp ()

autre:

BMpw.ChangeDutyCycle (95)

BaseMotionUp ()

autre:

BaseYStop ()

si (numchkX <100):

si (numchkX> 80):

BRpw.ChangeDutyCycle (20)

BaseRotateLeft ()

autre:

BRpw.ChangeDutyCycle (40)

BaseRotateLeft ()

elif (numchkX> 140):

si (numchkX <160):

BRpw.ChangeDutyCycle (20)

BaseRotateRight ()

autre:

BRpw.ChangeDutyCycle (45)

BaseRotateRight ()

autre:

BaseXStop ()

print str (numchkX) + '' + str (numchkY)

ChukBtn = wm.state 'nunchuk' 'buttons'

si (ChukBtn == 1):

Poignet ()

elif (ChukBtn == 2):

Poignet ()

autre:

WristStop ()

Pause

sauf KeyError:

print 'Aucun nunchuk détecté.'

autre:

si (compteur == 10000):

print 'Aucun nunchuk détecté.'

Compteur = Compteur / 10000

Pause

Compteur = Compteur + 1

Pause

#Chill for a bit

temps.sommeil (0.3)

sauf KeyboardInterrupt:

passer

imprimer "Goodby"

Étape 14: Démarrer automatiquement le programme Python

Lorsque je souhaite utiliser le robot, je souhaite allumer la batterie du moteur, allumer la batterie de l'ordinateur et être prêt à connecter la Wii. Il vous suffit d'appuyer sur les boutons 1 et 2 de la Wii et d'attendre que celle-ci gronde, puis vous savez qu'elle est connectée. Voici comment le configurer comme ça:

Commencez par ouvrir le fichier /etc/rc.local

sudo nano /etc/rc.local

Maintenant que c'est ouvert, j'insère la ligne suivante juste avant #Imprimer l'adresse IP

python /home/pi/pythoncode/robottrackarm.py &

Cela lancera Python et mon programme au démarrage

#! / bin / sh -e

#

# rc.local

#

# Ce script est exécuté à la fin de chaque niveau d'exécution multi-utilisateur.

# Assurez-vous que le script "quittera 0" en cas de succès ou autre

# valeur sur erreur.

#

# Pour activer ou désactiver ce script, il suffit de modifier l'exécution

# morceaux.

#

# Par défaut, ce script ne fait rien.

python /home/pi/pythoncode/robottrackarm.py &

# Imprimer l'adresse IP

_IP = $ (nom d'hôte -I) || vrai

if "$ _IP"; puis

printf "Mon adresse IP est% s n" "$ _IP"

Fi

sortie 0

Étape 15: Voici le paquet final

Cela termine ce projet. Voici le look final avec tout branché et les capots supérieurs dessus. J'espère avoir inspiré quelqu'un pour l'essayer. Faites-moi savoir ce que vous pensez du projet.