==== Main robotique commandable ====
Ce projet vise à réaliser une main robotique commandable à distance par le biais de cartes Arduino. L'utilisateur
commande la main robotique à l'aide d'un gant équipé de capteurs et la transmission de données est effectuée par Bluetooth.
__Projet réalisé par :__
* Fabrice Vailhen (fabrice.vailhen@hotmail.fr)
* Gabriel Chatelain (gabriel.chatelain@googlemail.com)
=== Les outils ===
Pour ce projet, nous avons recours à diverse technologie pour, d'une part, modéliser les pièces nécéssaire à imprimer en 3D et d'autres part, pour les mettre en mouvement.
Cette partie a pour but d'introduire ces différents outils.
==OpenScad==
OpenSCAD est un logiciel de modélisation tridimensionnelle rudimentaire qui fonctionne à la fois sous Linux, Mac OS et Microsoft Windows. Il se focalise plus sur l'aspect Conception Assisté par Ordinateur (CAO) que sur l'aspect artistique de la modélisation 3D (contrairement à un logiciel comme blender).
Ce logiciel se présente sous la forme d'un éditeur de texte, d'un aperçu de la pièce en cours de modélisation et d'une console. En écrivant du code dans la partie éditeur de texte, on modifie la pièce que l'on modélise.
{{ :wiki:projets:te_le_chargement.jpeg?516×431|Le logiciel OpenScad }}
Pour plus de détaille je vous recommande de lire ces pages :
* https://en.wikipedia.org/wiki/OpenSCAD?oldformat=true (page wikipedia)
* http://www.openscad.org/documentation.html (site officiel)
==Arduino==
A l'heure où l'utilisation de microcontrôleurs est en pleine essor, il n'est pas forcément évident de les utiliser pour le grand publique. Cela requière de se plonger dans des datasheet diverses et de connaitre l'architecture et la syntaxe du mircocontrôleur que l'on souhaite utiliser. Pour palier à cela, une équipe de développeurs italiens a eu l'idée de rendre la programmation de ces microntrôleurs plus simple en construisant une carte facile d'accès et une bibliothèques de programmation plus intuitive. Ils ont rencontrés un grand succès et l'utilisation des cartes Arduino est aujourd'hui très répandu dans le monde du DIY (Do It Yourself). Par ailleurs, ces cartes font office d'une bonne introduction si l'on souhaite se spécialiser dans le domaine de l'électronique, notamment dans le domaine des microncontrôleurs.
Pour utiliser ces cartes, on écrit un code informatique dans l'IDE (Integrated Development Environment) d'Arduino, puis on le "téléverse" dans la carte Arduino, c'est à dire qu'on l'envoi dans le microncontrôleur.
{{ :wiki:projets:arduinouno_r2_front450px.jpg?400|l'Arduino Uno }}
Pour plus de détaille je vous recommande de lire ces pages :
* https://fr.wikipedia.org/wiki/Arduino?oldformat=true (page wikipedia)
* https://www.arduino.cc/ (site officiel)
==Les servomoteurs==
Les servomoteurs sont des moteurs électriques qui ont la particularité de ne tourner que de 180° et d'être facilement asservi en position. Ils sont donc parfait pour les projets de robotique comme le notre.
{{:wiki:projets:10345_1_.jpg?300|un servomoteur}}
(en construction)
=== Les différentes étapes de ce projet ===
* __étape n°1__ Mise en place des différents outils numériques et organisation du projet (wiki, digramme de Gantt, ...)
* __étape n°2__ Création de prototype pour la main commandée
* __étape n°3__ Tests de positionnements simple d'un servomoteur avec un potentiomètre
* __étape n°4__ Créations et analyse de capteurs de flexions
* __étape n°5__ Insertions des capteurs de flexion dans les montages précédents
* __étape n°6__ Mise en place de la liaison Bluetooth
* (en construction ...)
== étape n°1 ==
nous avons recours à plusieurs outils pour organiser au mieux notre projet :
Tout d'abord, nous avons tenté d'estimer le temps nécéssaire à la réalisation du projet en le divisant en plusieurs étapes et le représentant sous la forme d'un diagramme de Gantt. Cela nous a donc donné un certain nombre de dates clé qu'il nous faut respecter afin de pouvoir présenter le projet à la date prévue.
Nous avons également réparti les tâches de la manière la plus équitable possible afin d'avancer au plus vite.
== étape n°2 ==
Pour cette étape nous avons proposé deux types de prototypes pour réaliser la main commandée :
* une main entièrement imprimée en 3D
* un main fabriquée à l'aide d'un gant en latex rempli de gélatine.
Fabrice à entièrement écrit le code OpenScad afin d'imprimer la main 3D. Nous avons pour le moment quelques doigts fonctionnels. Ce prototype est donc presque fini.
Voici les codes utilisés :
* pour les accroches des doigts
module accroche_doigt_unique(){
module accroche_doigt(){
union(){
difference(){
union(){
// Cube de base
translate([-1,0,0]) cube([15,10,18]);
// Bout cylindrique avant
translate([-1,5,3]) cylinder(d=10,$fn=20,h=12);
// Accroche fil
difference(){
translate([11,10,4]) cube([8,6,10]);
translate([11,10,6]) cube([8,4,6]);
}
}
// Avant coupé
translate([-10,0,-1]) cube([15.5,10,7]);
translate([-10,0,12]) cube([15.5,10,7]);
// Cylindre Avant
translate([-1,5,-1]) cylinder(d=5,$fn=20,h=20);
// Ouverture avant
translate([-7,3.5,0]) cube([6.5,3.2,18]);
// Tranchée élastique
translate([-10,0,7]) cube([21,1,4]);
translate([8,0,4]) cube([3,1,10]);
}
// Accroche elastique
translate([10.5,-5,6]) cube([8,6,6]);
translate([10.5,-5,3]) cube([10,3,12]);
}
}
union(){
difference(){
translate([0,-3,0]) cube([24,24,10]);
translate([0,-3,3]) cube([30,90,3.2]);
// Trous accroche
translate([19,15,-1]) cylinder(d=5,$fn=20,h=20);
translate([19,3,-1]) cylinder(d=5,$fn=20,h=20);
// Tranchée élastique
rotate([90,0,0]) translate([2,0,-14]) cube([3,1,10]);
rotate([90,0,0]) translate([0,0,-11]) cube([3,1,4]);
}
rotate([90,0,0]) translate([-5.5,0,-18]) accroche_doigt();
}
}
accroche_doigt_unique();
* pour les phalanges des doigts
module accroche(){
difference(){
rotate([0,90,0]) cylinder(d=10,$fn=20,h=2);
rotate([0,90,0]) cylinder(d=7,$fn=20,h=3);
translate([0,-10,10]) rotate([0,90,0]) cube([20,10,10]);
}
}
module phalange(e,l){
union(){
difference(){
union(){
// Cube de base
translate ([0,0,e/2]) cube([50*l,10,18-e]);
// Bout cylindrique avant
translate([0,5,6]) cylinder(d=10,$fn=20,h=6);
// Bout cylindrique arrière
translate([50*l,5,0]) cylinder(d=10,$fn=20,h=18);
// Bout rectangulaire avant
translate([-5,0,6]) cube([5,5,6]);
// Bout rectangulaire arrière
translate([50*l,0,0]) cube([5,5,6]);
translate([50*l,0,12]) cube([5,5,6]);
// Blocage articulation arrière
translate([48*l,-1,0+e/2]) cube([8,1,18-e]);
// Accroche fil
translate([35*l,8,18/2]) accroche();
// Bloque 90°
difference(){
union(){
translate([5,10,0+e/2]) cube([3,2,6-e/2]);
translate([5,10,18-e/2-(6-e/2)]) cube([3,2,6-e/2]);
}
translate([10,15,0]) cylinder(d=10,$fn=20,h=18);
}
}
// Avant coupé
translate([-1,0,-1]) cube([6.5,10,7]);
translate([-1,0,12]) cube([6.5,10,7]);
// Arrière coupé
translate([40*l,-1,5.5]) cube([15,11,7]);
// Cylindre Avant
translate([0,5,-1]) cylinder(d=5,$fn=20,h=20);
// Enlève cylindre de côté
translate([40*l,-1,-1+e/2]) cube([15,11,1]);
translate([40*l,-1,18-e/2]) cube([15,11,1]);
// Ouverture avant
translate([-6,3.7,0]) cube([6.5,2.5,18]);
// Tranchée élastique
translate([-10*l,0,7]) cube([55*l,2,4]);
translate([-7*l,0,7]) cube([4*l,5,4]);
}
// Accroche cylindrique arrière
translate([50*l,4,5]) cylinder(d=4,$fn=20,h=10);
}
}
module phalange_finale(e,l){
union(){
difference(){
union(){
// Cube de base
translate ([0,0,e/2]) cube([50*l,10,18-e]);
// Bout cylindrique avant
translate([0,5,3]) cylinder(d=10,$fn=20,h=12);
// Bout cylindrique arrière
translate([50*l,5,0]) cylinder(d=10,$fn=20,h=18);
// Bout rectangulaire avant
translate([-5,0,3]) cube([5,5,12]);
// Bout rectangulaire arrière
translate([50*l,0,0]) cube([5,5,6]);
translate([50*l,0,12]) cube([5,5,6]);
// Blocage articulation arrière
translate([48*l,-1,0+e/2]) cube([8,1,18-e]);
// Accroche fil
translate([32*l,8,18/2]) accroche();
translate([0,8,18/2]) accroche();
}
// Avant coupé
translate([-1,0,-1]) cube([5,10,4]);
translate([-1,0,15]) cube([5,10,7]);
// Arrière coupé
translate([40*l,-1,5.5]) cube([15,11,7]);
// Enlève cylindre de côté
translate([40*l,-1,-1-e/2]) cube([15,11,1+e]);
translate([40*l,-1,18-e/2]) cube([15,11,1+e/2]);
}
// Accroche cylindrique arrière
translate([50*l,4,5]) cylinder(d=4,$fn=20,h=10);
// Accroche élastique
translate([0,0,8]) cube([2,2,2]);
translate([-0.5,0,7.5]) cube([3,1,3]);
}
}
module doigt_majeur(){
phalange(0,6/5);
translate([-35,0,0]) phalange(2,3.5/5);
translate([-63,0,0]) phalange_finale(4,2.8/5);
}
module doigt_index(){
phalange(0,1);
translate([-30,0,0]) phalange(2,3/5);
translate([-55.5,0,0]) phalange_finale(4,2.5/5);
}
module doigt_petit(){
phalange(0,4/5);
translate([-25,0,0]) phalange(2,2.5/5);
translate([-45,0,0]) phalange_finale(4,2/5);
}
module doigt_pouce(){
phalange(0,4/5);
translate([-35,0,0]) phalange_finale(4,3.5/5);
}
//rotate ([0,-65,0]) translate([-50,0,-120]) doigt_pouce();
//rotate ([0,-2,0]) translate([0,0,-25]) doigt_index();
//rotate ([0,2,0]) translate([0,0,25]) doigt_index();
//translate([-10,0,0]) doigt_majeur();
//rotate ([0,3,0]) translate([10,0,50]) doigt_petit();
phalange(0,1);
translate([0,0,20]) phalange(2,3/5);
translate([0,0,40]) phalange_finale(4,2.5/5);
la première version de la main en latex n'a pas encore aboutie: les doigts ne se plient pas dans le bon sens et le prototype ne respecte donc pas du tout son cahier des charges. Des modifications sont donc encore à faire.
== étape n°3 ==
avec les "morceaux" de prototype de la main 3D, nous avons pu réaliser quelques tests avec une carte Arduino Uno et un servomoteur. Le résultat est encourageant pour le reste du projet. le code utilisé est le suivant :
#include "Servo.h"
const int ctrl_pouce = 0, ctrl_indexe= 0, ctrl_majeur= 0, ctrl_annulaire= 0, ctrl_oriculaire= 0;
Servo pouce, indexe, majeur, annulaire, oriculaire;
void setup()
{
indexe.attach(2);
Serial.begin(9600);
}
void loop()
{
int val_indexe = analogRead(ctrl_indexe);
int angle = map(val_indexe, 0, 1023, 0, 180);
indexe.write(angle);
Serial.println(angle);
delay(100);
}
le prototype de la main est à présent presque terminé et marche parfaitement. Voici quelques photos de ce que nous avons accompli pour le moment :