Aide pour adapter un programme à mes besoin!

Salut à tous!

Alors voila, je suis un peu nul en programmation, et j’aurai voulu savoir si une âme charitable pourrait me donner un coup de pouce!

Voila mon soucis, je veux piloter 2 servomoteurs à partir du programme de base Sweep, chaque servo moteur ayant une position mini et maxi spécifique.

j’ai commencé à ecrire mon code, mais je trouve que celui-ci devient lourd au fur et à mesure de son écriture!

Je me demandais si il existait une manière simple de l’écrire.

Voila mon code :

#include <Servo.h>

Servo myservo_1;
Servo myservo_2;
int pos_1 = 0;
int pos_2 = 0;
int posMIN_1 = 30;
int posMOY_1 = 80;
int posMAX_1 = 160;
int posMIN_2 = 50;
int posMOY_2 = 100;
int posMAX_2 = 180;
void setup()
{
    myservo_1.attach(2);
    myservo_2.attach(3);
    myservo_1.write(pos_1);
    myservo_2.write(pos_2);
    delay(2000);
}

void loop()
{
     for(pos_1 = posMIN_1 ; pos_1 < posMOY_1 ; pos_1 += 1)
      {   myservo_1.write(pos_1);
      delay(50);
      }
   for(pos_2 = posMIN_2 ; pos_2 < posMOY_2 ; pos_2 += 1)
      {   myservo_2.write(pos_2);
      delay(50);
      }
   delay(1000);
   for(pos_1 = posMOY_1; pos_1 < posMAX_1; pos_1 += 1)
      {    myservo_1.write(pos_1);
      delay(50);
      }
   for(pos_2 = posMOY_2; pos_2 < posMAX_2; pos_2 += 1)
      {    myservo_2.write(pos_2);
      delay(50);
      }
   delay(500);
   for(pos_1 = posMAX_1; pos_1 > posMOY_1; pos_1 -= 1)
      {   myservo_1.write(pos_1);
      delay(50);
      }
   for(pos_2 = posMAX_2; pos_2 > posMOY_2; pos_2 -= 1)
      {   myservo_2.write(pos_2);
      delay(50);
      }
   delay(1000);
   for(pos_1 = posMOY_1; pos_1 > posMIN_1; pos_1 -= 1)
      {   myservo_1.write(pos_1);
      delay(50);
      }
   for(pos_2 = posMOY_2; pos_2 > posMIN_2; pos_2 -= 1)
      {   myservo_2.write(pos_2);
      delay(50);
      }   
   delay(500);
}

Là, il est achevé mais j’espère qu’il y aurai plus simple!

Ce qui me gène le plus, c’est que les mouvement ne sont pas synchro!

Le servo 1 fait son 1er mouvement, puis c’est le servo 2, le servo 1 repart, puis le 2, et ainsi de suite!

J’aurai aimé que les 2 servo fassent leur mouvement en même temps!

Merci d’avance à tous

Bon voila un code qui me plait mieux, car là, les servo sont synchro!

#include <Servo.h>

Servo myservo_1;
Servo myservo_2;

int pos_1 = 0;
int posMIN_1 = 30;
int posMOY_1 = 80;
int posMAX_1 = 160;

int pos_2 = 0;
int posMIN_2 = 50;
int posMOY_2 = 100;
int posMAX_2 = 180;

void setup()
{
    myservo_1.attach(2);
    myservo_2.attach(3);
    myservo_1.write(pos_1);
    myservo_2.write(pos_2);
    delay(2000);
}

void loop()
{
   for(pos_1 = posMIN_1 , pos_2 = posMIN_2 ; pos_1 < posMOY_1 , pos_2 < posMOY_2 ; pos_1 += 1 , pos_2 += 1)
      {
      myservo_1.write(pos_1);  
      myservo_2.write(pos_2);
      delay(50);
      }
   delay(1000);
   for(pos_1 = posMOY_1 , pos_2 = posMOY_2; pos_1 < posMAX_1 , pos_2 < posMAX_2 ; pos_1 += 1 , pos_2 += 1)
      { 
      myservo_1.write(pos_1);    
      myservo_2.write(pos_2);
      delay(50);
      }
   delay(500);
   for(pos_1 = posMAX_1 , pos_2 = posMAX_2; pos_1 > posMOY_1 , pos_2 > posMOY_2 ; pos_1 -= 1 , pos_2 -= 1)
      { 
      myservo_1.write(pos_1);    
      myservo_2.write(pos_2);
      delay(50);
      }
   delay(1000);
   for(pos_1 = posMOY_1 , pos_2 = posMOY_2; pos_1 > posMIN_1 , pos_2 > posMIN_2 ; pos_1 -= 1 , pos_2 -= 1)
      { 
      myservo_1.write(pos_1);    
      myservo_2.write(pos_2);
      delay(50);
      }  
   delay(500);
}

On peut faire mieux?

Je suis surpris que ca marche

la syntaxe de la boucle for est :

for ( prologue ; condition ; increment )
{
bloc;
}

elle est équivalente à écrire :

prologue;
while ( condition )
{
bloc;
increment;
}

Si “init” et “increment” peuvent s’écrire “instruction1, instruction2, instruction3…” pour “condition” cela pose un problème.
En effet quand tu écrit que la condition vaut pos_1 < posMOY_1 , pos_2 < posMOY_2
la syntaxe est exacte mais le résultat obtenu n’est pas forcement celui que tu veux
En effet en C la valeur de “( expression1 , expression2, … )” vaut “expression1”

Donc 1 seul test est pris en compte.

Tu as de la chance car pour l’instant des 2 servos de déplacent du même nombre ensemble
pos_1 de MIN1 à MOY2 = 50 pas
pos_2 de MIN2 à MOY2 = 50 pas
idem la suite

Si ce n’est pas le cas dans le futur il va falloir réfléchir un peu plus… Dis nous ce qu’il en est

Sinon, tu n’est pas obligé de réinitialiser pos_1 et pos_2 en début de boucle si c’est pour redonner la même valeur

Voila ce que j’écrirait :

// indicateur du mouvement en cours
// on a 4 mouvements séparés 0, 1, 2 et 3
int mouv = 0;

// paramètres de chaque mouvement
// incrément a chaque pas (+1 on monte, -1 on descend)
int step[4] = { +1, +1, -1, -1 };
// nombre de pas par mouvement
int count[4} = { 50 ; 80 ; 80 ; 50 };
// delay à la fin du mouvement
int mouvdelay[4] = { 1000, 500, 1000, 500 };
// nombre de pas effectués dans le mouvement en cours
int counter = 0;

void setup()
{
myservo_1.attach(2);
myservo_2.attach(3);

mouv = 0; // On demarre sur le 1er mouvement
counter = 0; // 0 pas effectués
pos_1 = posMIN_1; // position de départ
pos_2 = posMIN_2
myservo_1.write(pos_1);
myservo_2.write(pos_2);
mouvdelay(2000);

}

void loop()
{
// a t’on terminé le mouvement en cours
if ( ++counter >= count[mouv] )
{
// mouvement courant terminé on fait la pause
delay( mouvdelay[mouv];
// puis on enchaine sur le mouvement suivant
if (++mouv > 3)
mouv = 0;
counter = 0;
}

pos_1 += step[mouv];
pos_2 += step[mouv];

myservo_1.write(pos_1);
myservo_2.write(pos_2);

delay(50);
}

C’est un premier jet qui introduit la notion d’automate.
On a un état (le mouvement en cours) et l’action a effectuer à chaque pas.
Déjà là tu as un code plus régulier.
De plus si tu veux commencer à ajouter d’autres choses dans ta boucle comme tester des capteurs ou autre info, c’est plus facile.

Est-ce que çà te semble clair ?

Ce n’est pas optimisé tant dans l’écriture (par exemple on pourrait ne pas lire step[mouv] à chaque fois mais le mettre dans une variable a chaque changement de mouvement.

Attention, je suis partit sur l’hypothèse que tous les mouvements sont relatifs par rapport à la position de départ, ce n’est pas forcément ce que tu veux
Par ailleurs ce code ne gère aussi pour l’instant que les mouvement avec un nombre de pas identique sur chaque servo.
Pour faire des mouvements différents, on peut considérer des incréments fractionnaires par exemple.

On perd encore 50ms a chaque tour mais il y a moyen de gagner cela aussi.

A+