Contrôle avec un Wii Nunchuck

On s’intéresse ici à un dispositif de contrôle original. On va se faire plaisir en utilisant le Nunchuck, une manette de la console de jeu Nintendo Wii.

Il ne s’agit pas de la manette principale Wiimote (décrite dans cet article) mais d’un périphérique qui s’y connecte via un câble. En tant que tel, il est donc beaucoup plus simple, mais au vu de toutes les innovations dont il est doté, c’est déjà un bond en avant dans les dispositifs de télé-commande classique, qui se limitaient jusqu’ici à des boutons et une croix directionnelle à 8 directions .

Nunchuck pris en main

Pince Easyrobotics + Nunchuck

Jugez plutôt : pour 15 euros, on trouve :
 une croix analogique à 2 axes
 un accéléromètre à 3 axes
 deux boutons judicieusement placés sous l’index et le majeur

Les usages sont multiples, mais on peut imaginer le sketch suivant, basé sur le robot Pobot Easy muni d’une pince Easyrobotics à 2 degrés de liberté :
 un bouton pour prendre la main sur le robot autonome (activer le nunchuck ou revenir au programme autonome)
 un bouton "panique" pour revenir à une situation stable (arrêt du robot, ouverture de la pince, position repliée)
 la croix analogique pour piloter les déplacements (un axe pour la vitesse, un axe pour l’angle, en déplacement polaire)
 l’accéléromètre pour piloter la pince : monter le nunchuck pour monter la pince, pivoter le nunchuck pour ouvrir la pince, en l’utilisant en gravitomètre (une simple rotation lente donnant les mêmes résultats qu’une translation brève) et en utilisant les mouvements rapides pour des enchainements (lancer le nunchuck en avant ferme rapidement la pince) permettant de jouer aussi sur la vitesse.

Exemple d’utilisation pour le Mario Chuck :

Mario Chuck first demonstration from JulienPobot on Vimeo.

 Faisabilité technique

Le matériel

L’avantage des périphériques Wii (et les ingénieurs de Nintendo sont bénis pour leur bonne idée) est d’utiliser des protocoles standards qu’on peut donc facilement reprendre et qu’on trouve déjà dans d’autres produits électroniques standards.

Ainsi le Nunchuck utilise le protocole I2C (ou TWI) qu’on retrouve dans beaucoup de capteurs et d’actionneurs en robotique, car issu de l’électronique grand public (magnétoscopes Philips au départ, puis un peu partout pour faire communiquer entre eux plusieurs circuits intégrés). Un inventaire des commandes I2C que le Nunchuck peut comprendre a été dressé par les passionnés, et de nombreuses bibliothèques de code sont disponibles pour les différents programmes électroniques courants.

Reste la connexion... mais là encore, vous n’êtes pas au bout de vos surprises :

1. la prise a un interstice de l’épaisseur d’une carte électronique standard
2. un adaptateur permet de récupérer les 4 signaux sur un connecteur standard 2,54 mm

Voici quelques images :

Adaptateur pour prise Wii

Nunchuck connecté à une Arduino

Le logiciel

On ne change pas une équipe qui gagne : depuis quelques mois, le prototypage rapide de nos ateliers est mené sur des cartes Arduino. On va donc très naturellement utiliser une carte Arduino, et cerise sur le gâteau, le génial Tod E. Kurt, concepteur - entre autres - du petit connecteur adaptateur, a choisi un ordre bien précis pour les signaux I2C, permettant d’utiliser directement sur le connecteur femelle de l’Arduino.

Pour se simplifier la vie, on va utiliser une librairie. Il en existe plusieurs :
 celle de WindMeadow
 celle de Tod
 celle de Growdown

En fait, à la base c’est le même reverse engineering de WM, donc j’ai classié les solutions par ordre chronologique. On va logiquement utiliser la toute dernière :) qui a l’avantage d’avoir les honneurs du playground Arduino : http://www.arduino.cc/playground/Ma...

Voici un exemple d’utilisation :

#include "Wire.h"
#include "WiiChuck.h"

WiiChuck chuck = WiiChuck() ;

int valX = 0 ;
int valY = 0 ;

void setup()
// alimentation du nunchuck (pas nécessaire de comprendre)
DDRC |= _BV(PORTC3) | _BV(PORTC2) ; // pattes Analog 2 et 3 en sortie
PORTC &= _BV(PORTC2) ; // patte Analog 2 à 0v
PORTC |= _BV(PORTC3) ; // patte Analog 3 à 5v

// NOTE : les variables PC2 et PC3 sont devenues PORTC2 et PORTC3 avec les nouvelles Arduino
// donc essayez l’un ou l’autre des noms selon votre carte.

delay(100) ; // une petite attente
//
Serial.begin(19200) ;
chuck.begin() ;
chuck.update() ;

void loop()
delay(200) ;
chuck.update() ;

// lecture des valeurs du joystick 2D
valX = chuck.readJoyX() ;
valY = chuck.readJoyY() ;

// affichage
Serial.print(valX) ;
Serial.print(" ") ;
Serial.print(valY) ;
Serial.println() ;

 Réalisation

Code Arduino"ChuckServoTest"

Voici ce qu’on voit à l’oscilloscope processing :

Nunchuck joystick axe X

les valeurs sont comprises entre 20 et 200

L’affichage des valeurs c’est déjà bien, mais piloter des servomoteurs ce serait plus... visuel ! alors c’est parti.
On va utiliser la bibliothèque officielle pour piloter les servos (attention, que 2 sur les pattes 9 et 10, pour plus de servos il faut utiliser une autre bibliothèque, qu’on peut trouver dans le Playground, comme SoftwareServo).
Pour plus de fun, on va faire bouger une pince Easyrobotics à 2 degrés de liberté. Il y en a justement une qui est arrivée chez moi ce matin...

Le code spécifique au servo est très simple :

#include "Servo.h"

Servo servBras ;
Servo servPince ;

...

void setup()

...
//
servBras.attach(10) ;
servPince.attach(9) ;
servBras.write(90) ; // valeur milieu
servPince.write(90) ; // valeur milieu

void loop()

...
// lecture des valeurs du joystick 2D pour rappel
valX = chuck.readJoyX() ;
valY = chuck.readJoyY() ;
...
servBras.write(90+valX/2) ; // on divise par 2 la valeur reçue pour moins d’amplitude et plus de précision
servPince.write(90+valY/2) ;

Et une petite vidéo :

Nunchuck Wii makes move robotics arm with grip from JulienPobot on Vimeo.

 Lisser les valeurs de l’accéléromètre

On va maintenant mettre en place un algorithme permettant de lisser la valeur de l’accéléromètre. Tout d’abord, on ne va pas utiliser les valeurs brutes des 3 axes mais les convertir en angles "roll" et "pitch".

Cette conversion est fournie par une librairie Arduino.

/**
* Nunchuck — Use a Wii Nunchuck
* Tim Hirzel http://www.growdown.com
*/

// returns roll degrees
int readRoll()
return (int)(atan2(readAccelX(),readAccelZ())/ M_PI * 180.0) ;

// returns pitch in degrees
int readPitch()
return (int) (acos(readAccelY()/RADIUS)/ M_PI * 180.0) ; // Radius = 210

Voici tout d’abord ce qu’on obtient sans filtre.

Nunchuck accelero "roll"

entre -180 et +180

Nunchuck accelero "X" + "roll"

en rouge l’accéléromètre X et en blanc l’angle calculé avec la formule trigonométrique.

Filtre PID

On va asservir une valeur "filtre" sur la valeur réelle, et on va utiliser un asservissement PID pour que notre valeur "filtre" suive la consigne donnée par la valeur réelle.

Voici le résultat de quelques tests :

Intéressant mais pas très utile finalement.

Filtre moyenne

En fait, le plus simple est de faire un effet retard en considérant comme valeur "filtre" la moyenne des n dernières valeurs réelles. Le choix de n influera sur la rapidité du filtre.

Voici ce que ça donne : c’est très satisfaisant et ça évitera que le nunchuck ne soit trop réactif.

 Autres vidéos d’un Nunchuck

Des vidéos d’autres réalisations (non-Pobot) :

Et une réalisation complète avec un robot humanoïde Robonova :