Séquence 8 : Double commande moteur

Malheureusement dans cette partie, nous ne pouvons plus utiliser le port série. Il nous faut utiliser le port réseau afin de pouvoir écrire son propre correcteur.

La vitesse de communication par le port réseau est beaucoup plus lente que par le port série. Cela implique un retard dans la chaine de communications que nous n'avions pas auparavant. De ce fait, le comportement de la platine n'est plus le même et le modèle que nous avions établi n'est plus valable !

L'implémentation d'un correcteur numérique dans un micro-contrôleur ou dans un ordinateur se fait grâce à un programme dont vous pouvez voir la structure ci dessous.

Il faut garder à l'esprit que ce script est itératif. Il est exécuté à intervalle de temps régulier avec une période de l'échantillonnage Te.

Nous rappelons que l'erreur est la différence de la consigne avec la réponse. Dans notre cas, la grandeur physique asservie est la vitesse de rotation du motoréducteur.

I_x = 0. # Etat de l'intégrateur
D_x = 0. # Etat de la dérivée
erreurprec = 0. # Mesure de l'erreur au pas précédent

def PID(cons, mes, Kp, Ki, Kd, Tf, umax, umin, Te):
    # cons : Consigne de vitesse
    # mes : Mesure de la vitesse
    # Kp : gain de l'action proportionnelle
    # Ki : gain de l'action intégrale
    # Ti : constante de temps de l'action intégrale
    if Ki == 0:
        Ti = 0 # Attention à la division par zéro...
    else:
        Ti = 1 / Ki
    # Kd : gain de l'action dérivée
    # Tf : Non utilise
    # umax : commande maximale
    # umin : commande minimale
    # Te : période de l'échantillonnage

    global I_x, D_x, erreurprec
    
    ## Calcul du PID

    ## Calcul de l'erreur
    erreur = cons - mes
 
    ## Terme proportionnel de gain Kp
    P_x = 0.

    ## Terme intégral de gain Ki ou de constante de temps Ti
    I_x = 0.

    ## Terme dérivé de gain Kd
    D_x = 0.

    ## Calcul de la commande avant saturation
    if (Kp == 0): P_x = 0.
    if (Ki == 0): I_x = 0.
    if (Kd == 0): D_x = 0.
    commande_avant_sat = P_x + I_x + D_x

    ## Application de la saturation sur la commande
    if (commande_avant_sat > umax):
        commande = umax
    elif (commande_avant_sat < umin):
        commande = umin
    else:
        commande = commande_avant_sat

    ## Stockage de l'erreur courante pour utilisation lors du pas d'échantillonnage suivant
    erreurprec = erreur

    return commande

La correction proportionnelle est caractérisée par cette relation : la commande \( u(t) = Kp \cdot erreur(t) \).

La commande \( u(t) \) de l'action proportionnelle sera appelée dans le programme P_x.

Modifier le programme ci-dessus pour implanter l'action proportionnelle.

Nous allons implanter votre programme dans la platine et tester dans la foulée votre programme.

• Ouvrir l'application Asservissement en vitesse (réseau)
• Si cela n'est pas déjà fait, commuter sur ON le bouton de Marche / Arrêt
• Implanter votre correcteur :
• Téléverser votre fichier PID.py
• Commuter le bouton Utiliser le fichier téléchargé sur
• Régler le correcteur PID à votre convenance
• Choisir une durée d’acquisition de 2.25 s
• Choisir un signal de type Rectangle avec
• un offset de 0 rad/s
• une amplitude de 40 rad/s
• une fréquence de 0.5 Hz
• un rapport cyclique de 80%
• un délai avant le démarrage de 500 ms
• Commuter le bouton du générateur de signal sur ON quand vous êtes prêt

• Refaire au choix une seule des situations Correction proportionnelle avec ou sans perturbation avec le correcteur personnalisé. Sauvegarder l'acquisition sous correcteurProportionnelPersonnalise.csv.
• Refaire la même situation avec le correcteur par défaut. Sauvegarder l'acquisition sous correcteurProportionnelparDefaut.csv
• Afficher les courbes dans la situation Correction proportionnelle.
• Commenter la différence entre le correcteur par défaut et le vôtre.

La correction intégrale est caractérisée par cette relation : la commande \( u(t) = \dfrac{1}{Ti} \cdot \int\limits_{0}^{t} erreur(\theta) \cdot d\theta \) avec \( \dfrac{1}{Ti} = Ki \).

La commande \( u(t) \) de l'action intégrale sera appelée dans le programme I_x.

Recopier sur une feuille le schéma ci-dessous

Représenter sur cette courbe \( \int\limits_{0}^{t} erreur(\theta) \cdot d\theta \) pour \( t = 2 \cdot Te \).

On suppose qu'à l'instant \( t \) que \( u(t) = \dfrac{1}{Ti} \cdot \int\limits_{0}^{t} erreur(\theta) \cdot d\theta \) est connu. D'ailleurs sur le programme ci-dessus, cela correspond à la variable globale I_x.

Le temps est échantillonné sur un intervalle de temps Te. A la prochaine itération, nous devons réévaluer \( u(t+Te) = \dfrac{1}{Ti} \cdot \int\limits_{0}^{t+Te} erreur(\theta) \cdot d\theta \) qui vaut en fait \( \dfrac{1}{Ti} \cdot \int\limits_{0}^{t} erreur(\theta) \cdot d\theta + \dfrac{1}{Ti} \cdot \int\limits_{t}^{t+Te} erreur(\theta) \cdot d\theta \).

Sur le schéma recopié, représenter d'une autre couleur \( \int\limits_{t}^{t+Te} erreur(\theta) \cdot d\theta \) pour \( t = 2 \cdot Te \).

Eventuellement, à partir de l'approximation numérique de l'intégrale par la méthode des rectangles, donner une approximation numérique de cette intégrale en fonction des variables disponibles dans le programme ci-dessus.

Un correcteur proportionnel intégrale peut s'écrire \( u(t) = Kp \cdot erreur(t) + \dfrac{1}{Ti} \cdot \int\limits_{0}^{t} erreur(\theta) \cdot d\theta \), c'est-à-dire, commande_avant_sat = P_x + I_x.

Modifier le programme précédent pour implanter l'action intégrale.

Téléverser votre nouveau programme.

• Refaire au choix une seule des situations Correction proportionnelle intégrale avec ou sans perturbation avec le correcteur personnalisé. Sauvegarder l'acquisition sous correcteurProportionnelIntegralPersonnalise.csv.
• Refaire la même situation avec le correcteur par défaut. Sauvegarder l'acquisition sous correcteurProportionnelIntegralparDefaut.csv
• Afficher les courbes dans la situation Correction proportionnelle.
• Commenter la différence entre le correcteur par défaut et le vôtre.