[ARDUINO] Asservissement grâce au PID

D’accord merci beaucoup pour tes explications et ton analyse du graphique qui sont très claires !

Bonjour !

Je reviens vers vous (@Aabu et @Jacen notamment ^^) après avoir un peu avancé.

Mon professeur va se charger de trouver la fonction de transfert de notre moteur(un moteur brushless).

Mais du coup pour s’en servir, quand on l’aura, il faudrait que le PID renvoie une tension comme commande. Et j’aurais 2 questions  :

• Vaut-il mieux convertir l’angle en tension dès le début ou convertir la commande ?

• Comment faire ? Nous avions d’abord pensez à faire un produit en croix pour trouver l’angle après avoir envoyé une certaine tension mais ne faut il pas prendre en compte le temps ? (On rechercherait l’angle parcourue par le drone pendant un temps t lorsque l’on envoie une certaine tension aux moteurs

Merci d’avance pour votre réponse !

Merci de ta réponse !

Je ne pensais pas du tout que ma commande était déjà une tension .

J’avais trouvé un bon schéma bloc en cours (qui ressemble à ce que l’on veut faire) mais impossible de le retrouver, donc en voici un autre mais qui me parait un peut moins bien  :

Je dois avouer que la suite de notre projet me parait un peu obscur du côté de l’asservissement :

• Si j’ai bien compris avec mes recherches, la fonction de transfert (que va chercher notre professeur) va me servir à convertir la commande en "tension" pour le moteur (donc abaisser la valeur de notre commande ? etc ?), donc on aurait ensuite juste à envoyer le résultat renvoyé par cette fonction et cela serait bon ?

• Mais même avec cette fonction de transfert qui s’occuperait selon moi d’adapter la commande aux moteurs, je ne vois pas trop quoi faire ensuite : je reparle ici de la vidéo du début de mon sujet qui montre ce que l’on veut faire, il y a deux moteurs, comment savoir lequel contrôler ?

Le matériel d e notre projet pour le moment : un banc pouvant bouger verticalement (voir vidéo), 2 moteurs (un de chaque côté) avec hélices + ECS (convertisseur), accéléromètre/gyroscope (pour récupérer l’angle), une carte Arduino.

Dans notre projet, je suis celui charger de l’asservissement par PID et je suis celui qui à le plus du mal (je n’ai fait que le calcul de la commande pour l’instant avec votre aide), si j’arrive à finir le PID notre projet seras quasiment finis…

Si j’ai bien compris avec mes recherches, la fonction de transfert (que va chercher notre professeur) va me servir à convertir la commande en "tension" pour le moteur (donc abaisser la valeur de notre commande ? etc ?), donc on aurait ensuite juste à envoyer le résultat renvoyé par cette fonction et cela serait bon ?

La fonction de transfert du moteur ne va pas te servir à transformer la commande en tension. C’est une représentation mathématique de comment ton moteur (ou esc+moteur, ça dépend de ce qu’on fait) transforme une grandeur d’entrée en autre chose. En fait, tu n’as pas vraiment besoin de la connaître pour régler ton PID avec une méthode essais-erreurs sur le système réel.

il y a deux moteurs, comment savoir lequel contrôler ?

Les deux ! Ce qui va faire pencher la balance, c’est la différence de poussée entre les deux moteurs. Donc ce que tu dois contrôler en toute rigueur, c’est le déséquilibre : si tu lèves trop d’un côté, il faut laisser tomber ce côté et tirer d’autant l’autre. Autrement dit, il faudra mettre plus de patate d’un côté, et moins de l’autre. On ne connaît pas comment est fait concrètement ton système d’ailleurs, un schéma serait sympathique, ça peut nous aider à t’aider. Note bien qu’il y a différentes solutions si ton système est attaché, vu que tirer plus fort sur les deux côtés ne fait rien, donc il faudra choisir à quoi correspond la poussée moyenne, pour pas que les moteurs tirent comme des dingues.

Aussi n’oublie pas ce qu’à dit @Jacen, ça pourrait être important à ce stade :

Dans notre projet, je suis celui charger de l’asservissement par PID et je suis celui qui à le plus du mal (je n’ai fait que le calcul de la commande pour l’instant avec votre aide), si j’arrive à finir le PID notre projet seras quasiment finis…

À mon avis, l’asservissement sur un projet de ce type est de loin la partie la plus compliquée, surtout pour un débutant ! Demande un peu d’aide à tes collègues, que tu sois pas tout seul à galérer.

Ah mince… Il faudra voir ce matin car mon professeur à peut-être passé son temps à la chercher, donc ça serais bien de l’utiliser si possible…

• Du coup vous me reconseillez de faire des tests pour voir comment les moteurs réagissent en fonction de la commande renvoyée par le PID ?

• Je verrai pour faire une photo du système lundi car il faut que l’on changé quelques trucs. Mais si j’ai bien compris il faudra d’abord faire tourner l’un des moteurs et si la commande du PID ne s’améliore pas arrêter ce moteur et faire tourner l’autre ?

• Si la commande est une différence comment redistribuer à chaque moteurs la bonne poussée ? Tests ? (Refaire un graphique du signal PWM envoyé par les ECS en fonction de la commande ?

• Oui je vais voir avec eux mais ils sont aussi occupés. Et dans le cahier des charges d’un projet en SI, les rôles sont attribués et on est censé faire que notre partie, mais bon notre professeur ne diras rien ^^.

• Pour le schéma je vais essayer d’en faire un ce week-end (préparée vos yeux 😂) et je prendrais une photo du système Lundi.

J’ai pu le prendre en photo aujourd’hui Du coup ce que vous verrez en photo seras relié à une carte Arduino et posait sur un pied :

Merci pour la photo, je vois bien comment votre installation est constituée maintenant.

Du coup vous me reconseillez de faire des tests pour voir comment les moteurs réagissent en fonction de la commande renvoyée par le PID ?

Honnêtement, il y a un stade où il faut mettre les mains dans le cambouis et arrêter de réfléchir dans le vent.

Mais si j’ai bien compris il faudra d’abord faire tourner l’un des moteurs et si la commande du PID ne s’améliore pas arrêter ce moteur et faire tourner l’autre ?

Pas forcément l’arrêter, mais l’un devra tourner moins vite que l’autre. Le plus simple, c’est de faire en sorte que le PID contrôle l’écart de poussée entre les deux moteurs. Si tu choisis cette solution, tu dois définir une méthode pour choisir la poussée de chaque moteur étant donné l’écart entre les deux. Je reste un peu vague, parce qu’il faut que tu le fasses toi-même, mais de manière imagée, si tu veux un écart de « poussée » de 5, tu peux pousser 10 d’un côté et 5 de l’autre ou encore 15 d’un côté et 10 de l’autre, tu vois le principe.

Si la commande est une différence comment redistribuer à chaque moteurs la bonne poussée ? Tests ? (Refaire un graphique du signal PWM envoyé par les ECS en fonction de la commande ?

À un moment donné oui, il faut tester. Est-ce que tu as déjà essayé de faire tourner tes moteurs (même sans PID) ? Est-ce que tu as fait des tests pour voir ce qu’il se passe quand tu donnes des consignes de vitesse différentes aux moteurs ? Est-ce que tu as moyen de « jouer au PID » en essayant de faire la régulation manuellement ? Toutes ces choses devraient t’aider à comprendre où aller au lieu de rester collé dans la théorie.

Merci beaucoup pour ton aide !

Notre système de maintien du drone étant quasiment fini je vais pouvoir faire des tests sur le modèle final. Je vais essayer d’avancer en faisant des tests.

Oui, on déjà essayer de faire tourner les moteurs. J’attendais que tout soit construit avant de commencer des tests avec le PID.

Je vais dire à mon professeur de ne pas regarder pour la fonction de transfert puisqu’elle ne servira pas dans mon cas si j’ai bien compris.

Re,

Je suis désolé de déjà revenir vers vous @Aabu, mais je n’ai pas trop compris l’une des choses que vous m’avez dit :’(.

Grâce à cela dans mon code :

    if (cmd < 0) cmd = 0 ;
    else if (cmd > 255) cmd = 255 ;

J’obtiens bien une commande comprise entre 0 et 255 (c’est déjà ça de fait…).

Mais vous me conseillez de travailler en différence de poussée entre les 2 moteurs mais je ne vois pas du tout comment faire :’(… : que faut-il faire pour trouver cette différence de poussée (je pense avoir compris pour tester de pousser de x d’un côté et de y de l’autre) et le lien avec le PID du coup… Auriez-vous une idée ? …

Merci beaucoup pour tes explications @Aabu ! Effectivement elle m’a débloquée un peu, mais vraiment pas beaucoup car je me retrouve bloqué dans mes calculs :’(.

Je ne vois pas trop le système d’équation que je dois résoudre pour exprimer p_g et p_d en fonction de Delta p et p_m…
J’ai réussi (bon ce n’était pas bien compliquer, mais c’est tout ce que j’ai réussi à faire…) à faire ça :

p_m = 1/2 * (Delta p)

Delta p = 2p_m

p_g = (Delta p) + p_d = 2p_m + p_d

p_d = -(Delta p) + p_g = -2p_m + p_g

Et c’est tout (J’ai essayer d’exprimer toutes les variables selon les autres mais il me manque le système…)

Et j’aurais une petite question : Dans mon cas, Delta p correspond à la commande du PID, non ?

EDIT : Grosse bêtise de recopiage de ta formule : j’avais mis un - dans la formule de la poussée moyenne, je ne pouvais pas trouver…

Le système est le suivant :

$\Delta p = p_g- p_d$

$p_m = \frac{p_g + p_d}{2}$

Tu peux le résoudre avec un système de calcul formel, si tu le souhaites. On n’est pas en cours de maths.

Et j’aurais une petite question : Dans mon cas, Delta p correspond à la commande du PID, non ?

Oui.

Merci beaucoup pour ton aide @Aabu ! J’avais essayé de résoudre ce système mais j’avais obtenu des résultats qui me semblait bizarre, et je viens de me rendre compte que j’avais mis un moins partout pour la moyenne … Du coup c’est bon je les résolus (à la main, pour le plaisir :)) :

• p_g = 1/2 * (Delta p) + p_m
• p_d = p_m + 1/2 * (Delta p)

C’est partie pour la suite  : Imaginons que j’ai une commande de 148, elle est dans l’intervalle 0–255 donc je peux l’utiliser directement. Ainsi, Delta p = 140 mais p_m = ?. Je pense savoir ce que je vais devoir rajouter dans mon programme ensuite (tu m’as bien aidé :)) donc il me reste juste à trouver comment calculer p_m, sans connaître p_g et p_d du coup.

Tu as un problème de signes dans ta solution. Avec ce que tu as écrit, les deux moteurs ont la même poussée.

$p_m$ ne se calcule pas, c’est à toi de choisir sa valeur. Dans un drone complet, ce serait une sortie du contrôleur d’altitude, mais tu n’en as pas.

Effectivement @Aabu, c’est : p_d = p_m - 1/2 * (Delta p).

D’accord, donc par exemple, je pourrais prendre p_m = 4984845 ? Et il n’y a rien à changer selon la valeur de p_m ?

Faut quand même vérifier que ta moyenne a du sens. C’est la moyenne des poussées… Ça te paraît raisonnable ton choix ?

D’accord @Aabu p_m = 100 ?

Par exemple. Le mieux reste de tester !

Bonne idée, je vais faire ça ! (des que l’on a projet, c’est à dire je ne sais pas trop quand, peut-être Samedi). Je te tiendrai au courant !

Merci énormément pour ton aide @Aabu en tout cas !

PS : Pour quelle raison, la valeur de la poussée moyenne peut-elle être choisie "aléatoirement" ? (pour que je puisse l’expliquer ;))

EDIT : Mon programme "final" :

////////////////////////////////////
// Les bibliothèques nécessaires  //
////////////////////////////////////

#include <Wire.h>
#include <ADXL345.h>

#define MOT_G ... // A REMPLACER
#define MOT_D ... // A REMPLACER

/* Variables */

double pitch = 0.00 ;

ADXL345 adxl ; // Variable adxl en relation avec la bibliothèque ADXL345 

float erreur = 0 ; // Erreur = consigne - mesure

float consigne = 90 ; // Valeur à atteindre (modifiable)

const float Kp = 10 ; // Constante du paramètre proportionnel
const float Ki = 0.4 ; // Constante du paramètre intégral
const float Kd = 20 ; // Constante du paramètre dérivée

float erreur_precedente = 0 ;
float somme_erreurs = 0 ;
float variation_erreur = 0 ;

float mesure = 0 ;

int poussee_g = 0 ; // Poussée du moteur gauche (à déterminer)
int poussee_d = 0 ; // Poussée du moteur droit (à déterminer)

float commande = 0 ; // Commande = différence de pousée entre les moteurs : cmd = poussee_g - poussee_d

const int periode = 15 ; // Période d'échantillonage = Pause à la fin du programme Arduino = Temps d'execution de la fonction loop()

const int poussee_moyenne = 100 ; // Poussée moyenne, déterminée aléatoirement mais dois rester logique

void setup() {

  pinMode(MOT_G, OUTPUT) ;
  pinMode(MOT_D, OUTPUT) ;

  Serial.begin(9600) ; // Moniteur série sur 9600 bauds (bits/s)

  adxl.powerOn() ; // Démarrage du capteur accéléromètre/gyroscope

}

void loop() {
  
  int x,y,z ;  
  adxl.readXYZ(&x, &y, &z) ; // Lecture des valeurs issues de  l'accéléromètre et stockage dans les variables x,y,z
  
  // Valeurs de sorties x, y, z 

  double x_Buff = float(x) ;
  double y_Buff = float(y) ;
  double z_Buff = float(z) ;

  pitch = atan2((- x_Buff) , sqrt(y_Buff * y_Buff + z_Buff * z_Buff)) * 63 ;
  mesure = pitch ; // Mesure finale
  
    erreur = consigne - mesure ; // Calcul de l'écart entre la consigne et la mesure (-> erreur) => Paramètre proportionnel
    somme_erreurs += erreur ; // Paramètre intégral
    variation_erreur = erreur - erreur_precedente ; // Paramètre dérivée

    commande = (Kp * erreur) + (Ki * somme_erreurs * periode) + ((Kd * variation_erreur) / periode) ; // Calcul de la commande

    erreur_precedente = erreur ; // Stockage de l'erreur actuelle

    // Conditions pour éviter la saturation (dépassage des valeurs limites (Démarrage du moteur/Moteur à fond)) :

    if (commande < ...) commande = ... ; // A REMPLACER par la valeur pour laquelle les moteurs démarrent /!\
    else if (commande > ...) commande = ... ; // A REMPLACER par la valeur pour laquelle les moteurs s'arrêtent /!\

    // Détermination de la pousée des moteurs :

    poussee_g = (1/2) * commande + poussee_moyenne ; // Poussee du moteur gauche
    poussee_d = poussee_moyenne - (1/2) * commande ; // Poussee du moteur droit

    // Envoie de ces poussées aux moteurs :

    analogWrite(MOT_G, poussee_g) ;
    analogWrite(MOT_D, poussee_d) ;

    /* Debug */

    //Serial.println(erreur) ;

    //Serial.print("Temps : ") ;
    //Serial.println(millis()) ;
    
    //Serial.print("Mesure : ") ;
    Serial.println(mesure) ;

    //Serial.print("Commande : ") ;
    //Serial.println(commande) ;

    
    delay(15) ; // Pause (= periode)

}