Cet article explique comment créer un robot contrôlé par un capteur Kinect relié à une carte Arduino pour traduire les mouvements en actions robotiques. Il détaille les caractéristiques techniques du Kinect et propose un programme en Processing pour suivre les articulations humaines, ainsi qu'un code Arduino pour contrôler les servomoteurs. L'objectif est de permettre un contrôle en temps réel des mouvements humains via le robot.

1. Kinect Arduino Robot
letselectronic.blogspot.com /2016/03/kinect-arduino-robot.html
Bonjour, Comme il est indiqué au titre de cette article je vais aujourd'hui illustrer les étapes à suivre pour réaliser un robot,
un système manipulé en générale guidé et commandé par ce qu'on appelle Kinect.
Commençons tout d'abord par définir Kinect pour ceux qui les connaissent pas encore:
On peut ainsi jouer sur des jeux spécialement développés pour le projet,
donc sans aucune manette ni périphérique autre que son propre corps.
Cette détection de mouvements sans périphériques était déjà présente
dans l’EyeToy de Sony.Ce vidéo vous montrerez comment ça fonctionne le
kinect
Le 21 octobre 2010, Microsoft dévoile la première publicité officielle de son
nouveau périphérique, montrant à quel point la firme vise le grand public.
Le géant de l'informatique a confirmé dépenser plus de 500 millions de
dollars en marketing pour s'assurer de toucher au maximum la population.
Initialement hostile au portage du Kinect sur les PC, la société Microsoft a
finalement changé d'avis et a introduit Kinect pour Windows au 1er février
2012. Pour un prix sensiblement supérieur, cette version pour PC inclut de
nouvelles fonctionnalités (par exemple le capteur a été repensé pour
fonctionner à partir d’une distance de 50 cm. Kinect pour Windows inclut un
kit de développement afin de permettre aux développeurs de créer leurs
propres applications.
Revenons maintenant au caractéristiques principales de cette caméra si
développée :
Capteur :
Lentilles détectant la couleur et la profondeur
Micro à reconnaissance vocale
Capteur motorisé pour suivre les déplacements
Champ de vision :
Champ de vision horizontal : 57 degrés
Champ de vision vertical : 43 degrés
Marge de déplacement du capteur : ± 27 degrés
Portée du capteur : 1,2 m – 3,5 m (à partir de 50 cm pour la version Kinect for Windows)
Flux de données :
320 × 240 en couleur 16 bits à 30 images par seconde
640 × 480 en couleur 32 bits à 30 images par seconde
Audio 16 bits à 16 kHz
Système de reconnaissance physique :
Jusqu’à 6 personnes et 2 joueurs actifs (4 joueurs actifs avec le SDK 1.0)
20 articulations par squelette
Application des mouvements des joueurs sur leurs avatars Xbox Live
1/6

2. Audio :
Chat vocal Xbox Live et chat vocal dans les jeux (nécessite un compte Xbox Live Gold)
Suppression de l’écho
Reconnaissance vocale multilingue (pour les français, cette fonction est disponible depuis le 06 décembre 2011
via une MàJ de la Xbox ).
L'objectif de notre projet c'est de savoir relier ce kinect avec une prototype Electronique composée d'une carte Arduino uno
simple et 4 servomoteurs de façon savoir traiter l'information revenante de ce kinect et la traduire en mouvement instantané,
intelligent et direct.
Pour ceci on eu besoin de réaliser une interface graphique sur processing ( Download here) de but a faire afficher la squelette
d’être humain captée par kinect, d'autre plan de capté les articulations logiques des ces organes (bras, épaules,main,....)
Comme premier plan on a arrivé a faire traduire les informations prises par kinect en 4 Angles principales (Epaule et coude
droites Angles et Epaule et coude gauche angles).
Le programme processing est si dessous:
// Kinect Robot Processing Program
import SimpleOpenNI.*;
2/6

3. import SimpleOpenNI.*;
SimpleOpenNI kinect;
import processing.serial.*;
Serial port;
void setup() {
size(640, 480);
kinect = new SimpleOpenNI(this);
kinect.enableDepth();
kinect.enableUser();
kinect.setMirror(true);
println(Serial.list());
String portName = Serial.list()[0];
port = new Serial(this, portName, 9600);
}
void draw() {
kinect.update();
PImage depth = kinect.depthImage();
image(depth, 0, 0);
IntVector userList = new IntVector();
kinect.getUsers(userList);
if (userList.size() > 0) {
int userId = userList.get(0);
if ( kinect.isTrackingSkeleton(userId)) {drawSkeleton(userId);
// get the positions of the three joints of our arm
PVector rightHand = new PVector();
kinect.getJointPositionSkeleton(userId,
SimpleOpenNI.SKEL_RIGHT_HAND,
rightHand);
PVector rightElbow = new PVector();
kinect.getJointPositionSkeleton(userId,
SimpleOpenNI.SKEL_RIGHT_ELBOW,
rightElbow);
PVector rightShoulder = new PVector();
kinect.getJointPositionSkeleton(userId,
SimpleOpenNI.SKEL_RIGHT_SHOULDER,
rightShoulder);
// we need right hip to orient the shoulder angle
PVector rightHip = new PVector();
kinect.getJointPositionSkeleton(userId,
SimpleOpenNI.SKEL_RIGHT_HIP,
rightHip);
// reduce our joint vectors to two dimensions
PVector rightHand2D = new PVector(rightHand.x, rightHand.y);
PVector rightElbow2D = new PVector(rightElbow.x, rightElbow.y);
PVector rightShoulder2D = new PVector(rightShoulder.x,
rightShoulder.y);
PVector rightHip2D = new PVector(rightHip.x, rightHip.y);
// calculate the axes against which we want to measure our angles
PVector torsoOrientation =
PVector.sub(rightShoulder2D, rightHip2D);
PVector upperArmOrientation =
PVector.sub(rightElbow2D, rightShoulder2D);
// calculate the angles between our joints
float shoulderAngle = angleOf(rightElbow2D,
rightShoulder2D,
torsoOrientation);
float elbowAngle = angleOf(rightHand2D,
rightElbow2D,
upperArmOrientation);
// show the angles on the screen for debugging
fill(255,0,0);
scale(3);
3/6

4. scale(3);
text("R shoulder: " + int(shoulderAngle) + "n" +
" elbow: " + int(elbowAngle), 20, 20);
print(int(elbowAngle));
print(": elbow angle");
print(int(shoulderAngle));
println(": shoulder angle");
//////////////////////////////////////////////////////////////////////////////////////////////
PVector leftHand = new PVector();
kinect.getJointPositionSkeleton(userId,
SimpleOpenNI.SKEL_LEFT_HAND,
leftHand);/////////////
PVector leftElbow = new PVector();
kinect.getJointPositionSkeleton(userId,
SimpleOpenNI.SKEL_LEFT_ELBOW,
leftElbow);
PVector leftShoulder = new PVector();
kinect.getJointPositionSkeleton(userId,
SimpleOpenNI.SKEL_LEFT_SHOULDER,
leftShoulder);
// we need right hip to orient the shoulder angle
PVector leftHip = new PVector();
kinect.getJointPositionSkeleton(userId,
SimpleOpenNI.SKEL_LEFT_HIP,
leftHip);
// reduce our joint vectors to two dimensions
PVector leftHand2D = new PVector(leftHand.x, leftHand.y);
PVector leftElbow2D = new PVector(leftElbow.x, leftElbow.y);
PVector leftShoulder2D = new PVector(leftShoulder.x,
leftShoulder.y);
PVector leftHip2D = new PVector(leftHip.x, leftHip.y);
// calculate the axes against which we want to measure our angles
PVector torsoOrientation1 =
PVector.sub(leftShoulder2D, leftHip2D);
PVector upperArmOrientation1 =
PVector.sub(leftElbow2D, leftShoulder2D);
// calculate the angles between our joints
float shoulderAngle1 = angleOf(leftElbow2D,
leftShoulder2D,
torsoOrientation1);
float elbowAngle1 = angleOf(leftHand2D,
leftElbow2D,
upperArmOrientation1);
// show the angles on the screen for debugging
fill(255,0,0);
scale(1);
text("L shoulder: " + int(shoulderAngle1) + "n" +
" elbow: " + int(elbowAngle1), 120, 20);
print(int(elbowAngle));
print(": elbow angle");
print(int(shoulderAngle));
println(": shoulder angle");
print(int(elbowAngle1));
print(": elbow angle");
print(int(shoulderAngle1));
println(": shoulder angle");
//println(int(shoulderAngle));
byte out[] = new byte[4];
out[0] = byte(int(shoulderAngle));
out[1] = byte(int(elbowAngle));
out[2] = byte(int(shoulderAngle1));
out[3] = byte(int(elbowAngle1));
port.write(out);
4/6

5. port.write(out);
}
}
}
float angleOf(PVector one, PVector two, PVector axis) {
PVector limb = PVector.sub(two, one);
return degrees(PVector.angleBetween(limb, axis));
}
// user-tracking callbacks!
void onNewUser(SimpleOpenNI curContext, int userId) {
println("onNewUser - userId: " + userId);
println("tstart tracking skeleton");
curContext.startTrackingSkeleton(userId);
}
void drawSkeleton(int userId) {
stroke(0);
strokeWeight(5);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_HEAD, SimpleOpenNI.SKEL_NECK);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_NECK, SimpleOpenNI.SKEL_LEFT_SHOULDER);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_LEFT_SHOULDER, SimpleOpenNI.SKEL_LEFT_ELBOW);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_LEFT_ELBOW, SimpleOpenNI.SKEL_LEFT_HAND);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_NECK, SimpleOpenNI.SKEL_RIGHT_SHOULDER);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_RIGHT_SHOULDER, SimpleOpenNI.SKEL_RIGHT_ELBOW);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_RIGHT_ELBOW, SimpleOpenNI.SKEL_RIGHT_HAND);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_LEFT_SHOULDER, SimpleOpenNI.SKEL_TORSO);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_RIGHT_SHOULDER, SimpleOpenNI.SKEL_TORSO);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_TORSO, SimpleOpenNI.SKEL_LEFT_HIP);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_LEFT_HIP, SimpleOpenNI.SKEL_LEFT_KNEE);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_LEFT_KNEE, SimpleOpenNI.SKEL_LEFT_FOOT);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_TORSO, SimpleOpenNI.SKEL_RIGHT_HIP);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_RIGHT_HIP, SimpleOpenNI.SKEL_RIGHT_KNEE);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_RIGHT_KNEE, SimpleOpenNI.SKEL_RIGHT_FOOT);
kinect.drawLimb(userId, SimpleOpenNI.SKEL_RIGHT_HIP, SimpleOpenNI.SKEL_LEFT_HIP);
noStroke();
fill(100,200, 0);
// drawJoint(userId, SimpleOpenNI.SKEL_HEAD);
// drawJoint(userId, SimpleOpenNI.SKEL_NECK);
// drawJoint(userId, SimpleOpenNI.SKEL_LEFT_SHOULDER);
// drawJoint(userId, SimpleOpenNI.SKEL_LEFT_ELBOW);
// drawJoint(userId, SimpleOpenNI.SKEL_NECK);
// drawJoint(userId, SimpleOpenNI.SKEL_RIGHT_SHOULDER);
// drawJoint(userId, SimpleOpenNI.SKEL_RIGHT_ELBOW);
// drawJoint(userId, SimpleOpenNI.SKEL_TORSO);
// drawJoint(userId, SimpleOpenNI.SKEL_LEFT_HIP);
// drawJoint(userId, SimpleOpenNI.SKEL_LEFT_KNEE);
// drawJoint(userId, SimpleOpenNI.SKEL_RIGHT_HIP);
// drawJoint(userId, SimpleOpenNI.SKEL_LEFT_FOOT);
// drawJoint(userId, SimpleOpenNI.SKEL_RIGHT_KNEE);
// drawJoint(userId, SimpleOpenNI.SKEL_LEFT_HIP);
// drawJoint(userId, SimpleOpenNI.SKEL_RIGHT_FOOT);
// drawJoint(userId, SimpleOpenNI.SKEL_RIGHT_HAND);
// drawJoint(userId, SimpleOpenNI.SKEL_LEFT_HAND);
}
void onLostUser(SimpleOpenNI curContext, int userId)
{
println("onLostUser - userId: " + userId);
}
void onVisibleUser(SimpleOpenNI curContext, int userId)
{
// println("ongle 1" , o);
}
5/6

6. }
L'autre phase c'était savoir manipuler ces angles traduites par Processing en mouvement instantané de 4 servomoteurs (deux
bras manipulateurs), Tout simplement en utilisant Arduino et en reliant les 4 servomoteurs en 4 sorties PWM d'arduino de façon
suivante:
// Kinect Robot Arduino Program
#include <Servo.h>
// declare both servos
Servo shoulder;
Servo elbow;
// setup the array of servo positions
2
int nextServo = 0;
int servoAngles[] = {0,0};
void setup() {
// attach servos to their pins 3
shoulder.attach(9);
elbow.attach(10);
Serial.begin(9600);
}
void loop() {
if(Serial.available()){
int servoAngle = Serial.read();
servoAngles[nextServo] = servoAngle;
nextServo++;
if(nextServo > 1){
nextServo = 0;
}
shoulder.write(servoAngles[0]);
elbow.write(servoAngles[1]);
}
}
Comme ça se voit au bout du programme, le serial a réalisé cette tache de lire les angles et la bibliothèque servo.h d'arduino
les traduites en mouvement instantanées.
Voila votre vidéo démonstratif de fonctionnement:
http://letselectronic.blogspot.com/
Done by Houssem and Aymen
benham.houssem@gmail.com
aymenlachkem@gmail.com
6/6