Scribd Logo
Importer

Bienvenue sur Scribd !

  • Compte Rendu TP1 Automatique Linéaire: - Hicham Elfarissi - Abdessamad Guessous - Qmsi

    Transféré par

    Abdessamad Guessous
    8 vues21 pages
    The document discusses three types of controllers - proportional (P), proportional-integral (PI), and proportional-derivative (PD) - for a system with poles at -1 and -5. It analyzes each controller for gains of 1, 10, and 100. The key findings are: 1) P control improves accuracy but not stability as gain increases. 2) PI control improves accuracy but stability decreases and settling time increases as gain rises above 10. 3) PD control provides stabilization without impacting accuracy, though overshoot increases with higher gains.

    Description originale:

    Titre original

    TpAL

    Copyright

    © © All Rights Reserved

    Formats disponibles

    PDF, TXT ou lisez en ligne sur Scribd

    Avez-vous trouvé ce document utile ?

    Ce contenu est-il inapproprié ?

    Signaler ce document
    The document discusses three types of controllers - proportional (P), proportional-integral (PI), and proportional-derivative (PD) - for a system with poles at -1 and -5. It analyzes each controller for gains of 1, 10, and 100. The key findings are: 1) P control improves accuracy but not stability as gain increases. 2) PI control improves accuracy but stability decreases and settling time increases as gain rises above 10. 3) PD control provides stabilization without impacting accuracy, though overshoot increases with higher gains.

    Droits d'auteur :

    © All Rights Reserved
    Téléchargez comme PDF, TXT ou lisez en ligne sur Scribd
    Signaler comme contenu inapproprié
    Télécharger au format pdf ou txt
    8 vues21 pages

    Compte Rendu TP1 Automatique Linéaire: - Hicham Elfarissi - Abdessamad Guessous - Qmsi

    Transféré par

    Abdessamad Guessous
    The document discusses three types of controllers - proportional (P), proportional-integral (PI), and proportional-derivative (PD) - for a system with poles at -1 and -5. It analyzes each controller for gains of 1, 10, and 100. The key findings are: 1) P control improves accuracy but not stability as gain increases. 2) PI control improves accuracy but stability decreases and settling time increases as gain rises above 10. 3) PD control provides stabilization without impacting accuracy, though overshoot increases with higher gains.

    Droits d'auteur :

    © All Rights Reserved
    Téléchargez comme PDF, TXT ou lisez en ligne sur Scribd
    Signaler comme contenu inapproprié
    Télécharger au format pdf ou txt
    sur 21

    • Hicham Elfarissi

    • Abdessamad Guessous
    • QMSI

    Compte rendu TP1 Automatique Linéaire


    Le schéma:

    1/Nous allons tracer les diagrames de bode des 3 fonctions en boucle ouvert

    On donne à K = 0.1, 10, 100

    P1: K=0.1

    sys1 = zpk([],[-1,-5],[0.1])

    sys1 =

    0.1
    -----------
    (s+1) (s+5)

    Continuous-time zero/pole/gain model.

    margin(sys1 )

    1
    sysbf1=feedback(sys1,1)

    sysbf1 =

    0.1
    -------------------
    (s+1.025) (s+4.975)

    Continuous-time zero/pole/gain model.

    margin(sys1)

    2
    step(sysbf1)

    3
    P2: K=10

    sys2 = zpk([],[-1,-5],[10])

    sys2 =

    10
    -----------
    (s+1) (s+5)

    Continuous-time zero/pole/gain model.

    margin(sys2)

    sysbf2=feedback(sys2,1)

    sysbf2 =

    10
    ---------------
    (s^2 + 6s + 15)

    Continuous-time zero/pole/gain model.

    step(sysbf2)

    4
    P3: K=100

    sys3 = zpk([],[-1,-5],[100])

    sys3 =

    100
    -----------
    (s+1) (s+5)

    Continuous-time zero/pole/gain model.

    margin(sys3)

    5
    sysbf3=feedback(sys3,1)

    sysbf3 =

    100
    ----------------
    (s^2 + 6s + 105)

    Continuous-time zero/pole/gain model.

    step(sysbf3)

    6
    bode(sys1,sys2,sys3)

    7
    stepinfo(sysbf1)

    ans = struct with fields:


    RiseTime: 2.2213
    TransientTime: 4.0411
    SettlingTime: 4.0411
    SettlingMin: 0.0177
    SettlingMax: 0.0196
    Overshoot: 0
    Undershoot: 0
    Peak: 0.0196
    PeakTime: 7.9424

    stepinfo(sysbf2)

    ans = struct with fields:


    RiseTime: 0.6131
    TransientTime: 1.3834
    SettlingTime: 1.3834
    SettlingMin: 0.6030
    SettlingMax: 0.6809
    Overshoot: 2.1322
    Undershoot: 0
    Peak: 0.6809
    PeakTime: 1.2894

    stepinfo(sysbf3)

    ans = struct with fields:


    RiseTime: 0.1282
    TransientTime: 1.3181
    SettlingTime: 1.3181

    8
    SettlingMin: 0.8134
    SettlingMax: 1.3163
    Overshoot: 38.2102
    Undershoot: 0
    Peak: 1.3163
    PeakTime: 0.3224

    D'une autre part on a Les valeurs theoriques des erreurs statiques :

    • Pour K=0.1 : εp = 0.92


    • Pour K=10 : εp = 0.3
    • Pour K=100 : εp = 0.04

    Conclusion:

    Pour un systeme de class 0 :

    on remarque que l'augmentation de gain proportionel permet de diminuer l'erreur, et ameliorer la precision.

    2/On ajoute un Integrateur :

    Le schéma:

    sysInt1 = zpk([],[0,-1,-5],[1]);
    sysInt2 = zpk([],[0,-1,-5],[10]);
    sysInt3 = zpk([],[0,-1,-5],[100]);
    sysIntBF1 = feedback(sysInt1,1);
    sysIntBF2 = feedback(sysInt2,1);
    sysIntBF3 = feedback(sysInt3,1);
    step(sysIntBF1)

    9
    stepinfo(sysIntBF1)

    ans = struct with fields:


    RiseTime: 8.3344
    TransientTime: 15.0125
    SettlingTime: 15.0125
    SettlingMin: 0.9002
    SettlingMax: 1.0000
    Overshoot: 0
    Undershoot: 0
    Peak: 1.0000
    PeakTime: 37.0932

    step(sysIntBF2)

    10
    stepinfo(sysIntBF2)

    ans = struct with fields:


    RiseTime: 0.9439
    TransientTime: 12.7074
    SettlingTime: 12.7074
    SettlingMin: 0.7562
    SettlingMax: 1.4855
    Overshoot: 48.5498
    Undershoot: 0
    Peak: 1.4855
    PeakTime: 2.5312

    step(sysIntBF3)

    11
    stepinfo(sysIntBF3)

    ans = struct with fields:


    RiseTime: NaN
    TransientTime: NaN
    SettlingTime: NaN
    SettlingMin: NaN
    SettlingMax: NaN
    Overshoot: NaN
    Undershoot: NaN
    Peak: Inf
    PeakTime: Inf

    On remarque que :

    • pour k=1: le systeme est plus mais le temps de prise est long (=15sec)
    • pour k=10: le systeme est moins stable mais le temps de prise est moins long (=12sec)
    • pour k=100: Le systeme est instable. le temps de prise est non déterminé.

    margin(sysInt1)

    12
    margin(sysInt2)

    13
    margin(sysInt3)

    bode(sysInt1,sysInt2,sysInt3)

    14
    Conclusion:

    Alors, l'integrateur permet d'améliorer la précision, et détériorer la stabilité et la rapidité.

    3/On ajoute un derivateur :

    Le schéma:

    sysDev1 = zpk([0],[-1,-5],[1]);
    sysDev2 = zpk([0],[-1,-5],[10]);
    sysDev3 = zpk([0],[-1,-5],[100]);
    sysDevBF1 = feedback(sysDev1,1);
    sysDevBF2 = feedback(sysDev2,1);
    sysDevBF3 = feedback(sysDev3,1);
    step(sysDevBF1)

    15
    stepinfo(sysDevBF1)

    ans = struct with fields:


    RiseTime: 9.5410e-17
    TransientTime: 5.3966
    SettlingTime: NaN
    SettlingMin: 1.0977e-04
    SettlingMax: 0.1190
    Overshoot: 1.0716e+17
    Undershoot: 0
    Peak: 0.1190
    PeakTime: 0.3718

    step(sysDevBF2)

    16
    stepinfo(sysDevBF2)

    ans = struct with fields:


    RiseTime: 1.9082e-17
    TransientTime: 12.5870
    SettlingTime: NaN
    SettlingMin: 3.7078e-04
    SettlingMax: 0.5882
    Overshoot: 2.6489e+17
    Undershoot: 0
    Peak: 0.5882
    PeakTime: 0.2526

    step(sysDevBF3)

    17
    stepinfo(sysDevBF3)

    ans = struct with fields:


    RiseTime: 6.0715e-17
    TransientTime: 82.9804
    SettlingTime: NaN
    SettlingMin: 0.0018
    SettlingMax: 0.9406
    Overshoot: 1.5128e+16
    Undershoot: 0
    Peak: 0.9406
    PeakTime: 0.0742

    margin(sysDev1)

    18
    margin(sysDev2)

    19
    margin(sysDev3)

    bode(sysDev1,sysDev2,sysDev3)

    20
    On remarque que :

    Le correcteur Derivateur permet d'ajouter un effet stabilisant, sans deteriorer la precision.

    21

    Vous aimerez peut-être aussi