[MATLAB] Asservissement grâce au PID

Bonjour,

Depuis mon sujet "[ARDUINO] Asservissement grâce au PID" (https://zestedesavoir.com/forums/sujet/11649/arduino-asservissement-grace-au-pid/?page=1#p194416), mon professeur nous a demandé de passer sur MATLAB (Simulink) pour faciliter aux autres la compréhension du programme aux autres (mais ce qui nous simplifie pas la tâche :p). Me voilà donc avec une tentative de programme pour reproduire le programme Arduino que j’ai obtenu à la fin de mon 1er sujet grâce à la participation des membres qui se reconnaitront si ils passent par là ^^.

Pour ceux ne pouvant pas aller voir mon sujet précédant voici un rapide résumé de ce que j’ai dis dans mon sujet précédant :

"Je suis actuellement en terminale SI et dans le cadre de cette matière, je dois réaliser un stabilisateur de drone "simplifié" c’est-à-dire ça : https://www.youtube.com/watch?v=w2hZoZQyRw8&t=28s

L’une des problématiques de ce projet est donc l’asservissement grâce au PID.

Notre cahier des charges nous impose de considérer que le drone n’est plus stabilisé lorsque ses oscillations dépassent de plus ou moins 5degrés de 90degrés."

Et le programme Arduino final :

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

double pitch = 0.00;

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

float erreur = 0; //consigne - mesure

float consigne = 90;

const float Kp = 10 ;
const float Ki = 0.4 ;
const float Kd = 20 ;

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

float mesure = 0;
float commande = 0;

const int periode = 15 ;

void setup() {

  Serial.begin(9600);
  adxl.powerOn();

}

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;
  
    erreur = consigne - mesure ;
    somme_erreurs += erreur ;
    variation_erreur = erreur - erreur_precedente ;

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

    erreur_precedente = erreur ;
    
    delay(15) ;

}

Et maintenant rentrant dans le vif du sujet de ce sujet (sujetception :)). Ma question est donc plutôt simple (en apparance) : le programme suivant vous semble t-il correct ?

Voici mon programme sur MATLAB :

Et le sous programme :

C’est tout pour ce message

Je vous remercie (beaucoup) par avance de vos réponses !

Cordialement,

Jupiter41

Salut,

Petit point de vocabulaire pour commencer. Tu utilises bel et bien Matlab, mais ce que tu montres n’est pas un programme Matlab, mais un modèle Simulink. Et le détail que tu montres n’est pas un sous-programme, mais un sous-système.

Ceci dit, je crois que ton modèle est faux, ou au mieux confus. Du coup, j’ai plein de questions pour toi.

• Que veux-tu faire avec ton block Timestamp ? Je ne le connais pas, mais je ne pense pas à première vu que ça corresponde à ton usage.
• As-tu lu et compris la documentation des blocs intégration et dérivation ?
• Cherches-tu à modéliser un contrôleur discret (comme ton programme Arduino) ou continu (comme si tu avais une implémentation en électronique analogique) ?
• Est-ce que tu veux modéliser ton programme ou aussi le monde extérieur (capteur, convertisseurs analogiques-numériques…) ?
• Pourquoi ne pas utiliser tout simplement les modèles de PID paramétrables fournis dans la bibliothèque de Simulink ?
• En quoi un modèle Simulink simplifierait la compréhension d’un PID par rapport à un schéma bloc fait à la main ?
• Est-ce que tu peux envoyer les paramètres de ta simulation (solveur, temps d’échantillonnage, etc.) ? On les trouve dans un des menus (dont j’ai oublié le nom, désolé), et ça peut être important en fonction de ce que tu veux exactement faire.

Salut !

Merci beaucoup pour ta réponse @Aabu  :

• Je voulais récupérer le temps d’exécution de la simulation pour obtenir ce qui correspond à la période dans le programme Arduino.

• Non, je n’ai pas lu leurs documentation car pour moi (j’imagine que c’est faux du coup) ils calculent juste l’intégrale et la dérivée d’une valeur.

• Je n’ai pas trop compris cette question (et la suivante) mais le but serait de faire exactement ce que je faisais sur Arduino sur MATLAB (donc récupérer la mesure, calculer le PID, contrôler les moteurs etc…)

• (Voir la réponse précédente)

• Le seul bloc que j’ai trouvé est le "PID Controller" mais je trouvais plus simple de tout faire moi-même puisque j’avais le programme Arduino à côté

• Aucune idée, peut-être un caprice de professeur de SI

• Je regarderai ça demain après midi mais si par "temps d’échantillonnage" tu entends bien "durée de la simulation" (à peu près) je l’ai réglé sur inf et le paramètre d’à côté dont je ne connais pas le nom (qui est réglé sur "Normal" normalement) est réglé sur "External" (pour l’envoyer sur la carte Arduino)

Rebonjour,

Je viens de penser à un truc. Tu connais les support packages pour Arduino ? J’imagine que oui vu que tu as l’air d’interagir avec ton Arduino. Par contre, si tu connais mal Simulink, c’est pas forcément un cadeau, et il vaut mieux bien comprendre les bases avant. Mais tu peux trouver plein de tuto (en français !) sur le site de Mathworks (l’éditeur de Matlab et Simulink). Je te laisse chercher sur ton moteur favori.

• Je voulais récupérer le temps d’exécution de la simulation pour obtenir ce qui correspond à la période dans le programme Arduino.

Du coup, tu cherches à simplement simuler ou à générer un programme pour Arduino ? Le mode external (auquel est lié le bloc timestamp) est fait pour le temps réel (ce qui n’est pas pareil qu’une simulation bête et méchante). Et même avec ça, je ne vois pas en quoi ce bloc t’aide à implanter un PID. Tu peux t’en passer avec une solution plus simple, c’est sûr.

• Non, je n’ai pas lu leurs documentation car pour moi (j’imagine que c’est faux du coup) ils calculent juste l’intégrale et la dérivée d’une valeur.

Ils calculent l’intégrale et la dérivée d’un signal. Mais en simulation numérique, il faut se méfier de ce que signifie "juste calculer". Ces blocs ne sont pas nécessaires pour faire un PID discret, mais on utilise alors d’autres fonctionnalités de Simulink.

• Je n’ai pas trop compris cette question (et la suivante) mais le but serait de faire exactement ce que je faisais sur Arduino sur MATLAB (donc récupérer la mesure, calculer le PID, contrôler les moteurs etc…)

Ce sera un contrôleur discret donc !

• (Voir la réponse précédente)

Avec ma question, j’essaie de comprendre la portée de ta modélisation. Là, dans ce que tu montres, tu modélises seulement l’implémentation du contrôleur. Il s’agit donc d’un modèle de ton programme Arduino et pas un modèle complet, qui inclurait une modélisation des capteurs, du processus de conversion de l’ADC, et plein d’autres choses.

• Le seul bloc que j’ai trouvé est le "PID Controller" mais je trouvais plus simple de tout faire moi-même puisque j’avais le programme Arduino à côté

C’est celui là. Par contre, c’est vrai que les paramètres des blocs de la bibliothèque peuvent être durs à comprendre. Mais traduire un programme Arduino en Simulink n’est pas forcément quelque chose de plus trivial !

• Aucune idée, peut-être un caprice de professeur de SI

Je ne serai pas étonné.

Ce n’est pas la durée de simulation, je pensais à un truc qu’on trouve dans "Configuration Parameters". Si tu fais de la simulation pure, je serai plus à même de t’aider, parce que là, ma connaissance de Simulink avec Arduino se limite quasiment à savoir que ça existe (mais j’ai déjà travaillé avec choses voisines…)

Bref, mes conseils pour t’aider à démarrer dans le sujet :

• essaie de faire des petits tuto avec Simulink pour te familiariser avec tout, si tu ne l’a pas déjà fait ;
• commence par faire de la simulation (mode Normal et pas External), sans chercher à interagir avec la carte, c’est une étape importante afin de comprendre ce que tu fais faire au logiciel sans rajouter de complexité supplémentaire ;
• cherche à vérifier, comme tu l’as fait avec ton programme Arduino à la main que ton PID est bien fait dans Simulink ;
• ensuite essaie d’exécuter ce programme sur ta carte et de comprendre les spécificités (souvent des histoires d’échantillonnage et d’horloge, mais j’y connais rien) ;
• si tu peux, essaie de voir si Simulink génère directement un programme ou si tu peux voir le code, ça te permettrait de mieux comprendre la chaîne de compilation de Simulink et de comparer avec ce que toi tu as fait.

D’accord merci beaucoup pour ton aide @Aabu !

• Tu as un peu près bien compris ce que je veux faire mais je vais essayer de préciser un peu plus  : En faite je voudrais faire tout ce que je faisais dans le programme Arduino avec Simulink : récupérer la mesure (fait (sous-système mesure)), calculer la commande grâce au PID (en cours) et enfin convertir cette commande en tension pour le moteur (pas encore regardé).

Comme tu l’as compris j’utilise Simulink pour communiquer avec la carte Arduino pour récupérer/envoyer des données. C’est pour cela que j’ai réglé la simulation en "External" (elle fonctionne avec la carte Arduino) et le temps de la simulation en "inf". Ce n’est donc bien pas une la simulation "pure"…

Du coup pour résumé je voudrais, avec Simulink, obtenir exactement le même graphique que j’avais fait pour vérifier si le PID marchait avec Arduino.

• Pour le bloc Timestamp, puisque apparement il ne s’agit pas du bon bloc je ne sais pas trop comment faire pour avoir la période :’(. (Mais il s’agit du temps de simulation non ? Si c’est bien le cas je devrais le retrouver à l’endroit que tu m’as indiqué dans ton message normalement)

• Du coup pour le paramètre intégrale et dérivée, il faut aussi passer par le calcul de la somme/variation des erreurs ?

Bon, j’ai vu avec mon prof pour repasser sur Arduino et il est d’accord. Puisque mon Pid fonctionne normalement avec Arduino, il me faut trouver la fonction de transfert d’un moteur brushless (des infos ? ) et l’implémenter et notre projet seras à peu près fini.

Ton système c’est une balance que tu équilibre avec la poussée de 2 hélices. Si tu veux faire une étude théorique, il va te falloir un modèle de ta balance, et un modèle de la poussée de tes moteurs. Ce dernier point est galère à avoir: si t’as pas un champs libre autours de tes hélices (de l’ordre de 3 diamètres d’hélice au dessus et 6 en dessous, si je me souviens bien ce qu’on m’avait dit), l’écoulement est perturbé. Ca va arriver quand ton système va osciller à gauche ou à droite.

Sans ça, ton hélice a une poussée proportionnelle au carré de ta vitesse, et un couple proportionnel à ta vitesse de rotation (plus ou moins. Les hélices de cette taille ont un nombre de Reynolds un peu bas pour que les modèles considérant un écoulement strictement turbulent s’appliquent).

La caractéristique d’un moteur électrique est toujours la même, brushed ou brushless:

Le problème c’est que cette caractéristique vaut pour une tension d’alimentation donnée. Ton moteur est contrôlé par un petit circuit électronique, appelé ESC, pour Electronic Speed Controller, qui crée une tension triphasée pour faire tourner le brushless, dont l’amplitude dépend de la consigne que tu lui fournit. Si le système est bien adapté, ton point de fonctionnement peut être proche du rendement maximum du moteur sur toute la plage de tension (et de vitesse de fonctionnement), environ 80% (ça dépend de ton moteur). Si ton moteur sature ou chauffe, ça va faire dégringoler le rendement à haute vitesse.

Bref, un modèle complet me semble bien au delà de ce qu’on peut attendre d’un projet scolaire. Par contre avec une simple balance, il est possible d’avoir une mesure pas trop déconnante de la poussée du moteur en fonction de la commande, et ça permet d’avoir un bon ordre de grandeur des commandes à envoyer pour stabiliser le système.

D’accord merci beaucoup pour ton aide @Jacen ! Si j’ai bien compris tu me recommande de plutôt passer par des tests ?

C’est l’idée. Tu mesure empiriquement le comportement de ton moteur+hélice en boucle ouverte, tu trouves une fonction polynomiale d’ordre pas trop élevé qui lui ressemble (une fonction linéaire ou quadratique, c’est bien)(Excel sait faire les régressions polynomiales) et tu considère que c’est le modèle de ton groupe propulsif. Il reste à déduire le couple appliqué sur ton "drone" en fonction de la différence de poussée des deux moteurs (là c’est de la physique plus facile) et tu as un modèle complet de ton système.

D’accord merci je vais regarder ça !

Si tu veux des mots-clés pour tes recherches, les techniques décrites par @Jacen sont ce qu’on appelle de l'identification de système. La page Wikipédia en français est très moyenne, celle en anglais un peu mieux : System Identification.

Ok merci !