Aller au contenu


Photo
- - - - -

[Défis] Comment commander la vitesse d'un servomoteur avec Arduino ?


  • Veuillez vous connecter pour répondre
14 réponses à ce sujet

#1 Mike118

Mike118

    Staff Robot Maker

  • Administrateur
  • PipPipPipPipPip
  • 7 905 messages
  • Gender:Male
  • Location:Anglet
  • Interests:Robotique, Entrepreneuriat, Innovation, Programmation, Résolution de problème, Recherche de solutions, Mécanique, Electronique, Créer, Concevoir

Posté 13 octobre 2016 - 03:54

Le principe du servomoteur c'est d'être asservi en position.

 

Le problème : 

 

A chaque nouvelle position "envoyé" au servomoteur, en utilisant une arduino et de la librairie servo, voir les tests par jekert ici le servomoteur va essayer d'y aller le plus vite possible, ce qui en fonction de ce qu'on fait n'est pas toujours le plus adapté ou le plus pratique. 

 

Code de base : 

//Bibliothèque :
#include <Servo.h> //Ajoute la librairie Servo

//servo1 :
Servo servo1;    //Déclare un nouveau servomoteur nommé servo1
int pos = 0;     //Position initiale du servo
#define PAUSE 2000 //Symbolise la pause en ms entre chaque mouvements du servo
#define MIN  500 // Position 0° en microseconde 
#define MAX  2500 // Position 180° en microseconde

void setup() 
{
  servo1.attach(9, MIN , MAX); //Attache servo1 au pin 9 avec MIN et MAX les extrêmes en 
}

void loop() 
{
    servo1.write(0);    // on va à 0°
    delay(PAUSE);       // On attend 2000ms = 2s ( voir valeur du define PAUSE 2000 )
    servo1.write(180);  // on va à 180°
    delay(PAUSE);       // On attend 2000ms = 2s ( voir valeur du define PAUSE 2000 )
}
 

Vidéo : 

 

[Video]

 

 

La solution théorique : 

 

Il est possible en rajoutant un peu de code et en rusant de changer la vitesse de déplacement. 

Le principe de base est simple : il faut décomposer le mouvement en une succession de plusieurs positions ! 

Supposons qu'on veuille aller de 0 à 180° on va en faite dire qu'on veut aller à 2° puis 4° puis 6° ... jusqu'à 180°

 

Apres il y a deux façon différentes de voir la chose : 

 

1) Base de temps fixe :

 

On peut fixer une base de temps et changer le nombre d'incrémentation. 
Supposons qu'on fasse une boucle récurrente toute les 500ms. 
Si dans cette boucle j'incrémente l'angle de position souhaité par le servo de 1° je vais voir le servomoteur se déplacer à une vitesse théorique de 2° par seconde (  1s = 2 * 500ms = 2* 1°  =>  2° ) 

Cependant si maintenant au lieu d'incrémenter de 1 on incrémente de 2° on va voir le servomoteur se déplacer à une vitesse de 4°/s ...  Ce qui donne bien une première façon de faire !

 

2) Incrémentation fixe : 

 

On peut aussi fixer une base d'incrémentation et changer le délais entre les incrémentation, c'est à dire changer la fréquence d'exécution de notre boucle où on va mettre à jour la position du servo !

Je décide que dans cette boucle à chaque fois j'incrémenterais la position de 1°, du coup si j'exécute cette boucle toute les 500ms je me retrouve bien avec ma vitesse de 2° par seconde, cependant si maintenant j'exécute toujours cette même action d'incrémenter de 1° mais toute les 250ms je me retrouve bien avec une vitesse de 4°/s ...

 

 

3) Le mix pour les plus téméraires ! 

 

On peut s'ammuser à faire varier à la fois la base d'incrémentation et la base de temps pour complexifier (mais aussi pour " affiner " les réglages possible en fonction du besoin  ;) ) 

 

 

Défis 

Proposer des codes arduino (accompagné d'une petite explication ,c'est à dire à minima la méthode choisie dans l'explication théorique ci dessus, et même d'une vidéo du résultat sinon c'est pas drôle  ;) )  Faîte danser vos robots! ;) 
Vous pouvez bien entendu aussi bien faire vos propres fonctions qu'utiliser une librairie si vous en avez une ;) ( ou la faire si vous êtes courageux ;) )

 

 

PS:

N'hésitez pas à proposer une façon de faire même si c'est loin d'être optimal voir même à proposer d'autres solutions théorique si vous en avez ! 
1) c'est en forgeant qu'on devient forgeron et il n'y a que ceux qui font jamais rien qui ne font jamais de bêtises mais du coup ils n'apprennent jamais rien ;) 
2) La démarche sera beaucoup plus intéressante en explicitant pour un tel code n'est pas super, et comment on peut l'améliorer.  Cela sera d'autant plus profitable pour le membre qui aura posté sont code mais aussi pour toute la communauté ;)

J'espère que l'idée vous plaira ! 


Si mon commentaire vous a plus laissez nous un avis  !  :thank_you:

Nouveau sur Robot Maker ? 

Jetez un oeil aux blogs, aux tutoriels, aux ouvrages, au robotscope  aux articles,  à la boutique  et aux différents services disponible !

 

Les réalisations de Mike118  

 

 

 


#2 Oracid

Oracid

    Pilier du forum

  • Modérateur
  • PipPipPipPipPip
  • 4 390 messages
  • Gender:Male

Posté 13 octobre 2016 - 07:34

Ça, c'est de la musique !
En musique, il y a la notion de "tempo" qui donne la vitesse d'exécution d'un morceau et il y a le "rythme" qui détermine la durée de chaque note par rapport à ses voisines.
Pour définir un rythme, on représente une note par une ronde, une blanche, une noire, une croche etc.

On pourrait donc représenter la course du servo par une succession de notes, pas forcément les mêmes, à un tempo donné.
Moi, j'opterais donc pour la 3eme solution, mais avec un paramètre supplémentaire, le rythme.

Ma séquence serait, par exemple, la suivante : accélération avec des rondes, puis des blanches, puis de noires, puis des croches pendant un certains temps, puis décélération avec des noires, des blanches et des rondes.

Pour la programmation, quelques variables tempo=delay, ronde=tempo/1, blanche=tempo/2, noir=tempo/4, croche=tempo/8
Le corps du programme étant constituer par .....un morceau de musique.
Une chaine de caractères du genre rrbbnncccccccnnbbrr.

Désolé ! J'espère que je n'ai pas dérapé là...

ps : Une chose importante, le "tempo" n'est pas forcément constant, c'est le rôle du chef d'orchestre qui décide de ralentir ou d'accélérer à certains moments.
Ma chaine vidéo YouTube : https://www.youtube....wMz-IzZqyvqEUek

#3 cocothebo

cocothebo

    Membre passionné

  • Membres
  • PipPipPip
  • 341 messages
  • Gender:Male

Posté 13 octobre 2016 - 08:56

Bonjour,

 

Si débat il ya alors moi je vais pas présenter de solutions parce que pour moi yen a surement des sous optimales mais qui au final ne feront pas le job...

 

Je m'explique, comme le décrit bien Mike118, un servomoteur "simple" type modélisme est asservi en position et seulement en position. Ici on veut passer d'un asservissement en position pour aller plus vers un asservissement en vitesse (voir après aussi accélération) et en position:

la consigne passe de "va a 152,354°" à "passe de ta position actuelle à 152,354° en 2s".

 

Dans l'absolu, je pense que ça rajoute une couche dans l'asservissement, il faut gérer la position dans le temps.

 

La solution proposée de découper avec una base de temps fixe et/ou incrémentation fixe fonctionnera très bien à un point de fonctionnement donné du système, cad par exemple servo à vide, on avec un effort de 1kg.cm ou plus ou moins.

Bref le problème vient du fait que le servomoteur n'a pas une vitesse fixe mais une vitesse qui est fonction du couple qu'il doit fournir, plus la charge est élevée plus il va lentement.

Ce phénomène doit donc être pris en compte, mais malheureusement sur un servo simple, il n'y a aucun retour, on ne peut donc pas soit savoir la position actuelle (ce qui permet d'accélérer ou ralentir pour rester dans le tempo imposé) ou encore connaitre la consommation qui est liée au couple demandé qui lui est lié à la vitesse du servomoteur.

 

Bref sans bricolage physique du servomoteur (je ne parle pas de servo style dynamixel qui fournit je crois ces infos), on aura une sorte d'asservissement qui est juste théorique, donc toute variation sur la vitesse réelle du servo fera qu'on aura une erreur non détectée, et donc un tempo complétement faux.

 

Je pense que c'est à cause de cela que la plupart des robots marcheurs (pas seulement humanoïdes) amateurs ne fonctionnent au final pas très bien, ils sont fait indirectement pour bien fonctionner à un effort donné, mais si cet effort change, ça fonctionne de moins en moins bien voir plus.

Une façon toute aussi sous optimale régulière de faire et de par exemple ne faire bouger les membres durant la marche qu'une fraction du temps, en gros on lève la patte, on l'avance, on la repose puis on attend...

Effectivement si le mouvement est moins rapide, la marche fonctionnera toujours vu q'uon avait prévu du temps "au cas ou", par contre ça limite énormément les possibilités, et je pense que ça doit même être très dur au final à dimenssioner correctement.

(Une autre façon est de franchement surdimensionner les sera, comme ça l'impact de l'effort est diminué, mais ça a aussi très vite des limites)

 

Attention, ici je ne juge absolument pas le travail sous conséquent réalisé par d'autre, loin de moi cette idée, j'essaye de comprendre pourquoi c'est si difficile à faire "correctement". Après je n'ai jamais (encore) fait de robot mobile ou autre, donc la théorie c'est joli, en pratique on commence petit (donc pas de double triple quadruple asservissements), et même comme ça on a déjà beaucoup de problèmes :)

 

 

 

Pour pas être globalement juste dans le négatif, moi si je devais faire ce genre de manip, j'essayerai de mettre en place deux choses:

  • niveau physique, le hack du servo pour avoir un retour sur sa position (facile à faire, faut juste avoir accès au potentiometre de recopie)
  • niveau soft, un fonctionnement par interruptions avec un échantilonage de la position un ordre de grandeur plus rapide que ma durée minimum souhaitée pour le système. En gros si on dit je veux gérer des déplacement jusqu'à 10ms, avoir un échantillonnage de la position du servo à 1ms, et une interruption qui arrive toute les ms aussi. L'idée après est de faie un PID ou autre pour corriger la vitesse en fonction de l'ordre de base et de la position réelle du servomoteur, en simplifiant du genre "durant cette ms je devais me déplacer de X°, en fait j'en suis à X+Y°, donc je réduis l'angle de mon prochain ordre", bien sur si dans la ms la position n'est pas atteinte, je suis au dessus des capacités de mon système, donc à voir comment réagir.

Un point important ici est le fonctionnement par interruption qui est pour moi beaucoup plus flexible et performant pour faire des taches répétitives, mettre des delay partout dans un arduino, c'est facile et rapide à mettre en place, mais ce n'est ni flexible, ni une bonne façon de faire pour quelque chose de cyclique.



#4 Oracid

Oracid

    Pilier du forum

  • Modérateur
  • PipPipPipPipPip
  • 4 390 messages
  • Gender:Male

Posté 13 octobre 2016 - 11:32

  • niveau physique, le hack du servo pour avoir un retour sur sa position (facile à faire, faut juste avoir accès au potentiometre de recopie)

Les servos Lego donnent leur position et peuvent servir comme capteur.
Ma chaine vidéo YouTube : https://www.youtube....wMz-IzZqyvqEUek

#5 ashira

ashira

    Pilier du forum

  • Modérateur
  • PipPipPipPipPip
  • 1 290 messages
  • Gender:Male

Posté 13 octobre 2016 - 12:39

Cocothebo je ne pense pas que modifier un peu le servo soit interdit dans le défi, donc si tu veux tu peux participer avec une solution qui te convient ;)

#6 Path

Path

    Made By Humans

  • Modérateur
  • PipPipPipPipPip
  • 2 391 messages
  • Gender:Male
  • Location:Paris

Posté 13 octobre 2016 - 07:19

Hypothèses :

 

On se met dans l'hypothèse à vide ou avec une charge inférieur à son max, et sans butée sur l'amplitude 0 à 180° et la commande en vitesse vise à réduire la vitesse max. On va donc supposer que le servo n'est pas gêné, qu'il fonctionne bien, qu'il est bien à la position commandée.

 

Rappel de l'énoncé :

Tout ce que sait faire un servo c'est aller à la position commandée aussi vite qu'il peut. Donc pour le faire aller moins vite, il faut le commander sur des positions intermédiaires. Comme dit dans l'énoncé.

 

Ma solution au défi ...

 

Pour résoudre le défi, je propose d'échantillonner en utilisant la boucle principale de l'arduino.

 

Une vitesse, c'est une distance (ici angulaire) parcourue en temps donné. Admettons qu'on veuille parcourir un secteur angulaire de 180° en 10s, par exemple. Soit une vitesse de 18°/s.

 

Pour expliquer, on va calculer la position toutes les secondes : 

 

Au départ (à 0s), on est à l'angle de départ (0°). => servo1.write(0);

A 1s, on est à 1x18° => servo1.write(18);

A 2s, on est à 2x18° => servo1.write(36);

...

A 10s, on est à 10x18° => servo1.write(180); // on est arrivé.

 

C'est un calcul proportionnel de la position en fonction du temps écoulé.

 

Dans le code arduino :

 

On va commencer par mémoriser l'heure de départ en ms avec la fonction

unsigned long startTimestamp = millis().

 

Dans la boucle loop(), on va utiliser la fonction map pour calculer la position en fonction du temps écoulé.

 

Temps écoulé : 

unsigned long timePosition = millis() - startTimestamp;

 

Calcul de l'angle proportionnellement au temps écoulé :

long angle = map(timePosition, 0, 10, 0, 180);

 

Avant de commander le servo, on vérifie qu'on ne sort pas des bornes 0 - 180.

servo1.write(angle);

 

A propos de la fonction map : elle fait un produit en croix.

Elle traduit proportionnellement une valeur (arg1) d'un champ (arg2 et 3) dans un autre champ (arg4 et 5).

          valeur en entrée (temps)

            v

Temps 0.....x...........10

angle 0.....x...........180

            ^

         Valeur de sortie (angle)

 

Dans ce cas, du temps en angle. Au fur et à mesure qu'on avance dans le temps, on obtient l'angle qui correspond à la vitesse voulue.

 

Avantage de cette solution : 

- n'occupe pas d'interrupetion

- le calcul est indépendant le la fréquence de l'arduino. Tant que celui-ci n'est trop occupé à faire autre chose bien sûr.

//Bibliothèque :
#include <Servo.h> //Ajoute la librairie Servo

//servo1 :
Servo servo1;    //Déclare un nouveau servomoteur nommé servo1
unsigned long startTimestamp;
unsigned long timePosition;
#define MIN  500 // Position 0° en microseconde 
#define MAX  2500 // Position 180° en microseconde

void setup() 
{
  servo1.attach(9, MIN , MAX); //Attache servo1 au pin 9 avec MIN et MAX les extrêmes en 
  startTimestamp = millis();
}

void loop() 
{
  timePosition = millis() - startTimestamp;
  long angle = map(timePosition, 0, 10, 0, 180);
  servo1.write(angle);
}

Cette méthode m'a donné satisfaction pour faire le P'tit Bob cet été. Je suis content de pouvoir le proposer au défi ^^

 

 

Source complet : http://www.robot-maker.com/forum/topic/10644-le-ptit-bob-de-path-complet/?p=72156


Podcast Made By Humans

Je cherche des volontaires de tous niveaux pour nos petites conversations entre hobbyistes.

Accès aux salles secrètes

 


#7 Telson

Telson

    Membre chevronné

  • Membres
  • PipPipPipPip
  • 975 messages
  • Gender:Male
  • Location:Punaauai - Tahiti

Posté 13 octobre 2016 - 10:35

Alors, je vois deux solutions pour résoudre ce problème.

 

Première solution : utiliser une carte qui permet de gérer la vitesse et l'accélération des servomoteurs. Très pratique dans la mesure car cela libère énormément de temps au programme pour faire autres choses.

 

Oui je sais c'est radical mais c'est vraiment très simple et très efficace....

 

Deuxième solution : gérer la totalité du déplacement des servomoteurs à partir du programme arduino.

 

Hypothèses : sur la base énoncée par @Path

 

On se met dans l'hypothèse à vide ou avec une charge inférieur à son max, et sans butée sur l'amplitude 0 à 180° et la commande en vitesse vise à augmenter/réduire la vitesse max. On va donc supposer que le servomoteur n'est pas gêné, qu'il fonctionne bien, qu'il est bien à la position commandée.

 

Secteur angulaire à parcourir : 180°.

Vitesse maxi : 180° en 10 secondes, soit 18°/s, soit 1°/56ms.

 

Ma solution au défi ...

 

3 phases :

  • 1 phase d’accélération, de 0° à 10 °. Si accélération il y a, alors la vitesse angulaire augmente
  • 1 phase à vitesse max, de 11° à 170° . Vitesse angulaire constante
  • 1 phase de décélération, de 171° à 180°. Si décélération il y a, alors la vitesse angulaire diminue

Pour augmenter/diminuer la vitesse angulaire, soit entre deux pas nous modifions le temps (la base de temps d'incrémentation) , soit sur la même base de temps d'incrémentation nous modifions l'amplitude d'un pas.

 

Souhaitant éliminer l'utilisation de la fonction delay() dans LOOP et utiliser la fonction millis() via le TIMER INTERRUPT, j'opte pour la modification de la base de temps d'incrémentation à chaque pas de 1°.

 

La fréquence du timer interrupt : TIMER0, est de 976.5625 Hz soit disons 1KHz ce qui nous donne une interruption toutes les 1ms.......

 

Admettons que le servomoteur a une vitesse de 18°/s (c’est énorme, oui mais c’est pour l’exemple ce qui donne 10 secondes pour 180° !!), soit 1°/56ms, je décide de définir la durée de mes phases ainsi :

 

  • phase d’accélération, de 0° à 10 ° = 850 ms. Le premier pas aura une durée de 112 ms, le deuxième 106 ms, ….le dernier 58
  • phase à vitesse max, de 11° à 169° = 8960 ms. Durée du pas 56 ms
  • phase de décélération, de 170° à 180°= 890 ms. Le premier pas aura une durée de 62 ms, le deuxième 68 ms, ….le dernier 116 ms

 

Soit un cylce en 10700 ms.

 

Dans le code arduino :

base_temps = 112; // initialisation de la base de temps
lastUpdate = millis(); // récupération du temps écoulé
num_pas = 1 ;// initialisation du pas
 
if((currentMillis - lastUpdate) >= base_temps) //si base_temps est atteinte 
{
if (num_pas <= 10)  //
{
base_temps = base_temps – 6; // accélération
}
else if (num_pas >= 170) 
{
base_temps = base_temps + 6; //décélération
}
else
{
base_temps = 56;
      if (num_pas >= 169)
      {
       base_temps = base_temps + 6 //petit subterfuge pour avoir le premier pas de la phase de décélération = 62 ms !!
      }
}
servo.write(num_pas); //exécution du pas
num_pas ++ ; //incrémentation du pas
}

Attention, lorsque  le servomoteur fera la course de 180° à 0° il faudra penser à initialiser base_temps = 116 et num_pas = 180.

 

Enfin, pour ce qui est d’utiliser le timer interrupt voir lien suivant :

 

https://learn.adafru...o-part-2/timers



#8 Mike118

Mike118

    Staff Robot Maker

  • Administrateur
  • PipPipPipPipPip
  • 7 905 messages
  • Gender:Male
  • Location:Anglet
  • Interests:Robotique, Entrepreneuriat, Innovation, Programmation, Résolution de problème, Recherche de solutions, Mécanique, Electronique, Créer, Concevoir

Posté 14 octobre 2016 - 08:16

Cocothebo je ne pense pas que modifier un peu le servo soit interdit dans le défi, donc si tu veux tu peux participer avec une solution qui te convient ;)

En effet ;)


Si mon commentaire vous a plus laissez nous un avis  !  :thank_you:

Nouveau sur Robot Maker ? 

Jetez un oeil aux blogs, aux tutoriels, aux ouvrages, au robotscope  aux articles,  à la boutique  et aux différents services disponible !

 

Les réalisations de Mike118  

 

 

 


#9 cocothebo

cocothebo

    Membre passionné

  • Membres
  • PipPipPip
  • 341 messages
  • Gender:Male

Posté 17 octobre 2016 - 02:10

Alors je vais faire une réponse purement théorique pour l'idée, sans prétention ni tests (ce qui si j'ai le temps me tente bien de faire sous peu).

 

Comme j' l'expliquai, moi je pense qu'il faut travailler le plus possible par interruption pour eviter les "delay" ou autres artifices pour faire une tache périodique.

Je parlais aussi de mettre en place un asservissement style PID sur la position, mais pour simplifier, je vais faire un asservissement encore plus simple.

 

Hypothèses en gros les mêmes que pour les autres.

 

Au final ma solution est une variante de celle proposée par Telson mais en essayant de gérer un peu plus finement le temps qui passe, indépendament de la vitesse du servomoteur utilisé.

 

En pratique, on a une interruption qui intervient toutes les X milli secondes et qui va récupérer l'angle du servomoteur et le comparer avec celui attendu. On aura 3 cas possibles (en fait 2 au final) :

  1. le servo est en retard, dans ce cas on continue à avancer
  2. le servo est dans les temps, idem
  3. le servo est en avance, on laisse le servo sur sa position.

Cette interruption permet donc de faire un peu un on/off de l'avancement du servo en fonction de l'angle, du temps et de la duree demandée.

 

Le code de l'interruption sera (code pas du tout vérifié, mais c'est l'idée):

int increment =  0;  //Incrémention attendue de l'angle de rotation
int anglePrevu = 0;  //Angle attendu
byte sens = 1;       //Sens de rotation, 1 ou -1

//Fonction de préparation en fonction de l'angle désiré en degré et du temps en ms
byte miseEnPlace(angle, duree)
{
  //Ici une méthode du style "map" permet de convertir la valeur analogique lue
  //au niveau du hack du servo en un angle absolu de 0 à 180°
  //mappé sur la taille d'un entier (soit de 0 à 32767)
  int angleActuel = convertir(analogRead(A0));
  
  //On converti aussi l'angle voulu sur le range d'un int
  int angleVoulu = map(angle,0,180,0,32767)

  //La rotation à faire est la différence entre les deux angles connus
  //le résultat peut être négatif (sens anti horaire) ou positif (sens horaire)
  int rotationAEffectuer = angleVoulu - angleActuel;
  
  sens = (rotationAEffectuer>=0)?1:-1;
  
  //Pour calculer de combien on doit tourner par interruption, une simple division
  //est nécessaire.
  increment = rotationAEffectuer / duree;
}

monInterruption()
{
  //On récupère l'angle actuel du servo
  byte angleActuel = convertir(analogRead(A0));
  
  //on calcule l'angle théorique qui devrait être atteint
  anglePrevu += sens * increment;
  
  //Si l'angle est > on attend, sinon on continue
  if (angleActuel > anglePrevu)
    Servo.write(map(angleActuel,0,32767,0,180));
  else Servo.write(map(anglePrevu,0,32767,0,180)); 
}

Bon c'est surement loin d'être optimal, à voir aussi si le Servo.write ne prends pas trop de temps, puisque une interruption se doit d'être la plus courte possible.

 

L'avantage de cette méthode qui est très similaire à celle de Telson, c'est qu'une fois qu'on a bien parametrer le système avec ce que l'on veut (en gros la fréquence de l'interruption), ça fonctionnera quelque soit le servomoteur sans connaitre sa vitesse (bien sur tant que la consigne reste atteignable).

A chaque interruption, le programme fera tourner le servomoteur si besoin ou attendra que ce soit nécessaire.



#10 Telson

Telson

    Membre chevronné

  • Membres
  • PipPipPipPip
  • 975 messages
  • Gender:Male
  • Location:Punaauai - Tahiti

Posté 17 octobre 2016 - 06:53

Très bon ça. Je pense vraiment qu'il devrait en sortir quelque chose de vraiment très bien de ce défis.

 

Est ce que tu pourrais expliquer cette ligne de code

sens = (rotationAEffectuer>=0)?1:-1;

 

Après ce serais pas mal un exemple de PID....Intéressant, très intéressant.



#11 cocothebo

cocothebo

    Membre passionné

  • Membres
  • PipPipPip
  • 341 messages
  • Gender:Male

Posté 17 octobre 2016 - 06:58

Salut,

 

Ah pardon des restes d'un peu de prog C.

La syntaxe Test?Vrai:Faux; c'est la version raccourcie de

if (Test)
   Vrai;
else Faux;

Donc c'est juste un test, si il est vrai tu fais ce qui est entre le ? et le :, si c'est faux tu fais ce qui est entre le : et le ;

 

Pour le PID, ya plein de littérature sur le sujet et de mémoire une librairie existe sur arduino pour en faire "facilement" (même si à programmer à la base c'est pas très dur non plus)

 

 

Edit: J'ai fait une petite faute au dessus, ce n'est pas un raccourci d'un "if else", en réalité, le ?: est un opérateur du C, comme = ou == par exemple.

Par contre les symptômes sont les mêmes, ça fait l'équivalent d'un if else.

D'ailleurs on trouve cette syntaxe sous le nom d'opérateur ternaire ou conditionnel.

 

 

Edit2: et comme c'est un opérateur, on ne peut mettre que des expressions entre ? et : ou : et ;... dans le if else, on peut mettre plus que des expressions (je sais pas le nom en français, un statement en english)


Modifié par cocothebo, 17 octobre 2016 - 07:11 .


#12 Telson

Telson

    Membre chevronné

  • Membres
  • PipPipPipPip
  • 975 messages
  • Gender:Male
  • Location:Punaauai - Tahiti

Posté 17 octobre 2016 - 07:03

Ok, merci pour les explications.



#13 Guigz65

Guigz65

    Membre occasionnel

  • Membres
  • Pip
  • 137 messages
  • Gender:Male
  • Location:33 - Nord Gironde

Posté 19 octobre 2016 - 09:25

Je suis bien incapable d'émettre une hypothèse par contre c'est clair que cela m'interesse pour mon bipède et que je vais essayer plusieurs de vos solutions !

 

Merci les gars ! :clapping:



#14 Mike118

Mike118

    Staff Robot Maker

  • Administrateur
  • PipPipPipPipPip
  • 7 905 messages
  • Gender:Male
  • Location:Anglet
  • Interests:Robotique, Entrepreneuriat, Innovation, Programmation, Résolution de problème, Recherche de solutions, Mécanique, Electronique, Créer, Concevoir

Posté 24 octobre 2016 - 09:37

Il reste encore des personnes qui planchent sur le problème et qui compte encore proposer un façon de faire ou pas ? =) 


Si mon commentaire vous a plus laissez nous un avis  !  :thank_you:

Nouveau sur Robot Maker ? 

Jetez un oeil aux blogs, aux tutoriels, aux ouvrages, au robotscope  aux articles,  à la boutique  et aux différents services disponible !

 

Les réalisations de Mike118  

 

 

 


#15 Telson

Telson

    Membre chevronné

  • Membres
  • PipPipPipPip
  • 975 messages
  • Gender:Male
  • Location:Punaauai - Tahiti

Posté 24 octobre 2016 - 11:10

C'est bon pour moi.






0 utilisateur(s) li(sen)t ce sujet

0 members, 0 guests, 0 anonymous users