Réalisation de la main gauche de Inmoov

***

Mise à jour 04/06/2022 : Plusieurs améliorations ont été apportées au projet initial de la main gauche de Inmoov. La mise en place d’un pouce ajustable pour permettre la fermeture complète de la main et l’amélioration du système de tension des tendons.

Sommaire :

Plusieurs améliorations ont été apportées au projet initial
- La mise en place d’un pouce ajustable pour permettre la fermeture complète de la main
- L’amélioration du système de tension des tendons.
Contrôle de la consommation électrique de la main.
Descriptif technique des différents matériels utilisés pour nos tests.
Impression 3D des différentes pièces .
Applications .
1. Montage et programme permettant de régler et de tester les doigts et la rotation du poignée .
  1. Schéma électrique avec batterie ou pile .
  2. Schéma électrique avec régulateur et alimentation supérieure a 9V.
  3. Programme pour Arduino .
2. Utilisation d’un capteur de flexion pour reproduire le mouvement des doigts
  1. Présentation du capteur de flexion .
    - Caractéristiques
    - Comment utilisé le capteur de flexion?
    - Schéma de principe du pont diviseur de tension .
  2. Schéma électrique de principe du capteur de flexion avec batterie ou pile.
  3. Vidéo de démonstration du fonctionnement du capteur de flexion .
3. Utilisation de 5 capteurs de flexion pour reproduire le mouvement des doigts et les transmettre vers la main .
  1. 1. Présentation et objectifs du montage .
    2. Liste du materiel
    3. Schéma électrique de câblage du gant de recopie et des servomoteurs de la main .
  1. 1. Montage des capteurs de flexion sur le gant de recopie.
  1. 1. Programme pour le fonctionnement de l’ensemble sur Arduino Mega 2560
  1. Vidéo de démonstration de l’ensemble .

Retour au sommaire

Plusieurs améliorations ont été apportées au projet initial

a) La mise en place d’un pouce ajustable pour permettre la fermeture complète de la main

b) L’amélioration du système de tension des tendons

Nous avons consacré un article complet sur la modification des tendons -> allez à la Modification

Nous utilisons en terme de colle pour l’assemblage, une colle double composant résine et durcisseur à base d’époxy ainsi que de la cyanoacrylate pour la fixation définitive des tendons (nœud)

Pour les tendons, nous avons opté pour du fil de pèche de ø 1mm supportant 200lb (91kg) obtenu chez Amazon

L’assemblage des doigts se fait avec de la colle époxy ainsi que du filament de 3 mm de type ABS, il faut bien sûr repercer avec un foret de 3mm les orifices des phalanges. Leur assemblage est ainsi facilité.

Filament ABS de 3mm

Retour au sommaire

Contrôle de la consommation électrique de la main.

Nous avons utilisé une alimentation ISO-TECH ips 405 pour déterminer la consommation max du montage . Les alimentations des servomoteurs ne sont pas prises en directe sur la carte Arduino car celle-ci ne peut fournir plus de 200 mA .

Cette alimentation est programmable pouvant générer 30 V sous 5 Ampères maximum cela nous permet une grande compatibilité avec nos montages. Dans notre cas, elle était réglée sur 6V de façon à obtenir le couple maximum des servomoteurs .

Nous avons déjà d’une façon théorique, calculer la consommation de cette main , mais pour avoir une image réelle de la consommation qui est le reflet des frottements et autres anomalies qui pourraient éventuellement avoir. Nous avons voulu vérifier en dynamique cette consommation . Nous avons imaginé un petit programme qui met en scène tous les mouvements possibles des doigts .

Grace à cela, nous pouvons en déduire la puissance nécessaire , et faire nos cartes d’alimentations électroniques en conséquence.

Retour au sommaire

Descriptif technique des différents matériels utilisés pour nos tests

Pour la partie télécommande, nous utilisons un Arduino méga 2560 surmonté d’un module Grove mega shield.

Pour la partie servomoteur, l’ensemble de l’avant-bras et géré par des HS-645MG de chez Hitec

Description des servomoteurs HS-645MG

Ce servomoteur à double roulements à billes se caractérise par un excellent centrage et un couple très élevé.

Alimentation: 4,8 à 6 Vcc
Course: 2 x 45°
Couple: 9,6 kg.cm
Vitesse: 0,2 s/60°
Dimensions: 41 x 20 x 36 mm
Poids: 54 gr

5 pour les tendons
1 pour le poignet
1 pour l’ajustage du pouce

Retour au sommaire

Impression 3D des différentes pièces

Pour l’ensemble du projet, l’imprimante 3D utilisée est une Makerbot Replicator 2

Toutes les pièces sont faites avec les réglages ci-dessous

Densité = 30%
Température = 215°C
Nombre de couche = 3
Épaisseur du trait = 0.15
Le temps total nécessaire et de 62 h 7 min
Pour un total de 715.76g de PLA

Fichier initial	Temps de fabrication	poids(g)
Bolt_entretoise6	1h44	15,2
leftcoverfinger1	1h10	16,6
leftrobcap3V1	2h02	29,19
Leftrobpart2V3	7h19	77,78
leftrobpart3V3	5h39	58,57
leftrobpart4V3	8h17	90,48
Leftrobpart5V3	9h46	105,09
leftthumb5	2h35	29,61
lefttopsurface4	3h09	44,97
LeftWristlargeV4	5h15	63,82
leftWristsmallV3	2h17	27,87
tendeur tendon RedohmV2	1h19	16,78
Leftauriculaire5	1h04	10,97
Leftindex5	1h29	15,78
Leftmajeur3	1h44	18,8
Leftringfinger3	1h19	14,11
LeftRobCableBackV3	0h38	8,52
LeftRobCableFrontV3	1h08	15,49
LeftRobServoBedV5	4h48	56,13

Total ->	62h07mm	715,76 g

Retour au sommaire

Applications

1) Montage et programme permettant de régler et de tester les doigts et la rotation du poignée.

a) Schéma avec batterie ou pile.

RedOhm schéma pour le pilotage de 6 servomoteurs avec potentiomètre.

Retour au sommaire

b) Schéma électrique avec régulateur et alimentation supérieure a 9V.

Schéma électrique pour 6 servomoteurs et régulation de la tension .

Pourquoi mettre des régulateurs en parallèles ?

Simplement pour augmenter le courant de sortie.

Comment calculer notre courant de sortie de notre montage ?

Il faut d’abord s’assurer du courant maximum des régulateurs en question (toujours prendre la même référence de régulateur pour un montage donné). Pour notre montage, nos régulateurs possèdent la référence suivante :MC7805CK . Le constructeur nous indique 3A maximum

Donc I_sortie = Nombre_de_régulateur * I_max soit 9A

A quoi servent les condensateurs aux bornes des régulateurs MC7805CK ?

Ce montage a tendance à entrer en oscillation. Il est très important que les condensateurs de découplage soit soudés le plus près possible de la sortie du régulateur et du retour à la masse de chaque régulateur.

Le courant est-il identique dans chaque régulateur ?

Il n’y a aucune importance que le courant de sortie se repartisse de façon identique dans chaque régulateur. Chaque régulateur va s’autoréguler.

Comment augmenter la tension de sortie d’un régulateur 5V pour obtenir du 6 ?

Il suffit simplement de l’adjonction d’une diode Zener ou une diode standart ( tension de jonction 0.7V ) dans la ligne de la masse qui a pour but d’augmenter la tension de sortie de la valeur de la tension de la diode en question.

Retour au sommaire

c) Programme .

/*
 * 
 * 
 * 
 * RedOhm
 * 
 * 
 * Positionnement des differents servomoteurs a l'aide 
 * de 6 potentiometres 
 *              
 * Le 11/09/2016
 * H.Mazelin              
 * 
 * Version 1.00
 */
 


// Cette librairie permet à une carte Arduino de contrôler des servomoteurs
#include <Servo.h>


// Crée un objet de type "Servo", nommé -> servopouce
Servo servopouce;
// Crée un objet de type "Servo", nommé -> servoindex
Servo servoindex;
// Crée un objet de type "Servo", nommé -> servomajeur
Servo servomajeur;
// Crée un objet de type "Servo", nommé -> servoannulaire
Servo servoannulaire;
// Crée un objet de type "Servo", nommé -> servoauriculaire
Servo servoauriculaire;
// Crée un objet de type "Servo", nommé -> servorotation
Servo servorotation;

// declaration pour l'information du pouce en entree
// broche sur lequel est branche le potentiometre pour animer du pouce
int brochepotar_de_position_pouce=0;
// variable contenant la valeur du potentiometre de du pouce
int  valeur_potar_position_pouce;

// declaration pour l'information du index en entree
// broche sur lequel est branche le potentiometre pour animer l'index
int brochepotar_de_position_index=2;
// variable contenant la valeur du potentiometre de l'index
int  valeur_potar_position_index;

// declaration pour l'information du majeur en entree
// broche sur lequel est branche le potentiometre pour animer le majeur
int brochepotar_de_position_majeur=4;
// variable contenant la valeur du potentiometre du majeur
int  valeur_potar_position_majeur;

// declaration pour l'information du l'annulaire en entree
// broche sur lequel est branche le potentiometre pour animer l'annulaire
int brochepotar_de_position_annulaire=6;
// variable contenant la valeur du potentiometre du annulaire
int  valeur_potar_position_annulaire;

// declaration pour l'information de auriculaire en entree
// broche sur lequel est branche le potentiometre pour animer l'auriculaire
int brochepotar_de_position_auriculaire=8;
// variable contenant la valeur du potentiometre de 1'auriculaire
int  valeur_potar_position_auriculaire;

// declaration pour l'information pour la rotation en entree
// broche sur lequel est branche le potentiometre pour animer la rotation
int brochepotar_de_position_rotation=10;
// variable contenant la valeur du potentiometre de rotation
int  valeur_potar_position_rotation;


// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécuter une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties


void setup() {


// initialisation de la connexion série
// IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.
Serial.begin(9600); 

// associe le servomoteur servopouce a la broche 2
servopouce.attach(2);
// associe le servomoteur servoindex a la broche 3
servoindex.attach(3);
// associe le servomoteur servomajeur a la broche 4
servomajeur.attach(4);
// associe le servomoteur servoannulaire a la broche 5
servoannulaire.attach(5);
// associe le servomoteur servoauriculaire a la broche 6
servoauriculaire.attach(6);
// associe le servomoteur servoauriculaire a la broche 7
servorotation.attach(7);
}



// Le programme principal s’exécute par une boucle infinie appelée Loop () 


void loop() {
  

  //***************************************************** 
  //traitement et pilotage du pouce
  //*****************************************************
  
    
  
  
  //traitement de pilotage du pouce
  valeur_potar_position_pouce=analogRead( brochepotar_de_position_pouce);
   
  // Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
  // Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
  valeur_potar_position_pouce=map(valeur_potar_position_pouce,0,1023,80,168);
  // définit la position d'asservissement du servomoteur 
  // en fonction de la valeur à l'échelle  
  servopouce.write(valeur_potar_position_pouce);
  // La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la 
  // fonction Map
  // Serial.println( valeur_potar_position_pouce); 
  delay(20);




  //***************************************************** 
  //traitement et pilotage de l'index
  //*****************************************************
  
 
  
  //traitement de pilotage du index
  valeur_potar_position_index=analogRead( brochepotar_de_position_index);
  
  // Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
  // Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
  valeur_potar_position_index=map(valeur_potar_position_index,0,1023,80,160);
  // définit la position d'asservissement du servomoteur 
  // en fonction de la valeur à l'échelle  
  servoindex.write(valeur_potar_position_index);
  // La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la 
  // fonction Map
  //Serial.println( valeur_potar_position_index); 
  delay(20);


  //***************************************************** 
  //traitement et pilotage du majeur
  //*****************************************************
  
  valeur_potar_position_majeur=analogRead( brochepotar_de_position_majeur);
  
  // Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
  // Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
  valeur_potar_position_majeur=map(valeur_potar_position_majeur,0,1023,80,175);
  // définit la position d'asservissement du servomoteur 
  // en fonction de la valeur à l'échelle  
  servomajeur.write(valeur_potar_position_majeur);
  // La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la 
  // fonction Map
  //Serial.println( valeur_potar_position_majeur); 
  delay(20);
  

  //***************************************************** 
  //traitement et pilotage de l'annulaire
  //*****************************************************
 
  //traitement de pilotage de l'annulaire
  valeur_potar_position_annulaire=analogRead( brochepotar_de_position_annulaire);
  
  
  // Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
  // Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
  valeur_potar_position_annulaire=map(valeur_potar_position_annulaire,0,1023,80,175);
  // définit la position d'asservissement du servomoteur 
  // en fonction de la valeur à l'échelle  
  servoannulaire.write(valeur_potar_position_annulaire);
  // La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la 
  // fonction Map
  Serial.println( valeur_potar_position_annulaire); 
  delay(20);

 
  //***************************************************** 
  //traitement et pilotage de l'auriculaire
  //*****************************************************
 
  //traitement de pilotage de l'auriculaire
  valeur_potar_position_auriculaire=analogRead( brochepotar_de_position_auriculaire);
  
  
  // Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
  // Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
  valeur_potar_position_auriculaire=map(valeur_potar_position_auriculaire,0,1023,80,175);
  // définit la position d'asservissement du servomoteur 
  // en fonction de la valeur à l'échelle  
  servoauriculaire.write(valeur_potar_position_auriculaire);
  // La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la 
  // fonction Map
  // Serial.println( valeur_potar_position_auriculaire); 
  delay(20);

   
  //***************************************************** 
  //traitement et pilotage pour la rotation  
  //*****************************************************

   //traitement pour le  pilotage de la rotation 
   valeur_potar_position_rotation=analogRead( brochepotar_de_position_rotation);
  
  
  // Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
  // Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
  valeur_potar_position_rotation=map(valeur_potar_position_rotation,0,1023,75,175);
  // définit la position d'asservissement du servomoteur 
  // en fonction de la valeur à l'échelle  
  servorotation.write(valeur_potar_position_rotation);
  // La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la 
  // fonction Map .
  // Serial.println( valeur_potar_position_rotation); 
  delay(20);



  
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

* RedOhm

* Positionnement des differents servomoteurs a l'aide

* de 6 potentiometres

* Le 11/09/2016

* H.Mazelin

* Version 1.00

// Cette librairie permet à une carte Arduino de contrôler des servomoteurs

#include <Servo.h>

// Crée un objet de type "Servo", nommé -> servopouce

Servo servopouce;

// Crée un objet de type "Servo", nommé -> servoindex

Servo servoindex;

// Crée un objet de type "Servo", nommé -> servomajeur

Servo servomajeur;

// Crée un objet de type "Servo", nommé -> servoannulaire

Servo servoannulaire;

// Crée un objet de type "Servo", nommé -> servoauriculaire

Servo servoauriculaire;

// Crée un objet de type "Servo", nommé -> servorotation

Servo servorotation;

// declaration pour l'information du pouce en entree

// broche sur lequel est branche le potentiometre pour animer du pouce

int brochepotar_de_position_pouce=0;

// variable contenant la valeur du potentiometre de du pouce

int valeur_potar_position_pouce;

// declaration pour l'information du index en entree

// broche sur lequel est branche le potentiometre pour animer l'index

int brochepotar_de_position_index=2;

// variable contenant la valeur du potentiometre de l'index

int valeur_potar_position_index;

// declaration pour l'information du majeur en entree

// broche sur lequel est branche le potentiometre pour animer le majeur

int brochepotar_de_position_majeur=4;

// variable contenant la valeur du potentiometre du majeur

int valeur_potar_position_majeur;

// declaration pour l'information du l'annulaire en entree

// broche sur lequel est branche le potentiometre pour animer l'annulaire

int brochepotar_de_position_annulaire=6;

// variable contenant la valeur du potentiometre du annulaire

int valeur_potar_position_annulaire;

// declaration pour l'information de auriculaire en entree

// broche sur lequel est branche le potentiometre pour animer l'auriculaire

int brochepotar_de_position_auriculaire=8;

// variable contenant la valeur du potentiometre de 1'auriculaire

int valeur_potar_position_auriculaire;

// declaration pour l'information pour la rotation en entree

// broche sur lequel est branche le potentiometre pour animer la rotation

int brochepotar_de_position_rotation=10;

// variable contenant la valeur du potentiometre de rotation

int valeur_potar_position_rotation;

// Un programme Arduino doit impérativement contenir la fonction "setup"

// Elle ne sera exécuter une seule fois au démarrage du microcontroleur

// Elle sert à configurer globalement les entrées sorties

void setup() {

// initialisation de la connexion série

// IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.

Serial.begin(9600);

// associe le servomoteur servopouce a la broche 2

servopouce.attach(2);

// associe le servomoteur servoindex a la broche 3

servoindex.attach(3);

// associe le servomoteur servomajeur a la broche 4

servomajeur.attach(4);

// associe le servomoteur servoannulaire a la broche 5

servoannulaire.attach(5);

// associe le servomoteur servoauriculaire a la broche 6

servoauriculaire.attach(6);

// associe le servomoteur servoauriculaire a la broche 7

servorotation.attach(7);

}

// Le programme principal s’exécute par une boucle infinie appelée Loop ()

void loop() {

//*****************************************************

//traitement et pilotage du pouce

//*****************************************************

//traitement de pilotage du pouce

valeur_potar_position_pouce=analogRead( brochepotar_de_position_pouce);

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

valeur_potar_position_pouce=map(valeur_potar_position_pouce,0,1023,80,168);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servopouce.write(valeur_potar_position_pouce);

// La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la

// fonction Map

// Serial.println( valeur_potar_position_pouce);

delay(20);

//*****************************************************

//traitement et pilotage de l'index

//*****************************************************

//traitement de pilotage du index

valeur_potar_position_index=analogRead( brochepotar_de_position_index);

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

valeur_potar_position_index=map(valeur_potar_position_index,0,1023,80,160);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servoindex.write(valeur_potar_position_index);

// La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la

// fonction Map

//Serial.println( valeur_potar_position_index);

delay(20);

//*****************************************************

//traitement et pilotage du majeur

//*****************************************************

valeur_potar_position_majeur=analogRead( brochepotar_de_position_majeur);

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

valeur_potar_position_majeur=map(valeur_potar_position_majeur,0,1023,80,175);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servomajeur.write(valeur_potar_position_majeur);

// La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la

// fonction Map

//Serial.println( valeur_potar_position_majeur);

delay(20);

//*****************************************************

//traitement et pilotage de l'annulaire

//*****************************************************

//traitement de pilotage de l'annulaire

valeur_potar_position_annulaire=analogRead( brochepotar_de_position_annulaire);

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

valeur_potar_position_annulaire=map(valeur_potar_position_annulaire,0,1023,80,175);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servoannulaire.write(valeur_potar_position_annulaire);

// La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la

// fonction Map

Serial.println( valeur_potar_position_annulaire);

delay(20);

//*****************************************************

//traitement et pilotage de l'auriculaire

//*****************************************************

//traitement de pilotage de l'auriculaire

valeur_potar_position_auriculaire=analogRead( brochepotar_de_position_auriculaire);

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

valeur_potar_position_auriculaire=map(valeur_potar_position_auriculaire,0,1023,80,175);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servoauriculaire.write(valeur_potar_position_auriculaire);

// La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la

// fonction Map

// Serial.println( valeur_potar_position_auriculaire);

delay(20);

//*****************************************************

//traitement et pilotage pour la rotation

//*****************************************************

//traitement pour le pilotage de la rotation

valeur_potar_position_rotation=analogRead( brochepotar_de_position_rotation);

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

valeur_potar_position_rotation=map(valeur_potar_position_rotation,0,1023,75,175);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servorotation.write(valeur_potar_position_rotation);

// La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la

// fonction Map .

// Serial.println( valeur_potar_position_rotation);

delay(20);

}

Programme ci-dessus à télécharger .
Téléchargement ->essai_de_la_main_le_10_09_2016

Retour au sommaire

2) Utilisation d’un capteur de flexion pour reproduire le mouvement des doigts

a) Présentation du capteur de flexion .

Le capteur de flexion est l’une des pièces souvent négligée par l’utilisateur, mais si vous avez besoin de vérifier si quelque chose se plie , comme un doigt ou un bras ce type de capteur semble tout indiqué pour votre application .
Capteur de flexion souple résistif. La résistance augmente lorsque l’angle de flexion du capteur augmente.

A savoir : Il faut éviter de plier la base du capteur.

Caractéristiques :

Résistance au repos: 10 kΩ
Tolérance: ±30 %
Variation: 60 à 110 kΩ
Puissance: 0,5 W
Durée de vie: 1 million de cycles
Dimensions: 112 x 6 x 0,43 mm

Capteur de flexion

Comment utiliser le capteur de flexion?

Le capteur Flex modifie sa résistance en flexion de sorte que nous pouvons mesurer ce changement sur l’une des broches analogique de la carte Arduino. Mais pour cela nous avons besoin d’une résistance fixe que nous allons utiliser pour cette comparaison (la résistance utilisée dans le montage est de valeur 22 KΩ).
Ce type de montage est appelé : pont diviseur de tension .On divise la tension du 5 V délivré par la carte microcontrôleur entre le capteur flexion est la résistance de 22KΩ .

Schéma de principe du pont diviseur de tension .

Schéma de principe du pont diviseur de tension

Retour au sommaire

b) Schéma électrique de principe du capteur de flexion avec batterie ou pile

Schéma de principe du capteur de flexion

Retour au sommaire

c) Démonstration du fonctionnement du capteur de flexion .

Retour au sommaire

3) Utilisation de 5 capteurs de flexion pour reproduire le mouvement des doigts et les transmettre vers la main.

a) Présentation et objectifs du montage .

Le but de ce montage et de copier les mouvements des doigts et de les retransmettre via une carte microcontrôleur à l’avant bras du projet Inmoov .Pour cela, nous allons créer un gant équipé de capteurs de flexion pour chaque doigt. Nous allons donc utiliser trois capteurs de type FS7548 que nous allons affecté à l’index, majeur et annulaire , et deux autres capteurs de type FS7954 qui eux seront affectés au pouce et à l’auriculaire .

Retour au sommaire

b) Liste du materiel.

Avec utilisation du materiel Grove
Quantité	Référence	Désignation	Prix moyen
1	Carte Arduino MEGA 2560 Fournisseur : generationrobot	La carte Arduino Mega 2560 est basée sur un ATMega2560 cadencé à 16 MHz. Elle dispose de 54 E/S dont 14 PWM, 16 analogiques et 4 UARTs.	37€ à 45€
1	Shield de connexion cartes Arduino Mega Fournisseur : generationrobot	Grove – Mega Shield est une shield de connexion pour cartes Arduino Mega et Google Android ADK.	10€ à 12€
3	Capteur de flexion FS7548 Fournisseur : gotronic	Capteur de flexion souple résistif. La résistance augmente lorsque l’angle de flexion du capteur augmente. Résistance au repos: 10 kΩ Dimensions: 112 x 6 x 0,43 mm Affectation : index,majeur,annulaire	18€ à 22€
2	Capteur de flexion FS7954 Fournisseur : gotronic	Capteur de flexion souple résistif. La résistance augmente lorsque l’angle de flexion du capteur augmente. Résistance au repos: 25 kΩ Dimensions: 74 x 6 x 0,43 mm Affectation : pouce,auriculaire	10€ à 14€
5	Résistance 1/4W 22KΩ Fournisseur : gotronic	Résistances à couche carbone ¼ W. Tolérance: 5% – Tension max: 250 V Diamètre 2.3 mm – Longueur 6.5 mm.	0.08€ à 0.12€
1	Gaine thermorétractable Reference : FT6.4N / 08842 Fournisseur : gotronic	Polyoléfine très flexible – Longueur: 1.20 m – Taux de retreint 2:1. Température de retreint: 120° C – T° de service: -40° C à +135° C. D: Ø avant retreint : 6.4mm d: Ø après retreint. 3.2mm Couleur : Noir Pour le montage des capteurs de flexion sur le gant	1.5€ à 1.90€

Retour au sommaire

c) Schéma électrique du câblage des gants de recopie et de la main .

Retour au sommaire

d ) Montage des capteurs de flexion sur le gant de recopie.

La gaine rétractable est coupée de la longueur de la sonde . On prend soin de chauffer l’extrémité de la gaine de façon que le capteur ne puisse s’échapper de son logement, puis on la fixe avec de la colle néoprène sur la partie supérieure du doigt du gant.Enfin,on répète cette opération pour chacun des doigts .

Insertion des capteurs de flexion dans la gaine thermo-rétractable

Insertion des capteurs de flexion dans la gaine thermo-rétractable.

Vue du gant prêt à fonctionner

Retour au sommaire

e ) Programme pour le fonctionnement de l’ensemble sur Arduino Mega 2560 .

/*
 * 
 * 
 * 
 * RedOhm
 * 
 * 
 * Positionnement des differents servomoteurs a l'aide 
 * du gant de recopie 
 * 
 * A savoir :
 * Nous avons repris le programme précédent et nous avons 
 * modifier quelques parametres
 *              
 * Le 21/09/2016
 * H.Mazelin              
 * 
 * Version 1.00
 */
 


// Cette librairie permet à une carte Arduino de contrôler des servomoteurs
#include <Servo.h>


// Crée un objet de type "Servo", nommé -> servopouce
Servo servopouce;
// Crée un objet de type "Servo", nommé -> servoindex
Servo servoindex;
// Crée un objet de type "Servo", nommé -> servomajeur
Servo servomajeur;
// Crée un objet de type "Servo", nommé -> servoannulaire
Servo servoannulaire;
// Crée un objet de type "Servo", nommé -> servoauriculaire
Servo servoauriculaire;
// Crée un objet de type "Servo", nommé -> servorotation
Servo servorotation;

// declaration pour l'information du pouce en entree
// broche sur lequel est branche le capteur de flexion afin d'animer du pouce
int brochepotar_de_position_pouce=0;
// variable contenant la valeur du capteur de flexion du pouce
int  valeur_potar_position_pouce;

// declaration pour l'information du index en entree
// broche sur lequel est branche le capteur de flexion afin d'animer l'index
int brochepotar_de_position_index=2;
// variable contenant la valeur du capteur de flexion de l'index
int  valeur_potar_position_index;

// declaration pour l'information du majeur en entree
// broche sur lequel est branche le capteur de flexion afin d'animer le majeur
int brochepotar_de_position_majeur=4;
// variable contenant la valeur du capteur de flexion du majeur
int  valeur_potar_position_majeur;

// declaration pour l'information du l'annulaire en entree
// broche sur lequel est branche le capteur de flexion afin d'animer l'annulaire
int brochepotar_de_position_annulaire=6;
// variable contenant la valeur du capteur de flexion de l'annulaire
int  valeur_potar_position_annulaire;

// declaration pour l'information de auriculaire en entree
// broche sur lequel est branche le capteur de flexion afin d'animer l'auriculaire
int brochepotar_de_position_auriculaire=8;
// variable contenant la valeur du capteur de flexion de 1'auriculaire
int  valeur_potar_position_auriculaire;

// declaration pour l'information pour la rotation en entree
// broche sur lequel est branche le potentiometre pour animer la rotation
int brochepotar_de_position_rotation=10;
// variable contenant la valeur du potentiometre de rotation
int  valeur_potar_position_rotation;


// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécuter une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties


void setup() {


// initialisation de la connexion série
// IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.
Serial.begin(9600); 

// associe le servomoteur servopouce a la broche 2
servopouce.attach(2);
// associe le servomoteur servoindex a la broche 3
servoindex.attach(3);
// associe le servomoteur servomajeur a la broche 4
servomajeur.attach(4);
// associe le servomoteur servoannulaire a la broche 5
servoannulaire.attach(5);
// associe le servomoteur servoauriculaire a la broche 6
servoauriculaire.attach(6);
// associe le servomoteur servoauriculaire a la broche 7
servorotation.attach(7);
}



// Le programme principal s’exécute par une boucle infinie appelée Loop () 


void loop() {
  

  //***************************************************** 
  //traitement et pilotage du pouce
  //*****************************************************
  
    
  
  
  //traitement de pilotage du pouce
  valeur_potar_position_pouce=analogRead( brochepotar_de_position_pouce);
  // Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
  // Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination 
  // attention a bien mettre la valeur du capteur de flexion dans la fonction map
  // récupérer les bonnes valeurs avec le programme etalonnage dispo sur le site REDOHM  
  valeur_potar_position_pouce=map(valeur_potar_position_pouce,250,423,80,168);
  // définit la position d'asservissement du servomoteur 
  // en fonction de la valeur à l'échelle  
  servopouce.write(valeur_potar_position_pouce);
  // La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la 
  // fonction Map
  // Serial.println( valeur_potar_position_pouce); 
  delay(20);




  //***************************************************** 
  //traitement et pilotage de l'index
  //*****************************************************
  
 
  
  //traitement de pilotage du index
  valeur_potar_position_index=analogRead( brochepotar_de_position_index);
  // Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
  // Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination
  // attention a bien mettre la valeur du capteur de flexion dans la fonction map
  // récupérer les bonnes valeurs avec le programme etalonnage dispo sur le site REDOHM     
  valeur_potar_position_index=map(valeur_potar_position_index,658,500,80,160);
  // définit la position d'asservissement du servomoteur 
  // en fonction de la valeur à l'échelle  
  servoindex.write(valeur_potar_position_index);
  // La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la 
  // fonction Map
  //Serial.println( valeur_potar_position_index); 
  delay(20);


  //***************************************************** 
  //traitement et pilotage du majeur
  //*****************************************************
  
  valeur_potar_position_majeur=analogRead( brochepotar_de_position_majeur);
  // Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
  // Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination
  // attention a bien mettre la valeur du capteur de flexion dans la fonction map
  // récupérer les bonnes valeurs avec le programme etalonnage dispo sur le site REDOHM     
  valeur_potar_position_majeur=map(valeur_potar_position_majeur,706,535,80,175);
  // définit la position d'asservissement du servomoteur 
  // en fonction de la valeur à l'échelle  
  servomajeur.write(valeur_potar_position_majeur);
  // La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la 
  // fonction Map
  //Serial.println( valeur_potar_position_majeur); 
  delay(20);
  

  //***************************************************** 
  //traitement et pilotage du l'annulaire
  //*****************************************************
 
  //traitement de pilotage du l'annulaire
  valeur_potar_position_annulaire=analogRead( brochepotar_de_position_annulaire);
  // Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
  // Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination 
  // attention a bien mettre la valeur du capteur de flexion dans la fonction map
  // récupérer les bonnes valeurs avec le programme etalonnage dispo sur le site REDOHM    
  valeur_potar_position_annulaire=map(valeur_potar_position_annulaire,677,486,80,175);
  // définit la position d'asservissement du servomoteur 
  // en fonction de la valeur à l'échelle  
  servoannulaire.write(valeur_potar_position_annulaire);
  // La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la 
  // fonction Map
  //Serial.println( valeur_potar_position_annulaire); 
  delay(20);

 
  //***************************************************** 
  //traitement et pilotage de l'auriculaire
  //*****************************************************
 
  //traitement de pilotage de l'auriculaire
  valeur_potar_position_auriculaire=analogRead( brochepotar_de_position_auriculaire);
  // Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
  // Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination
  // attention a bien mettre la valeur du capteur de flexion dans la fonction map
  // récupérer les bonnes valeurs avec le programme etalonnage dispo sur le site REDOHM     
  valeur_potar_position_auriculaire=map(valeur_potar_position_auriculaire,325,442,80,175);
  // définit la position d'asservissement du servomoteur 
  // en fonction de la valeur à l'échelle  
  servoauriculaire.write(valeur_potar_position_auriculaire);
  // La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la 
  // fonction Map
  // Serial.println( valeur_potar_position_auriculaire); 
  delay(20);

   
  //***************************************************** 
  //traitement et pilotage pour la rotation  
  //*****************************************************

   //traitement pour le  pilotage de la rotation 
   valeur_potar_position_rotation=analogRead( brochepotar_de_position_rotation);
  // Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
  // Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
  valeur_potar_position_rotation=map(valeur_potar_position_rotation,0,1023,75,175);
  // définit la position d'asservissement du servomoteur 
  // en fonction de la valeur à l'échelle  
  servorotation.write(valeur_potar_position_rotation);
  // La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la 
  // fonction Map .
  // Serial.println( valeur_potar_position_rotation); 
  delay(20);













  
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

* RedOhm

* Positionnement des differents servomoteurs a l'aide

* du gant de recopie

* A savoir :

* Nous avons repris le programme précédent et nous avons

* modifier quelques parametres

* Le 21/09/2016

* H.Mazelin

* Version 1.00

// Cette librairie permet à une carte Arduino de contrôler des servomoteurs

#include <Servo.h>

// Crée un objet de type "Servo", nommé -> servopouce

Servo servopouce;

// Crée un objet de type "Servo", nommé -> servoindex

Servo servoindex;

// Crée un objet de type "Servo", nommé -> servomajeur

Servo servomajeur;

// Crée un objet de type "Servo", nommé -> servoannulaire

Servo servoannulaire;

// Crée un objet de type "Servo", nommé -> servoauriculaire

Servo servoauriculaire;

// Crée un objet de type "Servo", nommé -> servorotation

Servo servorotation;

// declaration pour l'information du pouce en entree

// broche sur lequel est branche le capteur de flexion afin d'animer du pouce

int brochepotar_de_position_pouce=0;

// variable contenant la valeur du capteur de flexion du pouce

int valeur_potar_position_pouce;

// declaration pour l'information du index en entree

// broche sur lequel est branche le capteur de flexion afin d'animer l'index

int brochepotar_de_position_index=2;

// variable contenant la valeur du capteur de flexion de l'index

int valeur_potar_position_index;

// declaration pour l'information du majeur en entree

// broche sur lequel est branche le capteur de flexion afin d'animer le majeur

int brochepotar_de_position_majeur=4;

// variable contenant la valeur du capteur de flexion du majeur

int valeur_potar_position_majeur;

// declaration pour l'information du l'annulaire en entree

// broche sur lequel est branche le capteur de flexion afin d'animer l'annulaire

int brochepotar_de_position_annulaire=6;

// variable contenant la valeur du capteur de flexion de l'annulaire

int valeur_potar_position_annulaire;

// declaration pour l'information de auriculaire en entree

// broche sur lequel est branche le capteur de flexion afin d'animer l'auriculaire

int brochepotar_de_position_auriculaire=8;

// variable contenant la valeur du capteur de flexion de 1'auriculaire

int valeur_potar_position_auriculaire;

// declaration pour l'information pour la rotation en entree

// broche sur lequel est branche le potentiometre pour animer la rotation

int brochepotar_de_position_rotation=10;

// variable contenant la valeur du potentiometre de rotation

int valeur_potar_position_rotation;

// Un programme Arduino doit impérativement contenir la fonction "setup"

// Elle ne sera exécuter une seule fois au démarrage du microcontroleur

// Elle sert à configurer globalement les entrées sorties

void setup() {

// initialisation de la connexion série

// IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.

Serial.begin(9600);

// associe le servomoteur servopouce a la broche 2

servopouce.attach(2);

// associe le servomoteur servoindex a la broche 3

servoindex.attach(3);

// associe le servomoteur servomajeur a la broche 4

servomajeur.attach(4);

// associe le servomoteur servoannulaire a la broche 5

servoannulaire.attach(5);

// associe le servomoteur servoauriculaire a la broche 6

servoauriculaire.attach(6);

// associe le servomoteur servoauriculaire a la broche 7

servorotation.attach(7);

}

// Le programme principal s’exécute par une boucle infinie appelée Loop ()

void loop() {

//*****************************************************

//traitement et pilotage du pouce

//*****************************************************

//traitement de pilotage du pouce

valeur_potar_position_pouce=analogRead( brochepotar_de_position_pouce);

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

// attention a bien mettre la valeur du capteur de flexion dans la fonction map

// récupérer les bonnes valeurs avec le programme etalonnage dispo sur le site REDOHM

valeur_potar_position_pouce=map(valeur_potar_position_pouce,250,423,80,168);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servopouce.write(valeur_potar_position_pouce);

// La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la

// fonction Map

// Serial.println( valeur_potar_position_pouce);

delay(20);

//*****************************************************

//traitement et pilotage de l'index

//*****************************************************

//traitement de pilotage du index

valeur_potar_position_index=analogRead( brochepotar_de_position_index);

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

// attention a bien mettre la valeur du capteur de flexion dans la fonction map

// récupérer les bonnes valeurs avec le programme etalonnage dispo sur le site REDOHM

valeur_potar_position_index=map(valeur_potar_position_index,658,500,80,160);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servoindex.write(valeur_potar_position_index);

// La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la

// fonction Map

//Serial.println( valeur_potar_position_index);

delay(20);

//*****************************************************

//traitement et pilotage du majeur

//*****************************************************

valeur_potar_position_majeur=analogRead( brochepotar_de_position_majeur);

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

// attention a bien mettre la valeur du capteur de flexion dans la fonction map

// récupérer les bonnes valeurs avec le programme etalonnage dispo sur le site REDOHM

valeur_potar_position_majeur=map(valeur_potar_position_majeur,706,535,80,175);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servomajeur.write(valeur_potar_position_majeur);

// La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la

// fonction Map

//Serial.println( valeur_potar_position_majeur);

delay(20);

//*****************************************************

//traitement et pilotage du l'annulaire

//*****************************************************

//traitement de pilotage du l'annulaire

valeur_potar_position_annulaire=analogRead( brochepotar_de_position_annulaire);

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

// attention a bien mettre la valeur du capteur de flexion dans la fonction map

// récupérer les bonnes valeurs avec le programme etalonnage dispo sur le site REDOHM

valeur_potar_position_annulaire=map(valeur_potar_position_annulaire,677,486,80,175);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servoannulaire.write(valeur_potar_position_annulaire);

// La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la

// fonction Map

//Serial.println( valeur_potar_position_annulaire);

delay(20);

//*****************************************************

//traitement et pilotage de l'auriculaire

//*****************************************************

//traitement de pilotage de l'auriculaire

valeur_potar_position_auriculaire=analogRead( brochepotar_de_position_auriculaire);

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

// attention a bien mettre la valeur du capteur de flexion dans la fonction map

// récupérer les bonnes valeurs avec le programme etalonnage dispo sur le site REDOHM

valeur_potar_position_auriculaire=map(valeur_potar_position_auriculaire,325,442,80,175);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servoauriculaire.write(valeur_potar_position_auriculaire);

// La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la

// fonction Map

// Serial.println( valeur_potar_position_auriculaire);

delay(20);

//*****************************************************

//traitement et pilotage pour la rotation

//*****************************************************

//traitement pour le pilotage de la rotation

valeur_potar_position_rotation=analogRead( brochepotar_de_position_rotation);

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

valeur_potar_position_rotation=map(valeur_potar_position_rotation,0,1023,75,175);

// définit la position d'asservissement du servomoteur

// en fonction de la valeur à l'échelle

servorotation.write(valeur_potar_position_rotation);

// La fonction c-dessous peut-etre activée afin de vous aider à regler les parametres de la

// fonction Map .

// Serial.println( valeur_potar_position_rotation);

delay(20);

}

Retour au sommaire

f ) Vidéo de démonstration de l’ensemble .

Retour au sommaire

Retour à la foire aux questions