5. fejezet - Szervomotor szabályozási körének internetes távmérése (Laboratóriumi mérési gyakorlatok leírása)

Ebben a fejezetben a méréshez használt hajtást mutatjuk be. Mivel a méréseknél finom mozgásokat akarunk közvetíteni, ezért egy precíziós méretű motort választottunk. Szabályozástechnikai szempontból az állandó mágnessel gerjesztett egyenáramú motor egy kedvező beavatkozó szerv.

Egy állandó mágnessel gerjesztett egyenáramú motort választottunk. Maxon A-max sorozatú, 26 mm tengelyátmérőjű, 11 W teljesítményű, grafitkefés motort használtuk fel. A motor névleges tápfeszültsége 15V. 1999. évi Maxon katalógus 97. oldal, motor rendelési száma: 110961. A motor szögelfordulását, és forgásirányát egy optikai útadóval (enkóder) érzékeljük. A motorra a Maxon HEDL-5540-es digitális enkódert szereltük fel.

A digitális enkóder kimenetei a következők:

Az enkóder kimenetein digitális jel jelenik meg. Az enkóderben a DS26LS31C típusú vonali meghajtóáramkört helyezték el. Az 1, 3 lábakon az enkóder tápfeszültségét lehet bekötni, amely 5 V egyenfeszültség. Az 5-6 lábakon az A csatorna (0 fokos fázisszög), a 7-8. lábakon a B csatorna (90 fokos fázisszög), a 9-10. lábakon pedig az Index csatorna kivezetései találhatóak. Az Index jel nagyon fontos, főleg pozíciószabályozásnál, ugyanis a szabályozás kezdetekor a motor tengelyének helyzete nem ismert, és ez a szabályozás során állandó hiba forrása lehet. Ezért a szabályozás indítása előtt a motort egy előre meghatározott helyzetbe, ún. index pozícióba kell állítani. Az enkóder is rendelkezik ilyen index pozícióval, és ha a motor tengelye áthaladt az index pozíción, akkor az index csatorna 1-es jelet ad ki.

A motorvezérlésnél a Maxon 4QD- 50V/5A típusú szervoerősítőt használtuk fel.

A berendezés paraméterei:

Teljes négynegyedes hajtásvezérlés motor és generátoros üzemmódban egyaránt, gyorsítás, fékezés, a motor irányváltása. Az üzemi feszültség 12-50 V egyenfeszültség, rövid ideig 10 A áramot is képes szolgáltatni, de az üzemi kimenő árama 5 A, és így a maximális üzemi teljesítménye 250 W. A szervoerősítő a 5-4 ábrán látható. A szervoerősítő bemeneteire enkóder, és tachogenerátor kapcsolható, áram és fordulatszám kimenetekkel rendelkezik, valamint PWM üzemmódban is működtethető.

A szervoerősítő elsődleges feladata a motor tengelyének terheléstől független, megadott sebességű forgatása. A szervoerősítőben található vezérlőelektronika folyamatosan figyeli a motor sebességét, és összehasonlítja a beállított értékkel. Ha eltérést észlel, akkor módosítja a szervoerősítő kimenetének értékét, és ezzel vezérli a motort. A végeredmény egy zárt sebességvezérlő hurok. Természetesen a sebesség vezérlését többféle módon végezhetjük:

Tachogenerátorral

Digitális enkóderrel

I x R kompenzációval

Tachogenerátoros sebességvezérlés:

A motorra egy tachogenerátor felszerelve, az a fordulatszámmal arányos egyenfeszültséget ad. Előnye, hogy nagyon pontos, hátránya hogy a tachogenerátor, mivel mechanikus alkatrész, egy idő után cserére szorul.

Sebességvezérlés digitális enkóderrel:

A motorra egy digitális enkódert felszerelve, az egy körülfordulás alatt bizonyos számú jelet küld. Az enkóderek kétfajta jelet állítanak elő, a két jel között 90 fok a fáziseltérés. Ez teszi lehetővé az elfordulás irányának érzékelését. Mivel az enkóder nem mechanikus, ezért élettartama nagyon hosszú. Hátránya, hogy drága.

Sebsességvezérlés I x R kompenzációval:

A motor tápfeszültsége arányos a motor előírt sebességével. Ha megnő a motor terhelése, akkor a fordulatszám lecsökken. A szabályozó áramkör megemeli a motor feszültségét, (ezzel áramát is), hogy az előírt fordulatszámot tartani tudja. A kompenzációnak azonban figyelembe kell venni a motor ellenállását, ami a hőmérséklet és terhelésfüggő. Ezért ez a szabályozási mód kevésbé pontos. A módszer előnye, hogy nincs szükség külső segédberendezésre, tehát olcsó, hátránya a pontatlanság.

A szervoerősítőbe áramkorlátozó áramkör van beépítve. A szabályozó a motor áramát állítja, ami arányos a fordulatszámmal, és a nyomatékkal. A szervoerősító kétféle üzemmódban képes működni:

lineáris

PWM

A lineáris szabályozási mód esetében a motor feszültségét () a szabályozó áramkör állítja be úgy, hogy egy előtét a potenciaméter értékét állítja. A potenciaméteren eső feszültség () a potenciaméteren hővé alakul, emiatt jelentősen romlik a hatásfok.

A PWM szabályozási mód esetében a motort nagyon gyorsan ki/be kapcsolgatjuk, ezzel állítva be a kívánt fordulatszámot. A motor átlagfeszültsége arányos a ki/bekapcsolt állapot idejével. A hő miatti hatásfokveszteségek alacsonyak. Jó hatásfokú, de viszonylag bonyolult kiegészítő áramköröket kíván.

A kiválasztott szabályozási mód a szervoerősítőn DIP kapcsolókkal állítható be. A maximális fordulatszám, az áram, valamint az erősítés a P1-P5 potenciaméterekkel szabályozható.

A rendszer előnye nagyfokú integráltságában rejlik. Ha a felügyelő PC (Host PC) egy számítógéphálózatra kapcsolódik, pl. az internetre, akkor megfelelő programok segítségével, tetszőlegesen távoli helyről felügyelni lehet a rendszert, és szükség esetén be lehet avatkozni. Ehhez a gondolathoz megjegyezzük, hogy a Matlab RTW része tartalmaz olyan függvényeket, amelyek segítségével a két tetszőlegesen távol lévő modell adatokat tud cserélni az interneten keresztül. Így a Matlab szoftver segítségével a probléma megoldható.

E mérésnél az áramvezérlést (Current Controller) használtuk fel, a fordulatszámvezérlést (Speed Controller) az 1-es DIP kapcsoló rövidre zárásával iktattuk ki. A maximális áram beállítása nagyon fontos, ugyanis, ha a motor terhelése annyira megnő, hogy forgása lelassul, ebben az esetben olyan áram is keletkezhet, amely már káros a motor tekercselésének.

A függvény meghívása: status = DRV_DeviceOpen(DeviceNum, DriverHandle)

Rendeltetése: a registry vagy konfigurációs fájlból kinyeri az eszköz működtetéséhez szükséges paramétereket, és a gyors elérhetőség érdekében megcímzi a memóriát. Ezt a függvényt minden más függvény előtt meg kell hívni.

Eredmények:

Megjegyzések:

A függvény meghívása: status = DRV_AOVoltageOut(DriverHandle, lpAOVoltageOut)

Rendeltetése: beolvas egy lebegőpontos értéket, átalakítja a megfelelő bináris értékké, majd beírja a számot egy analóg kimeneti csatornába, hogy azon megváltozzon a feszültség.

Eredmények:

Megjegyzés:

A paraméterek nevei ebben a példában eltérnek a mérésben valóban használtaktól. Nem lehet egyszerűen másolni és beilleszteni ezt a példát.

/*
 **************************************************************************** 
 * Program        : DASOFT.CPP                                              * 
 * Description    : Demo program for analog output function                 * 
 * Boards Supp.   : PCL-818 series/818HG/1800/816/812PG/711B/726/727/728,   * 
 *                  PCI-1710/1720, MIC-2728, ADAM-4021/5024                 * 
 * APIs used      : DRV_DeviceOpen,DRV_DeviceClose, DRV_GetErrorMessage     * 
 *                  DRV_AOVoltageOut                                        * 
 * Revision       : 1.00                                                    * 
 * Date           : 7/8/1999                   Advantech Co., Ltd.          * 
 **************************************************************************** 
 */
#include <windows.h>
#include <windef.h>
#include <stdio.h>
#include <conio.h>
#include "..\..\..\include\driver.h"
/******************************
 * Local function declaration *
 ******************************/
void ErrorHandler(DWORD dwErrCde);
void ErrorStop(long*, DWORD);
void main()
{
    DWORD  dwErrCde;
    ULONG  lDevNum;
    long   lDriverHandle;
    USHORT usChan;
float  fOutValue;
PT_AOVoltageOut tAOVoltageOut;
    //Step 1: Display hardware and software settings for running this example
    printf("Before running this example, please\n");
    printf("use the device installation utility to add the device.\n");
    //Step 2: Input parameters
    printf("\nPlease input parameters:");
    printf("\nDevice Number (check the device installation utility): ");
    scanf("%d", &lDevNum);
    printf("\nOutput Channel: ");
    scanf("%d", &usChan);
    printf("\nOutput Value: ");
    scanf("%f", &fOutValue);
    //Step 3: Open device
    dwErrCde = DRV_DeviceOpen(lDevNum, &lDriverHandle);   
    if (dwErrCde != SUCCESS)
    {
        ErrorHandler(dwErrCde);
        printf("Program terminated!\n");
        printf("Press any key to exit....");
        getch();
        exit(1);
    }
    // Step 4: Output value to the specified channel
    tAOVoltageOut.chan = usChan;
    tAOVoltageOut.OutputValue = fOutValue;
    dwErrCde = DRV_AOVoltageOut(lDriverHandle, &tAOVoltageOut);
    if (dwErrCde != SUCCESS)
    {
        ErrorStop(&lDriverHandle, dwErrCde);
        printf("Press any key to exit....");
        getch();
        return;
    }
    // Step 5: Display ouptut data
    printf("\nOutput data = %f\n", fOutValue);
    // Step 6: Close device
    dwErrCde = DRV_DeviceClose(&lDriverHandle);
    printf("\nPress any key to exit....");
    getch();
}//main
/***********************************************************************
 * Function: ErrorHandler                                              *
 *           Show the error message for the corresponding error code   *
 * input:    dwErrCde, IN, Error code                                  *
 * return:   none                                                      *
 **********************************************************************/
void ErrorHandler(DWORD dwErrCde)
{
    char szErrMsg[180];
    DRV_GetErrorMessage(dwErrCde, szErrMsg);
    printf("\nError(%d): %s\n", dwErrCde & 0xffff, szErrMsg);
}//ErrorHandler
/*
 ***************************************************************************
 * Function:   ErrorStop                                                   *
 *             Release all resource and terminate program if error occurs  *
 * Paramaters: pDrvHandle, IN/OUT, pointer to Driver handle                *
 *             dwErrCde, IN, Error code.                                   *
 * return:     none                                                        *
 ***************************************************************************
*/
void ErrorStop(long *pDrvHandle, DWORD dwErrCde)
{
    //Error message 
    ErrorHandler(dwErrCde);
    printf("Program terminated!\n");
    //Close device
    DRV_DeviceClose(pDrvHandle);
}//ErrorStop

5 . 4 mérési feladat : PCI-1720 D/A kártya használata

A feladat a kártya 3-as csatornájának 5 Volt értékre való beállítása. Tulajdonképpen ez az 5 Volt teszi lehetővé a szervohajtás működését.

Szükséges lépések:

(olvasmány)

Real Time eXtension (RTX) for Control of Windows egy optimalizált bővítmény a Windows operációs rendszerhez. Nem egy valós idejű operációs rendszer ( Real Time Operating System) amit Windowsra portoltak. Az RTX precíz irányítást enged IRQ-k (Interrupt Request: megszakítási kérések), I/O, és memória felett, hogy biztosítsa az egyes feladatok megfelelő sorrendben és 100% biztossággal való végrehajtását. A Ring 0-ban való működtetés alatt az RTX biztosítja a legmagasabb teljesítményt és csak minimális beállítást igényel, biztosítva a 30Khz-es interruptokat 1 mikroszekundomos IST késési átlaggal. RTX egy igazi Windows bővítmény, alkalmazza az összes standard Windows szabványt, az API-kat, memória kezelést, SRI-ket, mutexeket, és a Windows fejlesztők számára ismert szemafórokat. Az RTX alkalmazás ki tudja használni a Windows és a Ring 3-ban lévő Intel architektúra által biztosított memóriavédelmi mechanizmusokat. Amint a fejlesztő kész a hibakereséssel és megbizonyosodik arról, hogy a memória mutatók és tömbök helyesek, az RTX alkalmazást azonnal újra lehet fordítani, hogy Ring 0-ban fusson az optimális teljesítményért. Ez a fő architektúra, amely az 5-12. ábrán látható.

Az RTX architektúra egy valódi kiegészítés, ami nem foglalja magába a Windows-t és nem avatkozik bele, vagy módosítja bármely elemét. Az elkülönítéssel az RTX valós idejű szub-rendszer (RTSS) biztosítja, hogy az RTX alapú alkalmazások túléljék a Windows összeomlásait, vagy „kék halálait”. Az RTX RTSS kernel egy nagy sebességű időzítőre lett tervezve, amik mind preemptikus, mind körbenforgó (round-robin) algoritmust használnak. Az RTX 1000 független folyamatot tud támogatni, amelyben minden folyamat korlátlan szálat támogat. Az alkalmazások finom vezérlését a 256 szintes szálprioritás beállítása biztosítja. Az ütemező azt garantálja, hogy a kritikus szál 500 nanoszekundumos prioritással vegye át a vezérlést. Az RTX folyamatok és Win32 alkalmazások közötti adatkommunikáció megkönnyítésére az RTX egy nagy teljesítményű üzenetküldő és szinkronizációs IPC mechanizmust használ. Egy megosztott memória modell használatával az IPC nagy mennyiségű adat átadására képes anélkül, hogy a teljesítmény csökkenne. Valós idejű rendszerben az esemény pontos végrehajtása kritikus. A pontosság elérése érdekében az RTX három órát használ, amelyekre alapozza az esemény időzítését. Az óra felbontása, a használt órától függően, akár 0,001 nanoszekundumos is lehet, anélkül, hogy bármilyen elcsúszás adódna.

5 . 5 mérési feladat : Egy szinuszos feszültség-idő függvény megjelenítése a PCI 1720 A/D kártya kimenetén

Meg kell határozni az összefüggést a mintavételi idő és a szinusz hullám között (3 Voltos amplitúdóval 1HZ-es frekvencián). A mintavételezés 0-tól kezdődik és a CurrentTime változón keresztül érhető el a programból. Ezt a váltózót a time_array[tickCount] változóval lehet elérni, ami 100 nanoszekundumos egységű adatot ad vissza.

Szükséges lépések:

Függvény hívása: status = DRV_DeviceOpen(DeviceNum, DriverHandle)

Rendeltetése: megszerzi az eszköz működtetéséhez szükséges paramétereket a regiszter ill. konfigurációs fájlból, és lefoglalja a memóriát a gyors hivatkozáshoz. Ezt a függvényt minden más függvény előtt meg kell hívni.

Eredmény:

Megjegyzések:

Függvény meghívása: status = DRV_CounterReset(DriverHandle, counter)

Rendeltetése: Kikapcsolja az adott számláló műveletet.

Eredmény:

Függvény meghívása: status = DRV_CounterEventStart(DriverHandle, lpCounterEventStart)

Rendeltetése: Konfigurálja a kiválasztott számlálót a feladatra és elindítja azt.

Eredmény:

Műveletek:

Függvény meghívása: status = DRV_CounterEventRead(DriverHandle, lpCounterEventRead)

Rendeltetése:Kiolvassa a jelenlegi számláló összeget anélkül, hogy a számlálást megzavarná és visszaadja a számláló és túlcsordulás feltételeit.

Eredmény:

Megjegyzés:

A paraméterek nevei a bemutatott példában eltérnek a mérésben valójában használt nevektől. Nem szabad egyszerűen kivágni és beilleszteni a részeket a példából.

/*
*****************************************************************************
 * Program           : COUNTER.CPP                                          *
 * Description       : Demo program for counter function                    *
 * Boards Supp.      :                                                      *
 * APIs used         : DRV_DeviceOpen,DRV_DeviceClose, DRV_GetErrorMessage, *
 * DRV_CounterReset, DRV_CounterEventStart, DRV_CounterEventRead            *
 * Revision          : 1.00                                                 *
 * Date              : 7/8/1999                   Advantech Co., Ltd.       *
 ****************************************************************************
 */
#include <windows.h>
#include <windef.h>
#include <stdio.h>
#include <conio.h>
#include "..\..\..\..\include\driver.h"
/******************************                                          
 * Local function declaration *                                          
 ******************************/                                         
void ErrorHandler(DWORD dwErrCde);
void ErrorStop(long*, DWORD);
void main()
{
    DWORD  dwErrCde;
    ULONG  lDevNum;
    long   lDriverHandle;
    USHORT wChannel = 0;  
USHORT wOverflow = 0;         // counter over 32 bit flag
ULONG  dwReading = 0;   
PT_CounterEventStart tCounterEventStart;
    PT_CounterEventRead  tCounterEventRead;
    //Step 1: Display hardware and software settings for running this example
    printf("Before running this example, please\n");
    printf("use the device installation utility to add the device.\n");
    //Step 2: Input parameters
    printf("\nPlease input parameters:");
    printf("\nDevice Number (check the device installation utility): ");
    scanf("%d", &lDevNum);
    printf("\nInput Channel: ");
    scanf("\n%d", &wChannel);
    //Step 3: Open device
    dwErrCde = DRV_DeviceOpen(lDevNum, &lDriverHandle);   
    if (dwErrCde != SUCCESS)
    {
        ErrorHandler(dwErrCde);
        printf("Program terminated!\n");
        printf("Press any key to exit....");
        getch();
        exit(1);
    }
    // Step 4: Reset counter by DRV_CounterReset
dwErrCde = DRV_CounterReset(lDriverHandle, wChannel);
    if (dwErrCde != SUCCESS)
    {
        ErrorHandler(dwErrCde);
        printf("Program terminated!\n");
        printf("Press any key to exit....");
        getch();
        exit(1);
    }
    // Step 5: Start counting operation by DRV_CounterEventStart
tCounterEventStart.counter = wChannel;
    dwErrCde = DRV_CounterEventStart(lDriverHandle, &tCounterEventStart);
    if (dwErrCde != SUCCESS)
    {
        ErrorHandler(dwErrCde);
        printf("Program terminated!\n");
        printf("Press any key to exit....");
        getch();
        exit(1);
    }
    // Step 6: Read counter values by DRV_CounterEventRead in while loop
    //         and display counter value, exit when pressing any key
tCounterEventRead.counter = wChannel;
    tCounterEventRead.overflow = &wOverflow;
    tCounterEventRead.count = &dwReading;
    while( !kbhit() )
    {
       dwErrCde = DRV_CounterEventRead(lDriverHandle, &tCounterEventRead);
       if (dwErrCde != SUCCESS)
       {
          ErrorStop(&lDriverHandle, dwErrCde);
          return;
       }
       printf("\nCounter value = %lu", dwReading);
       Sleep(1000);
    }       
    // Step 7: Stop counter by DRV_CounterReset
dwErrCde = DRV_CounterReset(lDriverHandle, wChannel);
    if (dwErrCde != SUCCESS)
    {
        ErrorHandler(dwErrCde);
        printf("Program terminated!\n");
        printf("Press any key to exit....");
        getch();
        exit(1);
    }
    // Step 8: Close device
    dwErrCde = DRV_DeviceClose(&lDriverHandle);
    getch();
    printf("\nPress any key to exit....");
    getch();
}//main
/*
***********************************************************************
 * Function: ErrorHandler                                             *
 *           Show the error message for the corresponding error code  *
 * input:    dwErrCde, IN, Error code                                 *
 * return:   none                                                     *
 **********************************************************************
*/
void ErrorHandler(DWORD dwErrCde)
{
    char szErrMsg[180];
    DRV_GetErrorMessage(dwErrCde, szErrMsg);
    printf("\nError(%d): %s\n", dwErrCde & 0xffff, szErrMsg);
}//ErrorHandler
/*
 ****************************************************************************
 * Function:   ErrorStop                                                    *
 *             Release all resource and terminate program if error occurs   *
 * Paramaters: pDrvHandle, IN/OUT, pointer to Driver handle                 *
 *             dwErrCde, IN, Error code.                                    *
 * return:     none                                                         *
 ****************************************************************************
*/
void ErrorStop(long *pDrvHandle, DWORD dwErrCde)
{
    //Error message 
    ErrorHandler(dwErrCde);
    printf("Program terminated!\n");
    //Close device
    DRV_DeviceClose(pDrvHandle);
    printf("Press any key to exit....");
    getch();
    exit(1);
}//ErrorStop

5 . 10 mérési feladat a PCI 1784-es kártya használata

A feladat a számláló értékének beolvasása a PCI 1784-es kártya 3-as csatornájáról.

Szükséges lépések:

Az elméleti hátteret számos animált dián mutatjuk be. Ez egy rövidített ismétlés a DC motor tárgykörnek a “INETELE Interactive and Unified E-Based Education and Training for Electrical Engineering” című számítógépes tananyagból.

Ez a fejezet a DC motor matematikai modelljét ismerteti 3 fő fejezetben:

Az szögsebesség-idő függvénye nagyon zajos, mert a pozíciójelből digitális deriválási művelettel kapjuk. A deriválás általában kiemeli a zajokat, és ezt a méréseknél a gyakorlatban is tapasztalni fogjuk. Általában, ha lehet, akkor a deriválást kerülni szoktuk. pl. kevésbé zajos jelet kapnánk, ha a fordulatszámot közvetlenül érzékelnénk. Ha erre nincs mód, akkor a zajos jelet célszerű szűrni egy aluláteresztő szűrővel, például a következő módon.

Tekintsük a rendszer bemenetének a mért , kimenetének a szűrt szögsebességet.

Tegyük fel, hogy sorba kapcsolunk 3 db elsőfokú aluláteresztő szűrűt, azonos időállandóval. A szűrő átviteli függvénye

Átrendezve

Inverz Laplace-transzformálva

ahol Tc a vágási körfrekvencia reciproka és a pont jelöli ( ) az idő szerinti deriváltat. A szűrő állapottér egyenlete (5.33) alapján:

Az állapottér egyenlet (5.34) leírható diszkrét alakban.

Ahol k a k-dik mintavételezés rövidítése és a rendszermátrix elemei (ai és bi) kiszámíthatók a MATLAB “c2d” függvényével, ami “continuous to discrete”, vagy folytonos-diszkrét rövidítése.

[Ad, Bd] = c2d(A, B, tsample);

ahol tsample a mintavételezési periódus és Tc szűrő időállandója

A értékének meghatározásához abból indulhatunk ki, hogy a fordulatszám jelhez adódó zaj abból adódik, hogy két pozíciójel különbségéből számítjuk. A pozíciójelet a számlálóból olvassuk ki, ami az enkóderből érkező impulzusokat számlálja. Az enkóderből érkező jelek értelemszerűen nincsenek szinkronizálva a számláló értékének beolvasásával. Ezért előfordulhat, hogy egyszer pont egy enkóderből származó impulzus érkezése előtt, egyszer pont utána olvassuk ki a számláló értékét, így állandó szögsebesség esetén is két különböző értéket fogunk kiszámítani. Elképzelhető, hogy minden beolvasásánál a hiba előjelet vált, így a zaj periódus idejét jól közelíthetjük a mintavételi idő kétszeresével. Ebből már meghatározhatjuk a zaj frekvenciáját, illetve körfrekvenciáját, mivel a szűrő tervezéséhez ez utóbbira van szükség. Esetünkben

Az aluláteresztő szűrő vágási frekvenciáját ennél kisebbre kell beállítani. Ha egy dekáddal kisebbre állítjuk be, akkor az egy harmadjajú szűrő esetén kb. ezred részére képes csökkenti a zajt. a vágási körfrekvencia reciproka, ezért legyen a választásunk a következő

A diszkrét idejű szűrő együtthatóit meghatározó és a C kódot generáló MATLAB program

Ts = 0.001;
Tc = 1/(2*pi*1/(2*Ts)/10);
 
A = [0, 1, 0;
     0, 0, 1;
     -1/Tc^3, -3/Tc^2, -3/Tc];
 
B = [0;0;1/Tc^3];
 
[Ad,Bd] = c2d(A,B,Ts);
 
for i = 1:3
    for j = 1:3
        disp(['float ad',num2str(i),num2str(j),' = ', num2str(Ad(i,j)),';']);
    end
end
 
for i = 1:3
    disp(['float bd',num2str(i),'  = ', num2str(Bd(i)),';']);
end
Eredmény
float ad11 = 0.99591;
float ad12 = 0.00095987;
float ad13 = 3.652e-007;
float ad21 = -11.3235;
float ad22 = 0.88778;
float ad23 = 0.00061567;
float ad31 = -19089.6748;
float ad32 = -193.6165;
float ad33 = 0.30752;
float bd1  = 0.0040906;
float bd2  = 11.3235;
float bd3  = 19089.6748;

A szűrő mellékhatása, hogy növeli a rendszer fáziseltolását. E problémán javíthatunk, ha egy más típusú szűrőt alkalmazunk.

Vizsgáljunk meg egy harmadrendű Bessel szűrőt. A harmadrendű Bessel szűrő átviteli függvénye:

Ts = 0.001;
Tc = 1/(2*pi*1/(2*Ts)/10);
A = [0, 1, 0;
     0, 0, 1;
     -15/Tc^3, -15/Tc^2, -6/Tc];
 
B = [0;0;15/Tc^3];
 
[Ad,Bd] = c2d(A,B,Ts);
 
for i = 1:3
    for j = 1:3
        disp(['float ad',num2str(i),num2str(j),' = ',num2str(Ad(i,j)),';'])
    end
end
 
for i = 1:3
    disp(['float bd',num2str(i),'  = ', num2str(Bd(i)),';']);
end

Eredmény

float ad11 = 0.95193;
float ad12 = 0.00083371;
float ad13 = 2.6009e-007;
float ad21 = -120.9668;
float ad22 = 0.56688;
float ad23 = 0.00034345;
float ad31 = -159737.83;
float ad32 = -629.4281;
float ad33 = -0.080513;
float bd1  = 0.048071;
float bd2  = 120.9668;
float bd3  = 159737.83;

Vizsgáljunk meg egy ötödrendű Bessel szűrőt. Az ötödrendű Bessel szűrő átviteli függvénye:

A diszkrét idejű szűrő együtthatóit meghatározó és a C kódot generáló MATLAB program

Ts = 0.001;
Tc = 1/(2*pi*1/(2*Ts)/10);
A = [0, 1, 0, 0, 0;
     0, 0, 1, 0, 0;
     0, 0, 0, 1, 0;
     0, 0, 0, 0, 1;
     -945/Tc^5, -945/Tc^4, -420/Tc^3, -105/Tc^2, -15/Tc];
 
B = [0;0;0;0;945/Tc^5];
 
[Ad,Bd] = c2d(A,B,Ts);
 
for i = 1:5
    for j = 1:5
        disp(['float ad',num2str(i),num2str(j),' = ',num2str(Ad(i,j)),';'])
    end
end
 
for i = 1:5
    disp(['float bd',num2str(i),'  = ', num2str(Bd(i)),';']);
end

Eredmény

float ad11 = 2.3749;
float ad12 = 0.0060369;
float ad13 = 8.9952e-006;
float ad14 = 8.7509e-009;
float ad15 = -2.4834e-013;
float ad21 = -55.9541;
float ad22 = 0.80926;
float ad23 = 0.00070548;
float ad24 = 2.3492e-007;
float ad25 = 6.3994e-011;
float ad31 = -185062.4462;
float ad32 = -645.0082;
float ad33 = -0.024158;
float ad34 = 4.2341e-005;
float ad35 = 1.3387e-007;
float ad41 = -387151871.8085;
float ad42 = -1417349.3637;
float ad43 = -2388.3942;
float ad44 = -1.4113;
float ad45 = 7.4665e-005;
float ad51 = -215947384065.4345;
float ad52 = -1074421228.8149;
float ad53 = -2389749.1508;
float ad54 = -3161.8599;
float ad55 = -0.37582;
float bd1  = -1.3925e-005;
float bd2  = 0.00056689;
float bd3  = 1.8749;
float bd4  = 3922.0853;
float bd5  = 2186784.2468;

A CalculateController függvényt a valós idejű óra minden jelére meghívja a keretprogram. A saját szabályozó algoritmusát a következő programba írhatja bele:

#include <windows.h>
#include <stdio.h>
#include <rtapi.h>
#include <math.h>
#include <string.h>
#define PI 3.14159265358979323846
typedef struct
{   
float Position;
float Velocity;
float Torque;
float StateVariable_5;
float StateVariable_6;
float StateVariable_7;
float StateVariable_8;
float StateVariable_9;
float StateVariable_10;
} NewControllerData;
NewControllerData CalculateController(
const float CurrentPosition,
const float OldPosition,
const float OldVelocity,
const float CurrentTime,
const float OldTime,
const float Old_StateVariable_5,
const float Old_StateVariable_6,
const float Old_StateVariable_7,
const float Old_StateVariable_8,
const float Old_StateVariable_9,
const float Old_StateVariable_10
)
{
NewControllerData ResultData; // result
//Declaration of your controller
// Position is saved automatically
ResultData.Position = CurrentPosition;
// Angular velocity is saved automatically
if (CurrentTime != 0.0f){
ResultData.Velocity = (1000.0f * (float)(CurrentPosition - OldPosition)/(float)(CurrentTime - OldTime));
}
else {
ResultData.Velocity = 0.0f;
}
//Calculation of your controller
return ResultData;
}

A pirossal írt részek helyére kell a saját programot elhelyezni. A változók új értékeit és minden számítást ezen a függvényen belül kell megadni. A motor állapotát a keretprogram kiszámítja és a következő változókban tárolja:

ResultData.Position: pozíció

ResultData.Velocity: szögsebesség

ResultData.Time: az aktuális idő

Biztonsági okokból a motor bemeneti feszültségét nem lehet direkt módon állítani. Az irányítóprogram kimenete, amely a kimenő jel a D/A kártyán a referencia áram-jel. Ez referencia nyomaték-jelnek is tekinthető. A saját programunkban kell, hogy legyen a következő értékadás:

ResultData.Torque = …

A felhasználónak az értéket a “your controller program” végén kell beállítania. Például:

ResultData.Torque = 1;

azt jelenti, hogy a tengelyen a nyomaték (a fogaskerék után) 1 Nm-re lett állítva. Mivel a D/A kártya kimenete feszültség, a keretprogram kiszámolja a megfelelő feszültség értéket a ResultData.Torque-ból, amely a kimeneti jel lesz.

Ebben a feladatban nyílt hurkú méréseket végzünk a DC motoron. Maximum 10 állapotváltozó választható ki Matlab formátumban történő mentésre. A 10-ből 4 állapotváltozó kötött: az idő, a pozíció, a szögsebesség és a motor nyomatéka.

Ha az állapotváltozó hibát kívánja menteni, az alábbiakat kell tennie:

Írja be az állapotváltozó nevét vel_filt (szűrt sebesség) az ötödik sorba a következő formában:

5. vel_filt

Írja be a változó deklarációját:

float vel_filt;

Írja be a következőt a parancs dobozba:

Vel_filt = (ki kell számítani a szűrt sebesség értékét)

ResultData.StateVariable_5 = vel_filt;

A mérés után a vel_filt állapotváltozó is letölthető.

Hajtsa végre a feladatokat nyílt körre és hasonlítsa össze őket a P, és PI szabályozókkal.

Az eredményfájlok, amelyek a mérés végén letölthetők, MATLAB-ban kiértékelhetők. Erre a feladatra már írtunk egy programot, amely kirajzolja a tengelysebesség-idő, feszültség-idő és pozíció-idő diagramjait. Ezek a diagramok .jpg formátumban menthetők el további dokumentációkhoz.

MEGJEGYZÉS:

A szabályozó programot minden egyes mintavételező periódusban meghívja a keretprogram. A függvény végrehajtása után minden változó (kivéve a ResultData.Time, ResultData.Velocity,ResultData.Position ResultData.Torque és ResultData.StateVariable_5-10) felszabadul (avagy az értékek elvesznek). Ha szükséges egy változó a következő mintavételező periódusban is, akkor statikus típusú változóként kell deklarálni. Például:

static float vel_filt;

Általános lépések szükségesek:

Segítségképp az első három laboratóriumi gyakorlaton megismert két kártyát a keretprogram inicializálja. Csak a fentebb leírt lépések szükségesek a sikeres laboratóriumi mérés végrehajtásához.

5 . 11 mérési feladat : K onstans nyomaték kiadása

Az első feladatban az elektromos nyomaték értéke:

Ezúton a különböző motor-változók különböző nyomatékjel lépés-változásaira kapott lépés válaszai kaphatók meg. Az eredmény fájlok, amelyek a mérés végén letölthetők, Matlabban kiszámíthatók. Erre a feladatra már van egy program. A program futtatásával az eredményeket megkapjuk tengelysebesség-idő, feszültség-idő és pozíció-idő diagramokon. Ezeket a diagramokat .jpg formátumban lehet elmenteni a további dokumentáció érdekében.

5 . 12 mérési feladat : K onstans nyomaték kiadása és a fordulatszám szűrése

Az előző feladathoz hasonlóan a nyomaték legyen a következő:

Alkalmazza az 5.9.5 pontban leírt digitális szűrőket. Legyen a töréspont helye

5 . 13 mérési feladat : A motor válasza szinuszos nyomatékra és a szervoerősítő offset kompenzációja

A szervoerősítőnek (mint minden műveleti erősítőnek) van egy offset feszültsége. Ez akkor a legszembetűnőbb, ha szinuszos feszültséget alkalmazunk. Ebben az esetben a motortól azt várjuk, hogy szinuszos legyen a tengely szögsebessége és ebből adódóan, szinuszos pozícióváltozása. Az offset feszültséget célszerű hardveresen kompenzálni, de kompenzálhatjuk szoftveresen is.

5 . 14 mérési feladat : Digitális szűrő

Az animáció bemutatja a P, PI, PID szabályozókat és az egymás közötti különbségeket.

“P”:

“PI”:

“PID”:

Animált magyarázat a fázistartalék meghatározására: Az amplitúdó diagramon a 0 szinten, egy piros vízszintes vonal jelenik meg. Azon a ponton, ahol a piros vonal keresztezi az amplitúdó görbéjét, egy függőleges vonal megy le a fázisdiagramig. Abban a pontban, ahol ez a vonal keresztezi a fázisgörbét, egy vízszintes vonal mutatja a pillanatnyi fázis értékét. A végén megjelenik a fázistartalék, amit az alábbiak szerint számolhatunk:

Ezt a dimenzióvonal mutatja a fázis tengelyen.

A dia elmagyarázza a PI szabályozó használatát. A motor és a szabályozó átviteli függvénye 1 közelítéssel:

Megválasztva, hogy legyen: az átviteli függvény:

Végül és AP meghatározása a fázistartalék megválasztásával.

Az animáció mutatja Ap meghatározását, 30...60o fázistartalékát (stabil, sima működésnél) egy fordított, nem analitikus módon, ahol a Bode diagramokon látszik a fázistartalék. A felhasználó 0.5 és 3.5 között változtathatja Ap –t és megfigyelhetőek a különböző fáziseltolások hatásai a fázistartalékon. Az animáció az előzetesen bemutatott példa alapján rajzolja ki a grafikonokat. Ap 0.5 és 3.5 között 7 fokozatban állítható (0.5; 1.0; 1.5; 2.0; 2.5; 3.0; 3.5).

A szimuláció során használt paraméterek:

MatLab utasítások:

g = tf([Api/Kfi],[Tpi*Te Tpi 0]);

bode(g);

A dia a nyílt és visszacsatolt hurkú átviteli függvényeket mutatja be ismét. PI szabályozót használ és TPI= Tm.

Az egyenletek (levezetések nélkül) az alábbiak:

Az animáció a sebesség referencia-jel lépésszerű változására a rendszer által adott választ mutatja be.

Megjegyzendő, hogy növekvő Ap nem eredményez túllendülést. Az animáció az előzetesen használt grafikonokat és eredményeket használja. Ap 0.5 és 3.5 közt 7 fokozatban változtatható (0.5; 1.0; 1.5; 2.0; 2.5; 3.0; 3.5).

A szimuláció MatLab Simulink segítségével készült, a szimulációs beállítást az 5-35. ábra mutatja.

A motor és PI szabályozó elrendezése egy feedback hurokban látható az 5-37. ábra alapján.

A felhasználó megfigyelheti, hogy AP növelésével a rendszer túllendülése is nő.

A dia a zavarérzéketlenség hatását mutatja. Egy lépésszerű nyomatékterhelést kapcsolunk t = 5s időpillanatban a bemenetre. Az animáció összehasonlítja a szabályozó sebesség értékét különböző Ap értékeknél. Ap 0.5 és 3.5 között 8 fokozatban változtatható (0.5; 0.7; 1.0; 1.5; 2.0; 2.5; 3.0; 3.5). AP = 0.7 azért adódik, mert a különbség 0.5 és 1.0 között túl nagy.

Ez a fejezet röviden ismerteti az áramszabályozó működését. Részletes blokkdiagramot tartalmaz a motorról és szabályozókról (sebesség és áram), valamint a szabályozók egyenleteiről.

Sebességszabályozó:

Áramszabályozó:

A dia azt mutatja, miért hanyagolható el a motor visszahatása. Segít azonosítani a lényeges és nem lényeges elemeket. A motor belső visszahatása elhanyagolható, mert az áramszabályozó sokkal gyorsabb működésű, mint a mechanikus szabályozó. Ezért a belső visszahatás zavarként kezelhető, amely lassan változik, a szabályozó kiküszöböli a hibát, amit a D motor pontatlan modellje okoz.

A dia a szabályozó működéséhez szüksége egyenleteket mutatja.

A fenti dia leírja a rendszer nyílt hurkú átviteli függvényét.

További részletekért látogasson el az alábbi animációs oldalra:

http://dind.mogi.bme.hu/animation/

A módszer célja, hogy a PID szabályozó paramétereit egy egyszerű teszttel választhassuk meg. Vannak esetek, amikor a szabályozott szakasz paraméterei nem ismertek, ezért a PID szabályozót próbálgatással, kísérletileg kell behangolni. Több olyan módszer ismert, amely a próbálgatások hatékonyságát növeli. Az egyik legnépszerűbb módszert Ziegler és Nichols dolgozta ki [48]. Elsősorban időkésleltetéssel rendelkező rendszerekhez alkalmazható, de gyakorlatilag minden szabályozó gyártó használta a módszert kisebb módosításokkal beállítási ajánlásaik elkészítéséhez. Népszerűségének oka az, hogy egyszerű megtanulni és elmagyarázni. A módszert egy egyenáramú szervomotor fordulatszám szabályozó körének kísérleti behangolásán keresztül mutatjuk be. A példában egy fordulatszám szabályozó behangolását mutatjuk be. A szabályozó algoritmus a motor armatúra áramának az alapjelét határozza meg. A program kiszámítja és kiadja a motor áramreferencia jelét, a motor áramszabályozóhurkához (amely az áramkorlátozást is megvalósítja) biztonsági okokból nem férünk hozzá. A motor tényleges árama a szabályozási idő leteltével éri el a referencia értéket. Maga a rendszer két energiatárolós szakasznak tekinthető, ezért a motor önmagában strukturálisan stabilis (így a Ziegler-Nichols módszer nem lenne alkalmazható), de a fordulatszám jelet digitális szűréssel állítjuk elő, így a motor az alkalmazott harmadfokú szűrő algoritmussal együtt már egy öt energiatárolós rendszernek tekinthető. Természetesen ez csak akkor igaz, ha a szűrt jelet használjuk fel a hiba előállításához.

Feladatok a hangolás során:

Először teszteljük, hogy a szükséges P tag negatív vagy pozitív. Kapcsoljuk a szabályozót csak P módra, avagy kapcsoljuk ki az I és D funkciókat. A bemeneti feszültséget kapcsoljuk nyílt körbe (hibajel), növeljük kicsit manuális vezérléssel, hogy lássuk az állandósult állapotú rendszer kimenetének értéke is növekedett. Ha ez így van, akkor az állandósult rendszer erősítése pozitív, avagy a P szabályozó AP-értékének is pozitívnak kell lennie, különben (ha csökkent), AP negatív lesz.

Változtassuk a szabályozó erősítését, AP –t lassan (növeljük, ha AP pozitív volt, és csökkentsük, ha AP negatív volt) és figyeljük a kimeneten adott választ. Megjegyezzük, hogy ez AP lépésenkénti változtatásával jár majd, a lépések után meg kell várni az állandósult állapotot, mielőtt AP –t újból megváltoztatnánk.

Legyen az AP kritikus (ultimate) értéke AU, amikor a kimeneten állandósult lengőjel alakul ki. Mérjük meg ennek a periódusidejét is, és nevezzük el TU-nak, (ld. 5-44. ábra). TU a határperiódusidő.

Az AU határerősítést és a TU határperiódusidőt felhasználva Ziegler és Nichols módszere a következő AP, TI és TD, értékeket javasolja a szabályozó típusától függően:

A következőkben különböző vezérlés típusokat vizsgálunk.

Ebben a gyakorlatban először P, majd PI és a legvégén PID sebességszabályozót állítunk be a DC motornak.

Lépések:

5 . 16 mérési feladat : A Ziegler-Nichols módszer ún. ultimate körerősítésének meghatározása

Készítsen egy P szabályozót és fokozatosan növelje a P értékét a stabilitás határáig, amikor a fordulatszám jelben közel állandó amplitúdójú lengések ki nem alakulnak. Fontos megjegyzés, hogy az ultimate körerősítés erősen függ az alkalmazott szűrő típusától és annak vágási frekvenciájától. Ezt a feladatot végezze el különböző szűrőkkel.

5 . 17 mérési feladat : P szabályozó

Vizsgálja meg a P szabályozó működését Ω = 7 rad/s tengelysebesség mellett.

5 . 18 mérési feladat : P szabályozó v áltozó alapjel lel

Az 5.17 kibővítése, azzal a különbséggel, hogy először Ω = 4 rad/s t = 0 s-mál, majd Ω = 2 rad/s t = 2 s-mál és végül Ω = 6 rad/s t = 4 s-nál.

5 . 19 mérési feladat : P szabályozó t erhelésrádobás sal

Vizsgálja meg a P szabályozó zavarérzéketlenségét. A zavart t = 0.5 s-ban adjuk a rendszerre, mint negatív nyomatékot T_load= -0.5, amely kivonódik a szabályozó által számolt kimeneti feszültségből.

ResultData.Torque = (kérjük, írja ide a szabályozóját)

ResultData.Torque = ResultData.Torque + T_load; /* ez a virtuális terhelés sora*/

5 . 20 mérési feladat : PI szabályozó

Vizsgálja meg a PI szabályozó működését Ω = 7 rad/s tengelysebesség mellett.

5 . 21 mérési feladat : PI szabályozó változó alapjel lel

Legyen először Ω = 4 rad/s t = 0 s-nál, majd Ω = 2 rad/s t = 2 s-nál, és végül Ω = 6 rad/s t = 4 s-nál.

5 . 22 mérési feladat : PI szabályozó terhelésrádobás sal

Vizsgálja meg a PI szabályozó zavarérzéketlenségét. A zavart t = 0.5 s-ban adjuk a rendszerre, mint negatív nyomatékot T_load= -0.5, amely kivonódik a szabályozó által számolt kimeneti feszültségből.

ResultData.Torque = (kérjük, írja ide a szabályozóját)

ResultData.Torque = ResultData.Torque + T_load; /* ez a virtuális terhelés sora*/

5 . 23 mérési feladat : A nti windup PI szabályozó

A PI szabályozó hibatoleranciája (maradó hiba mentes PI szabályozó)

Szimuláljunk hibát, amikor a motor megakad, vagy az elektromos egység meghibásodik és a nyomaték 0, miközben a PI szabályozó működik. Az integrál tag növekszik. A hiba után az a integráló tag értékét le kell csökkenteni (a pozitív hiba közben integráló tag értéke nagyon megnövekedhet, amelyet egy negatív hibával lehet csökkenteni).

Először hangoljuk be a PI szabályozót (állítsuk be a mérés hosszát 1000 ms-ra), és adjuk a következő sort a szabályozóhoz:

if ( CurrentTime < 0.3*1e3) {ResultData.Torque = 0.0;}

Az integrálótag értékének növekedését alapvetően két módon korlátozhatjuk. Egyrészt közvetlen korláttal, másrészt az integrátort célszerű kikapcsolni akkor, amikor a szabályozó telítésben működik. Hasonlítsa össze normál PI és az anti windup funkcióval kiegészített PI szabályozó működését.

5 . 24 mérési feladat : Ziegler-Nichols módszer időkésleltetés beiktatással

Készítsen egy P szabályozót, de a kiszámított nyomaték jelet őrizze meg 10 időlépésen keresztül, és csak azt követően adja ki a motorra. Használjon normál harmadfokú szűrőt paraméterrel. Fokozatosan növelje a P értékét a stabilitás határáig, amikor a fordulatszám jelben közel állandó amplitúdójú lengések ki nem alakulnak. A Ziegler-Nichols módszerrel határozza meg egy PI típusú szabályozó P és I paraméterét.

5 . 25 mérési feladat : E gy-hurkos P és PI szabályozó ugrás függvény válasza

Legyen a referencia pozíció jel 10 rad. A nyomatékot közvetlenül a pozíció hibából számolja, P illetve PI szabályozót alkalmazva.

5 . 26 mérési feladat : Stick-slip jelenség vizsgálata

Válassza meg a P és I paramétert úgy, hogy a motor ragadjon be a referencia pozíció előtt, és az integrátor lendítse túl a hibán.

5 . 27 mérési feladat : K aszkád sz abályozás

Az előző feladatban túllövés tapasztalható, aminek oka az, hogy idő szükséges a motor lelassításához, ha az elérte a referenciaértéket. Ezt a hatást megszüntethetjük, ha egy belső szögsebesség szabályozót is beiktatunk a rendszerbe. A szögsebesség referencia értéke a motor pozíció hibájából adódik. Ez azt jelenti, amint a motor közelít a referenciapozícióhoz, a referencia sebesség is elkezd csökkeni. Ez a nullához közelít már a véghelyzet közelében. A szabályozás hatásvázlata az alábbi ábrán látható. A pozíció szabályozó P és a sebességszabályozó PI típusú.

A fordulatszám szabályozó körében PI a pozíció szabályozó körben P szabályozót alkalmazzon.

5 . 28 mérési feladat : C súszómód szabályozó

Tervezzen csúszómód szabályozót a motor pozíciójához.

Ennek két fő lépése:

a csúszási felület megválasztása;

vezérlési törvény megválasztása.

A konstans referencia pozíció:

αref= 10 rad.

A pozíció és sebesség hibát

αe= αref – αmotor

Ωe= 0-Ωmotor .

értékekként deklaráljuk.

A csúszó felületet

σ=αe+λΩe

alapján választjuk.

A vezérlési törvény:

torque=0.1 sign σ.

Természetesen ezeket C kódban kell megírni. További részletes információért és új szabályozási módszerekért látogasson el az alábbi animációs oldalra:

http://dind.mogi.bme.hu/animation/

5 . 29 mérési feladat : Modellreferenc i ás adaptív szabályozó

Tervezzen modellreferenciás adaptív szabályozót a motor pozíciójához.