Idée : Faire un poisson (une nageoire)

IMT Atlantique 2024 – Groupe 1 : Ditsouga, Maxence, Quentin, Antoine

Vient de : https://robotics24.net/blog/soft-robotics-examples-research-and-applications/

Pourquoi ?

Les chercheurs en biologie marine rencontrent souvent des limites quand il s’agit d’observer la faune. En effet, pour éviter d’effrayer les autres poissons et la faune marine une équipe du MIT a développé un robot poisson équipé d’une caméra et basé sur le biomimétisme.

Dans ce projet nous tentons de reproduire le mouvement de la queue du poisson.

Comment ?

Utiliser 2 parties “muscles” rétractables en silicone qui se contractent en alternance pour tirer le bout de la queue du poisson d’un côté puis de l’autre. Contrôler le tout avec une seule pompe qui gonfle un muscle puis l’autre avec un circuit pneumatique fermé.

On utilise la pompe à eau 12v qui peut changer de sens d’aspiration.

Deuxième possibilité de type de muscles

  • Muscles artificiels de type McKibben

Le principe de fonctionnement est le même que pour les muscles en silicone.

Plan :

  • Faire 2 muscles artificiels (en silicone, ou de type McKibben)
  • Faire un circuit de contrôle de la pompe (arduino) , avec éventuellement des capteurs de flexion sur la queue pour la commande.

*Impression en 3D de la nageoire caudale et du corps du poisson

Etape de la mise en place :

Réflexion sur le muscle à utiliser :

  • Tout d’abord, on a pensé au muscle en silicone pour les mouvement de la queue mais le moule du modèle donné par le site (https://softroboticstoolkit.com/book/pneunets-downloads) ne nous a pas donné de résultat satisfaisant. En effet, a cause la présence de bulles d’air et de la plaque du dessous pas assez rigide , des trous laissaient s’échapper l’air et empêchaient le gonflement du muscle (nous avons changé d’approche car refaire un autre muscle était très long puisqu’il faut attendre qu’il sèche).

  • On a donc décidé d’intégrer des muscles avec des gaines (type McKibben). Pour fabriquer nos muscles, on a enfilé un ballon dans la gaine : lorsque le ballon se gonfle, la gaine se rétracte et inversement. On a donc un muscle contrôlable avec une pompe.

 

      • On a juste eu quelques problèmes quand le ballon était trop gonflé

Choix des pompes

  • On a initialement pensé à utiliser une pompe à air classique (à piston), cela n’a pas marché car la pompe n’était pas réversible ce qui nous a empêché de remplir et vider successivement le muscle.
  • Nous avons utilisé une pompe à galet qui est plus efficace avec de l’eau (mais reste efficace avec de l’air) pour remplir et vider le ballon

  • Les pompes se dégonflent puis se gonflent :

Capteur de flexion :

    • Le capteur de flexion nous permet de savoir à quel moment la flexion de la nageoire est terminé et de passer à une nouvelle flexion (changement de sens de la nageoire). Il est nécessaire d’avoir 2 capteur parce qu’il sont sensible uniquement dans un sens de pliure.
    • Ces capteurs sont des capteurs analogique relié comme ci dessous :

  • Le montage ensemble est le suivant, il fonctionne avec le code arduino :

 

 

 

Impression 3D :

Dans un premier temps, nous avons fait un modèle de nageoire étroite.

 

Cependant, les mouvements de la queue étant plutôt lents, nous avons à la place opté pour une nageoire moins réaliste mais plus large pour avoir une meilleure surface de contact avec l’eau (et donc permettre au poisson d’avancer).

L’impression du corps n’a pas été concluante à cause de mauvais réglages (parois trop fines).

 

Montage final avec la queue :

 

Schéma du montage électrique :

Code Arduino :

//Pompes
int E2 = 5;
int M2 = 4;
int tau = 1000; //Durée en ms entre chaque alternance gonflage/dégonflage en mode "normal"

//Commande
int Bouton = 3;
int Etat = 1; //0 = mode normal , 1 = mode remplissage , 2 = mode vidange
int etat_bouton = 0;
int timer = 0;

//Capteurs de flexion
const int Capteur_droit = A1;
const int Capteur_gauche = A0;
int sensorValueD = 0;        // value read from the pot
int sensorValueG = 0;        // value read from the pot
#include <Servo.h>
Servo index;

void setup()
{
    pinMode(M2, OUTPUT);
    pinMode(Bouton,INPUT);
    Serial.begin(9600);
}

void loop()
{
  etat_bouton = digitalRead(Bouton);

  if (etat_bouton == LOW) {
    //On arette la pompe le temps de connaitre le mode souhaité
    digitalWrite(E2,LOW);
    //Mesure temps d'appui sur le bouton
    while (etat_bouton == LOW){
      timer += 20;
      delay(20);
      etat_bouton = digitalRead(Bouton);
    }
    //Si appui long (plus de 2s) on change de mode entre normal(0) et remplissage(1)
    if (timer>=2000){
      Etat = (Etat==0);
    }
    // Sinon si on est en mode 1 ou 2 on change de mode entre 1 et 2
    else {
      if (Etat != 0){
        Etat = 1*(Etat==2) + 2*(Etat==1);
      }
    }
    timer = 0;
  }
  Serial.println(Etat);
  // On fait tourner la pompe selon son mode de fonctionnement
  rotation_pompe(Etat);
  // On attend 20 ms avant une nouvelle boucle
  delay(20);
}

// Déclenche les pompes avec le bouton selon le sens de rotation/ mode souhaité
void rotation_pompe(int nouvel_etat) {
  //Modes pour vider/remplir le ballon
  if (nouvel_etat==1){
     digitalWrite(E2,HIGH);
     digitalWrite(M2,LOW);//gonfler
  }
  else {
    if (nouvel_etat==2){
      digitalWrite(E2,HIGH);
      digitalWrite(M2,HIGH);//dégonfler
    }

    else{
      //Mode normal alternance
      digitalWrite(E2,HIGH);
      digitalWrite(M2,HIGH);
      delay(tau);
      digitalWrite(M2,LOW);
      delay(tau);

      // //Mode normal avec capteurs de flexion (décommentez ci-dessous et commentez le mode normal au dessus)
      //   // read the analog in value:
      //   sensorValueD = analogRead(Capteur_droit);
      //   sensorValueG = analogRead(Capteur_gauche);

      //   digitalWrite(E2,HIGH);

      //   if (sensorValueD > 820) {  // 820 correspond au seuil à partir la flexion du capteur est suffisante pour changer de sens
      //     digitalWrite(M2,HIGH);
      //   }
      //   if (sensorValueG > 820) {
      //     digitalWrite(M2,LOW);
      //   }
    }
  }
}

Pistes d’amélioration :

  • Refaire une structure en impression 3D pour le corps du poisson et intégrer les pompes
  • Faire une nageoire dorsale orientable pour contrôler le poisson
  • Ajouter un “ballast” qui empêche le poisson de couler
  • Mieux étanchéifier , utiliser des pompes plus puissantes ou des muscles moins larges.

Voici une version du capteur étanchéifiée avec du silicone que nous n’avons pas eu le temps de tester.

Etude en parallèle


L’idée était d’automatiser un mouvement d’accordéon, de propulsion.

 


const int springPin1 = A1;  // Broche de contrôle du relais pour le premier ressort
const int springPin2 = A2;  // Broche de contrôle du relais pour le deuxième ressort

void setup() {
  pinMode(springPin1, OUTPUT);
  pinMode(springPin2, OUTPUT);
}

void loop() {
  // Activer le courant sur le premier ressort
  digitalWrite(springPin1, HIGH);
  delay(2000); 
  // Attendre 2 secondes

  // Désactiver le courant sur le premier ressort
  digitalWrite(springPin1, LOW);
  delay(10000);

  // Activer le courant sur le deuxième ressort
  digitalWrite(springPin2, HIGH);
  delay(2000);  // Attendre 2 secondes

  // Désactiver le courant sur le deuxième ressort
  digitalWrite(springPin2, LOW);
  delay(10000);
}

Problèmes rencontrés :
_ Définition du temps de latence adéquat pour laisser le ressort à mémoire de forme refroidir pour permettre le mouvement inverse.
_ Elongation dans un seul sens

Potentielles solutions :
_ Essayer de changer le générateur avec un meilleur calibrage
_ Installer un bouton qui va permettre d’ouvrir et de fermer le passage du courant sur chacun des ressorts à mémoire de forme.

Ce que j’ai appris :
_ Bases de Arduino, en passant par le codage et le montage
_ Ouverture d’esprit sur sur les métiers