FablabSU

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.

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.

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.

(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 :