Laboration i industriella styrsystem PID-implementering i PLC Denna version: 16 april 2013 PID N7:0 N9:0 N9:2 REGLERTEKNIK Namn: Personnr: AUTOMATIC LINKÖPING CONTROL Datum: Godkänd:
Tabell 1. Godkännande Förberedelseuppgifter Uppgift Datum Godkänd 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 2
Innehåll 1 Introduktion 4 1.1 Tidsåtgång............................ 4 1.2 Examination............................ 4 2 Uppgiftsbeskrivning 5 2.1 Krav på den egna PID-regulatorn................ 5 2.2 Krav på det grafiska gränsnittet................. 6 2.3 Analys av implementationen................... 7 2.4 Frivilliga uppgifter........................ 7 3 Implementering av pid-regulator i plc 8 3.1 Diskretisering av pid-regulator.................. 8 3.2 Nedklockning........................... 10 3.3 Integratoruppvridningsskydd................... 12 3.4 Derivatafilter (Endast TSIU04)................. 13 3.5 Aritmetik med heltal....................... 14 3.5.1 Överspill.......................... 15 3.5.2 Skalning.......................... 16 4 Arbetsgång 17 4.1 Plan för minnesanvändning.................... 18 5 Förberedelseuppgifter 21 5.1 Integratoruppvridning...................... 21 5.2 Regulatorparametrar och skalning................ 22 5.3 Heltal och överspill........................ 23 5.4 Programmets struktur...................... 24 3
Kapitel 1 Introduktion Denna laboration är en fortsättning på laboration 1 i kursen TSIU04, där plc-koden och InTouch skall utökas med en egenimplementerad pid-regulator. Laborationen handlar därmed både om implementering av en pid-regulator och hur en plc kan programmeras. Syftet med labben är att få en djupare förståelse för pid-regulatorer i allmänhet och mer specifikt integratoruppvridning samt derivatafilter. 1.1 Tidsåtgång Förväntad tidsåtgång för laborationen är ca 12 h (exklusive förberedelsetid), varav 4 h utförs med tillgång till assistent under schemalagd tid. Notera att förberedelseuppgifterna förväntas ta ca 8 h. 1.2 Examination Förberedelseuppgifterna måste vara godkända senast dagen innan 1 laborationen. Dessa examineras genom att skriftligen och muntligen redogöra för svaren på uppgifterna i kapitel 5. Laborationen examineras genom att en labbhandledare går igenom kraven i kapitel 2 muntligt. Tid för examination bokas med respektive handledare. 1 Notera att om ni har labb på måndag eller tisdag måste det vara godkänt på fredagen veckan innan. 4
Kapitel 2 Uppgiftsbeskrivning Laborationens huvudsakliga målsättning är att implementera en egen diskret pid-regulator i plc:n. En ytterligare målsättning är att integrera denna regulator i det grafiska gränssnitt som utvecklades under laboration 1 samt att studera skillnader och likheter mellan dessa regulatorer. Centrala problem och begrepp i denna laboration är skalning, överspill, logiska villkor samt integratoruppvridning. Laborationen består av förberedelseuppgifter, där ni själva skapar ett färdigt stegkodsprogram på papper innan laborationen. Under den schemalagda tiden ska stegkodsprogrammet implementeras och provköras i plc:n samt det grafiska gränssnittet uppdateras med några ytterligare funktioner. Som tidigare genomförs laborationen till stor del på egen hand men en laborationshandledare kommer att vara närvarande för att svara på frågor och hjälpa till med praktiska problem. Utgå från de RSLogix- och InTouch-program som utvecklades under laboration 1 samt förberedelseuppgifterna för att lösa problemen i detta avsnitt. 2.1 Krav på den egna PID-regulatorn Utgå från stegkodsprogrammet som skapades under laboration 1 med de två utökningarna. Utöver de krav som ställdes i laboration 1, ställer vi nu ett antal ytterligare krav på er implementation av pid-regulatorn. Stegkodsprogrammet skall innehålla följande ytterligare funktionalitet: 1. Det ska vara möjligt att välja mellan den egen-implementerade och den inbyggda regulatorn genom flaggan N10:0/0. 5
2. Den egen-implementerade regulatorn ska: (a) kunna styra både den övre och undre tanken, vilken tank som styrs kontrolleras av flaggan N9:5/0 på samma sätt som för den inbyggda regulatorn i laboration 1. (b) styra pumpen med hjälp av en pid-återkoppling. (c) använda en långsam cykel för att uppdatera den integrerande och deriverande återkopplingen samt en snabb cykel för den proportionella återkopplingen. (d) hantera överspill i alla multiplikationer. (e) trunkera styrsignalen så att den hamnar inom rätt intervall. (f) implementera ett skydd mot integratoruppvridning, som kan inaktiveras genom flaggan N10:0/1. 3. (Endast TSIU04): Den egen-implementerade regulatorn ska: (a) Implementera ett derivatafilter på pid-regulatorn för att minska regulatorns bruskänslighet, som kan inaktiveras genom att sätta N = 0. 2.2 Krav på det grafiska gränsnittet Utgå från InTouch-gränsnittet som utvecklades under laboration 1. Under denna laboration ska ni vidareutveckla detta gränssnitt så att de utöver kraven från laboration 1 även uppfyller ett antal ytterligare krav. Det ska vara möjligt att: 4. välja om det är den egen-implementerade regulatorn eller den inbyggda som är används för att styra tanken, alltså styra flaggan N10:0/0. 5. följa den egenimplementerade pid-regulatorns I-del i en realtidstrendoch historiktrendkurva. Detta för att senare kunna studera hur väl integratoruppvridningsskyddet fungerar. 6. (Endast TSIU04): följa den egenimplementerade pid-regulatorns D-del i en realtidstrend- och historiktrendkurva. Detta för att senare kunna studera derivatafiltrets funktion. 7. nollställa I-delen, det vill säga kunna nollsätta N10:7. 6
8. stänga av skyddet mot integratoruppvridning från processdatorn, alltså styra flaggan N10:0/1. 9. (Endast TSIU04): stänga av derivatafiltret från processdatorn. 10. ställa in regulatorparametrar för den egna regulatorn från processdatorn. Notera att det är K och T I som skall ställas in från gränssnittet men det är K och R I som lagras i plc:n. 11. (Endast TSIU04): ställa in regulatorparametrar för den egna regulatorn från processdatorn. Notera att det är K, T I, T D och N som skall ställas in från gränssnittet men det är K, R I, R D och R N som lagras i plc:n. 2.3 Analys av implementationen Som avslutning på laborationen ska ni lösa följande uppgifter genom att använda er av stegkodsprogrammet och gränsnittet som utvecklas enligt ovanstående krav. 12. För övre tanken: (a) jämför prestanda för den egenimplementerade- och inbyggda pidregulatorn. Beter de sig på samma sätt? (b) utför ett antal stegsvarsexperiment med och utan integratoruppvridningsskydd. Förklara beteendet i de båda fallen. (c) på vilket sätt påverkar parametrarna K och T I hur lång överslängen blir när integratoruppvridningsskydd är inaktiverat? 13. För undre tanken, jämför regleringen med och utan D-del om regulator parametrarna bestäms med hjälp av λ-trimning. 2.4 Frivilliga uppgifter Vid ytterligare tid och intresse kan följande uppgifter vara intressanta att studera vidare. Observera att en pid-regulator troligen behövs för att kunna styra vattennivån i den undre tanken. Inför stötfri modomkoppling mellan manuell och automatisk styrning. 7
Kapitel 3 Implementering av pid-regulator i plc Det här kapitlet kommer introducera teori bakom diskretiseringen av en pidregulator samt ett antal utökningar för att hantera problem som uppstår med hårdvaran som används i laborationen. Efter varje teoristycke presenteras dessutom en algoritm för implementation. 3.1 Diskretisering av pid-regulator I det här avsnittet behandlas diskretisering av pid-regulatorn u(t) = Ke(t) + t t 0 K T I e(τ) dτ + KT D ė(t) (3.1) där e(t) = r(t) y(t) är det så kallade felet. För att gå från kontinuerlig till diskret tid, med samplingstidpunkter t k och samplingsintervall t k t k 1 = T s, utnyttjas en Euler approximation (bakåt) tk t 0 e(τ) dτ l k T s e(t l ), ė(t) e(t k) e(t k 1 ) T s vilket ger den diskreta beskrivningen av (3.1) u(t k ) = Ke(t k ) + l k T s T I Ke(t l ) KT D T s (y(t k ) y(t k 1 )), (3.2) 8
där r(t k ) r(t k 1 ) = 0, det vill säga, referensen antas vara konstant mellan olika samplingstidpunkter. Vanligtvis är det fördelaktigt att dela upp regulatorn i en del som bara beror på det nuvarande felet, e(t k ), och en del som även beror på tidigare fel och således har ett minne. Det ger beskrivningen i(t k ) = l k T s Ke(t l ) = R I e(t l ), T I l k d(t k ) = KT D T s (y(t k ) y(t k 1 )) = R D (y(t k ) y(t k 1 )), a(t k ) = i(t k ) + d(t k ), u(t k ) = Ke(t k ) + a(t k ). (3.3) Den här matematiska beskrivningen av regulatorn tar ingen hänsyn till den verkliga världen. I fysiska system så finns det begränsningar på hur stor styrsignalen, u(t k ), kan vara. I detta fall är det pumpen som sätter begränsningarna. Exempelvis så kan pumpen inte suga ut vatten, vilket ger en nedre begränsning på 0 och det finns en övre gräns för hur mycket vatten den kan pumpa. För att hantera dessa begränsningar är det lämpligt att införa ytterligare en signal v(t k ) som bara används internt i regulatorn och som kan tillåtas vara hur stor eller liten som helst. Det är alltså en trunkerad version av v(t k ) som skickas till pumpen. Regulatorn ges alltså av e(t k ) = r(t k ) y(t k ), i(t k ) = R I e(t l ), l k d(t k ) = R D (y(t k ) y(t k 1 )), a(t k ) = i(t k ) + d(t k ), v(t k ) = Ke(t k ) + a(t k ), u max, om v(t k ) > u max, u(t k ) = v(t k ), om u min v(t k ) u max, u min, om v(t k ) < u min. (3.4) Den diskreta pid-regulatorn (3.4) lämpar sig väl för implementering i ett sekventiellt system såsom plc:n i labbet. Algoritm 1 beskriver en möjlig implementation. För mer information om diskretisering av pi- och pid-regulatorer se kurskompendiet! 9
Algoritm 1 Sekventiell implementering av pid-regulator (3.4) 1. Mät systemets är-värde, y(t k ) 2. Beräkna felet, e(t k ) = r(t k ) y(t k ) 3. Beräkna den approximerade integralen i tiden t k, i(t k ) = i(t k 1 ) + K Ts T I e(t k ) = i(t k 1 ) + R I e(t k ) 4. Beräkna den approximerade derivatan i tiden t k, d(t k ) = R D (y(t k ) y(t k 1 )) 5. Beräkna totala inverkan av I- och D-del i tiden t k, a(t k ) = i(t k ) + d(t k ) 6. Beräkna den otrunkerade utsignalen v(t k ) = Ke(t k ) + a(t k ) 7. Beräkna den trunkerade styrsignalen u(t k ) enligt (3.4) 8. Låt k = k + 1 och börja om på steg 1 3.2 Nedklockning Den regulatorn som är beskriven i (3.4) uppdateras med en fast tidsintervall, T s. En kort samplingstid är att föredra för att minimera tidsfördröjningen från en mätning till dess att utsignalen är uträknad och för att reagera snabbt på eventuella förändringar. Att köra plc:n med kort sampeltid skapar problem eftersom plc:n har begränsad upplösning. Lösningen är att låta i(t k ) och d(t k ) i (3.4) uppdateras mer sällan än v(t k ). Regulatorn beskriven i (3.4) kan alltså utökas till e(t k ) = r(t k ) y(t k ), i ( t ) Ts k = K e ( t ) l = RI e ( t ) l, T I l k l k d( t k ) = KT D T s ( y( t k ) y( t k 1 ) ) = R D ( y( t k ) y( t k 1 ) ), a(t k ) = i ( t k ) + d( t k ), v(t k ) = Ke(t k ) + a (t k ), u max, om v(t k ) > u max, u(t k ) = v(t k ), om u min v(t k ) u max, u min, om v(t k ) < u min, (3.5) där v(t k ) och u(t k ) uppdateras med frekvensen 100 Hz och i( t k ) samt d( t k ) uppdateras med frekvensen 2 Hz. Ett sätt att åstadkomma en längre sampeltid är att använda en timer. Den timer vi föreslår att man använder heter TON. Figur 3.1 visar hur timern kan 10
TON Timer T4:0 Time Base 0.01 Preset 50 Accum 0 T4:0/EN T4:0/DN T4:0/DN T4:0/DN (stuff) Beräkna långsam cykel T4:0 RES Figur 3.1. Kod för att skapa långsam cykel. Instruktionerna i den mellersta raden (som illustreras med blocket (stuff)) körs två gånger i sekunden. användas för att köra integral- och derivatadelarna med en längre sampeltid. Då timern har räknat upp till Time base Preset = 50 0.01 = 0.5s sätts T4:0/DN till 1. Om T4:0/DN är 1 så beräknas i ( t k ) och d ( t k ) enligt (3.5) och T4:0/DN nollställs. Algoritm 2 är en utökning av algoritm 1 med den långsamma cykeln. För mer information om timern, se lektionsanteckningar och bilagan till uppgiftskompendiet. Algoritm 2 Sekventiell implementering av pid-regulator (3.5) med långsam cykel 1. Mät systemets är-värde, y(t k ) 2. Beräkna felet, e(t k ) = r(t k ) y(t k ) 3. Beräkna den approximerade integralen och derivatan i tiden t k, Om T4:0/DN == 1 beräkna i( t k ) = i( t k 1 ) + R I e( t k ) d( t k ) = R D ( y( t k ) y( t k 1 ) ) T4:0/DN = 0 4. Beräkna totala inverkan av I- och D-del i tiden t k, a(t k ) = i( t k ) + d( t k ) 5. Beräkna den otrunkerade utsignalen v(t k ) = Ke(t k ) + a(t k ) 6. Beräkna den trunkerade styrsignalen u(t k ) enligt (3.5) 7. Låt k = k + 1 och börja om på steg 1 11
3.3 Integratoruppvridningsskydd För att motverka integratoruppvridning skall villkorlig integrering implementeras. Villkorlig integrering innebär att uppdateringen av integralen upphör om styrsignalen är mättad. Styrsignalen är omättad om u min v(t k ) u min, med andra ord skall alltså punkt 3 i algoritm 1 inte utföras om u(t k ) v(t k ). Se figur 3.2 för ett exempel på en mättad styrsignal. 250 200 150 100 Output (%) 50 0 50 100 150 200 250 0 5 10 15 20 25 30 35 40 45 50 Time (s) Figur 3.2. Ett exempel där den uträknade styrsignalen v(t k ) är större (och mindre) än det tillåtna värdet på utsignalen u(t k ). Notera att v(t k ) sammanfaller med u(t k ) när signalen är omättad, det vill säga v(t k ) = u(t k ) då signalen är omättad. Algoritm 3 är en utökad version av algoritm 2 där det villkorlig integratoruppvridningsskyddet är implementerad. Mer information om detta samt andra uppvridningsskydd och en mer detaljerad förklaring finns i kurskompendiet. 12
Algoritm 3 Sekventiell implementering av pid-regulator (3.5) med villkorligt integratoruppvridningsskydd och långsam integral- och derivatadel 1. Mät systemets är-värde, y(t k ) 2. Beräkna felet, e(t k ) = r(t k ) y(t k ) 3. Beräkna den approximerade integralen och derivatan i tiden t k, Om T4:0/DN == 1 beräkna d( t k ) = R D ( y( t k ) y( t k 1 ) ) Om v( t k ) == u( t k ) i( t k ) = i( t k 1 ) + R I e( t k ) Annars i( t k ) = i( t k 1 ) T4:0/DN = 0 4. Beräkna totala inverkan av I- och D-del i tiden t k, a(t k ) = i( t k ) + d( t k ) 5. Beräkna den otrunkerade utsignalen v(t k ) = Ke(t k ) + a(t k ) 6. Beräkna den trunkerade styrsignalen u(t k ) enligt (3.5) 7. Låt k = k + 1 och börja om på steg 1 3.4 Derivatafilter (Endast TSIU04) Ett stort problemet med pid-regulatorn beskriven i (3.1) är att den förstärker höga frekvenser. Detta betyder att brus på mätsignalen kommer förstärkas kraftigt och resultatet blir att bruset slår igenom kraftigt på utsignalen. Problemet kan undvikas genom att lågpassfiltrera den ideala derivatan D(s) KT D se(s) 1 + sn (3.6) där d(t) approximativt kommer bete sig som KT D ė(t) för låga frekvenser men kommer endast förstärka höga frekvenser med faktorn KT D /N. En inverse Laplace-transform av (3.6) ger N d(t) + d(t) = KT D ė(t) (3.7) På samma sätt som i kapitel 3.1 används Euler approximation (bakåt) för att diskretisera (3.7) och resultatet blir N d(t k ) = d(t k 1 ) KT D (y(t k ) y(t k 1 )) N + T s N + T s = R N d(t k 1 ) R D (y(t k ) y(t k 1 )) (3.8) där r(t k ) r(t k 1 ) antas vara 0. Notera att R D i (3.3) skiljer sig från R D i (3.8) men att de sammanfaller då N = 0, det vill säga då derivatafiltret är avstängt. Ekvation (3.5) kan nu uppdateras till 13
e(t k ) = r(t k ) y(t k ), i ( t ) k = RI e ( t ) l, l k d( t k ) = R N d( t k 1 ) R D ( y( t k ) y( t k 1 ) ), a(t k ) = i ( t k ) + d( t k ), v(t k ) = Ke(t k ) + a (t k ), u max, om v(t k ) > u max, u(t k ) = v(t k ), om u min v(t k ) u max, u min, om v(t k ) < u min, (3.9) där hänsyn tagits till långsammare sampeltid. Algoritm 4 beskriver den nya algoritmen. Se kurskompendiet för mer detaljer om derivatafilter. Algoritm 4 Sekventiell implementering av pid-regulator (3.9) med villkorligt integratoruppvridningsskydd, långsam integral- och derivatadel samt derivatafilter 1. Mät systemets är-värde, y(t k ) 2. Beräkna felet, e(t k ) = r(t k ) y(t k ) 3. Beräkna den approximerade integralen och derivatan i tiden t k, Om T4:0/DN == 1 beräkna d( t k ) = R N d( t k 1 ) R D ( y( t k ) y( t k 1 ) ) Om v( t k ) = u( t k ) i( t k ) = i( t k 1 ) + R I e( t k ) Annars i( t k ) = i( t k 1 ) T4:0/DN = 0 4. Beräkna totala inverkan av I- och D-del i tiden t k, a(t k ) = i( t k ) + d( t k ) 5. Beräkna den otrunkerade utsignalen v(t k ) = Ke(t k ) + a(t k ) 6. Beräkna den trunkerade styrsignalen u(t k ) enligt (3.5) 7. Låt k = k + 1 och börja om på steg 1 3.5 Aritmetik med heltal Den plc som används i den här laborationen använder endast med 16-bitars heltal med en teckenbit. Det är en stor begränsning och här ges ledning till hur det kan hanteras. 14
3.5.1 Överspill Begränsningen till 16 bitar för heltal med tecken innebär att alla tal är begränsade till intervallet [ 32768, 32767 ]. Beräkningar som leder till tal utanför det här intervallet ger ett ogiltigt resultat och måste hanteras. Problemet kallas överspill (på engelska: overflow). plc:n som används i laborationen hanterar överspill genom att Trunkera svaret till tillåtet intervall. Exempelvis blir 400 100 = 40000 trunkerat till 32767. Meddela att överspill har inträffat genom att sätta biten S:5/0 till 1. Denna bit kallas för minor error bit. Om S:5/0 inte återställs kommer plc:n avbryta exekveringen och FLT-lampan kommer blinka rött. Om det händer kan man ofta få vägledning om var det blivit fel genom att leta efter register som fått värdet 32767 eller 32768. S:5/0 U END Figur 3.3. Genom att utföra en unlatch av S:5/0 sist i programmet fångas eventuellt överspill upp och programmet kan fortsätta att exekvera. För att hantera överspill behöver programmet på något sätt ta hand om felet och återställa S:5/0. Biten S:5/0 kan nollställas genom att använda operationen OTU (unlatch). Genom att införa en unlatch-operation på S:5/0 sist i programmet fångas eventuellt överspill upp för beräkningar där S:5/0 inte används för att öka precisionen i beräkningen, se figur 3.3. Biten S:5/0 kan även användas för att hantera problem med överspill genom att minska precisionen. Mer om detta diskuteras under lektionerna samt i förberedelseuppgifterna till denna laboration. 15
3.5.2 Skalning På grund av att tal i plc:n representeras med heltal måste de skalas för att kunna representera tal som inte är heltal mellan 32768 och 32767. Vid beräkningar är det därför viktigt att ta hänsyn till skalningen. Addition(subtraktion): Talen som adderas(subtraheras) måste ha samma skalfaktor. Multiplikation(division): Talen behöver inte ha samma skall faktor men det är viktigt att vara medveten om att den resulterande skalfaktorn är produkten(kvoten) av skalfaktorerna för de båda talen. Vid multiplikation är det viktigt att se till att resultatet inte blir för stort. Vilket av talen som skall skalas upp/ner innan beräkning beror på om det är viktigt att behålla upplösning eller att undvika överspill. 16
Kapitel 4 Arbetsgång Notera att allting som hanterar D-delen av regulatorn endast är för kursen TSIU04. Även om uppgiften lätt kan formuleras som att en pid-regulator med derivata filter och skydd mot integratoruppvridning ska implementeras, kan det visa sig oväntat svårt att genomföra uppgiften med den enkla hårdvara som används i laborationen. Ekvation (3.5)/(3.9) eller algoritm 1-4 kan vid en första anblick kännas omöjliga att hantera. Vid implementation av godtyckligt problem är det viktigt att bryta ner problemet i hanterbara bitar. Det första naturlig steget är att göra en inventering av problemet och dess delar. Är det möjligt att implementera delar av algoritmen? I vilken ordning måste saker utföras? Vad finns tillgängligt och vad måste beräknas? Dessa regler kan applicerar på ekvation 3.5 eller algoritm 1-4. Ekvation (3.5)/(3.9) kan delas upp i beräkning av felet, beräkning av den proportionella delen, beräkning av integraldelen, beräkning av derivatadelen, summering av alla bidrag och trunkering av den beräknade styrsignalen. Dessa delar kan implementeras var för sig och det är därmed också möjligt att testa dem på ett lättare sätt. För att underlätta problemet är det rekommenderat att först implementera en P-regulator med trunkering 17
1. Implementera en P-regulator med trunkering av styrsignalen, dvs. punkt 1, 2, 5, 6 och 7 i algoritm 2. 2. Utöka P-regulatorn med en nedklockad integral- och derivata-del, dvs. lägg till punkt 3 och 4 i algorithm 2. 3. Utöka pid-regulatorn med integratoruppvridningsskydd enligt kapitel 3.3, dvs gör ändringarna enligt algorithm 3. 4. Utöka pid-regulatorn med ett derivatafilter enligt algoritm 4. 4.1 Plan för minnesanvändning Här presenteras ett förslag på hur minnet i plcn kan användas. Först påminner vi om några intressanta värden som är givna av sammanhanget. Förslaget bygger på att allt minne som hör till den nya regulatorn ska samlas i datafilen N10. Registrena N10:14 - N10:16 kan användas för att lagra mellanresultat, var dock noga med att skriva ner var ni lägger era olika mellanresultat och med vilken skalfaktor de sparas. Utöver registren som nämns ovan läggs flaggor och heltalsvariabler enligt tabell 4.2. Att en flagga är satt (lika med 1) ska tolkas som att motsvarande funktion är aktiv. 18
Tabell 4.1. Skalfaktorer för fixpunkt-representationen. Notera att flaggan RG måste vara satt till 1 för att skalfaktorn 100 skall gälla för K och T I. Samtliga register i denna tabell är av datatypen I/O real. Reg. Uttryck Faktor Kommentar I:3.0 1 Mätsignal från över tank I:3.1 1 Mätsignal från undre tank O:3.0 1 Utsignal till pump N7:2 r(t k ) 1/2 Börvärdet N7:3 K 100 Parameter för inbyggda regulatorn N7:4 T I 100 Parameter för inbyggda regulatorn N7:5 T D 100 Parameter för inbyggda regulatorn N9:0 y upper (t k ) 1/2 Tanknivå övre tanken N9:1 y lower (t k ) 1/2 Tanknivå undre tanken N9:2 u pump (t k ) 1/2 Styrsignal till pumpen N9:3 u pump,manuell (t k ) 1/2 Manuell styrsignal till pumpen N9:4 y(t k ) 1/2 Ärvärde N10:1 K 4 Parameter för egen regulator N10:2 RI = K T s T I 256 Parameter för egen regulator N10:3 RD = K T D N+ T 1 Parameter för egen regulator s N10:4 RN = N N+ T 256 Parameter för egen regulator s N10:5 e(t k ) = r(t k ) y(t k ) 1/2 Reglerfelet N10:6 RI e( t k ) 1 Tillskottet till integralen vid t k N10:7 i( t k ) t k t 0 K T I e(τ) dτ 1 Den approximerade integralen N10:8 d( t k ) = R D (y( t k ) y( t k 1 )) 1/4 Derivatan i tidpunkten t k N10:9 Ke(t k ) 1/4 Mellanlagring av P-del N10:10 a(t k ) 1/4 Mellanlagring av D- och I-del N10:11 v(t k ) 1/4 Uträknad styrsignal för pump N10:12 u(t k ) 1/4 Trunkerad styrsignal för pump N10:13 y( t k 1 ) 1/2 Ärvärde i föregående tidpunkt N10:14 Fritt för mellanresultat N10:15 Fritt för mellanresultat N10:16 Fritt för mellanresultat 19
Tabell 4.2. Flaggor och heltalsvariabler. Att flaggan är satt (biten är = 1) tolkas som att funktionen är aktiv. Samtliga register i denna tabell är av datatypen I/O discrete. Register N7:0/1 N9:5/0 N9:5/1 N10:0/0 N10:0/1 Kommentar Manuellt läge. Val av tank som skall regleras. Överfyllnadssskydd aktiverat. Egna pid-regulatorn inkopplad Integratoruppvridningsskydd aktivt 20
Kapitel 5 Förberedelseuppgifter Uppgifterna i detta kapitel är som titeln säger förberedelser inför laborationen och är tänkta att öka förståelsen och förenkla genomförandet av laborationen. Svaren på uppgifterna kommer användas under laborationen och examinationen. Tänk på hur uppgifterna kopplar till laborationen och de uppgifterna som behöver slutföras för att få godkänt på laborationen! 5.1 Integratoruppvridning Denna laboration fokuserar på integratoruppvridning, som är ett praktiskt problem som man ofta stöter på när man implementerar en pid-regulator. Läs därför genom materialet från föreläsningar och lektioner samt läs i kurskompendiet för att besvara dessa frågor: Uppgifter: 1. Beskriv problemet med integratoruppvridning. Vad är orsaken? Vilka konsekvenser riskerar man? 2. Förklara hur villkorlig uppdatering fungerar och hur den skyddar mot integratoruppvridning. 3. Förklara hur justering av integral-delen fungerar och hur den skyddar mot integratoruppvridning. 4. Vad finns det för för- och nackdelar med dessa två metoder? Är det rimligt att föredra någon och isåfall när? 21
5.2 Regulatorparametrar och skalning Er implementering av pid-regulatorn kommer att använda sig av andra skalfaktorer än den inbyggda för de olika parameterarna (K,T I,T D ). Vi behöver därför beräkna nya skalningar på ett liknande sätt som i laboration 1. Lägg märke till att vi använder en annan parametrisering av pid-regulatorn än den inbyggda. Detta betyder främst att vi har R I, R D och R N som konstanter i ekvation (3.9). Uppgift: 5. Använd detta labb-pm för att hitta hur man beräknar R I, R D och R N. I InTouch vill vi kunna ställa in parametrarna K, T I och T D för båda regulatorerna samt N för vår egna. Eftersom vi i implementeringen använder R I, RD och R N. som beror på K, T I, T D och N, måste vi räkna ut R I, RD och R N givet dessa parametrar och sedan skicka resultatet till rätt register. Detta kommer vi att lösa genom ett data change script 1 i InTouch. Uppgifter: 6. Det är fördelaktigt att genomföra denna beräkning i InTouch istället för i stegkodsprogrammet. Vad är anledningen till detta? 7. Beräkna en ny skalning för R I, RD och R N som vi ska använda i In- Touch. Antag att förstärkningen K [0, 200], att integreringstiden T I [0.1, 10] minuter, att deriveringstiden T D [0, 1] minuter och att tidskonstanten för lågpassfiltret på derivatadelen N [0, 30] s. (a) Vad är det största respektive minsta värdet som R I, RD och R N kan anta som oskalad? (Observera att R I, RD och R N ska vara dimensionslöst, alltså sakna enhet) (b) Vilket intervall blir detta om ni skalar R I, RD och R N med den skalfaktor som föreslagits i detta labb-pm? 1 Ett data change script utför en beräkning när en viss tag har förändrats i InTouch. Skriptet ser ut precis som i Matlab. Antag att man har kopplat exempelvis en slider som ska styra förstärkningen till en tag som heter Kegen och på samma sätt skapat Tiegen för integreringstiden. Antag vidare att vi har skapat en tag som är kopplat till det register i plc:n som ska lagra R I och har döpt denna tag till Riegen, samt har skalat den på rätt sätt (se nästa förberedelseuppgift). Då kommer vårt skript att bli Riegen=Kegen*0.5/Tiegen, eftersom samplingstiden är 0.5 sekunder. Notera att Kegen och Riegen är kopplade till respektive register i plc:n som vanligt, dock finns Tiegen endast i InTouch. 22
5.3 Heltal och överspill I denna laboration riskerar vi problem med överspill eftersom stora heltal kommer att multipliceras och adderas. Målsättningen är nu att skapa några stegkodsstrukturer som kommer att hjälpa oss att hantera detta problem på bästa sätt. Antag att man vill genomföra följande beräkning: multiplicera registren N10:2 och N10:5 samt placera den skalade produkten i N10:6. Skalningen kommer att bli en division med 128 eftersom målregistret har skalfaktor 1 och källregistren har skalfaktorerna 1/2 respektive 256. Detta kan genomföra på två olika sätt: att först multiplicera källregistrer och sedan skala med 128 eller att först skala ett källregister och sedan multiplicera källregistren. Detta kan genomgöras i stegkodsprogrammering genom strukturerna som visas i figur 5.1. Uppgifter: 8. Vad händer i de olika stegen? Vad kan man uppnå med att göra på detta sätt? 9. Om skalningen görs innan multiplikationen måste ett register väljas att skala. Är det lämpligast att välja N10:2 eller N10:5? Motivera. 10. Vad är för- och nackdelarna med de två lösningarna i figur 5.1? Vilket alternativ vill man använda i första hand? DIV N10:5 128 N10:6 MUL N10:5 N10:2 N10:6 MUL N10:6 N10:2 N10:6 DIV N10:6 128 N10:6 Figur 5.1. Två olika sätt att lösa problemet N10:6 = N10:2 N10:5 128. Ett metod för att lösa detta problem på ett sätt som balanserar problemet med överspill och förlust av precision är att använda sig av minor error bit S:5/0. 23
Uppgifter: 11. Hur kan S:5/0 användas för att avgöra vilket av alternativen i figur 5.1 som är bäst? 12. Använd de två strukturerna i figur 5.1 samt S:5/0 för att konstruera ett stegkodsprogram som utför multiplikationen med största möjliga precision men som samtidigt undviker överspill. Använd följande steg: (a) Utgå från att nollsätta S:5/0. (b) Prova att utföra det bästa alternativet från ovan. (c) Om överspill inträffar, utför det andra alternativet. 13. Skapa en ytterligare byggsten till det framtida programmet genom att förändra registren och skalfaktorerna (se tabell 4.2) i det föregående stegkodsprogrammet för att istället utföra operationen K e(t k ). 5.4 Programmets struktur Vi är nu redo att kombinera kunskapen om diskretiserade pid-regulatorer samt överspillshantering i ett stegkodsprogram. Målsättningen är att skapa ett komplett stegkodsprogram som hanterar skalning, överspill och integratoruppvridning genom att i ordning lösa uppgifterna nedan. Utgå från lösningarna i föregående uppgifter, kapitel 4, algoritmerna 1-4 och stegkodsprogrammet som utvecklades i labb 1. Uppgifter: 14. Utgå från stegkodsprogrammet från labb 1. Var skall den egen-implementerade regulatorn placeras? Notera att det skall vara möjligt att välja vilken regulator som är aktiv. 15. Skapa en enkel p-regulator genom att använda algorithm 2, överspillshanteringen från föregående avsnitt samt kapitel 4. (a) Bryt ned punkt 1 i kapitel 4 till hanterbara bitar. (b) Vad finns tillgängligt och vad behöver beräknas? (c) Vilka skalfaktorer blir de efter varje uträkning och stämmer det med registren de skall lagras i? (d) Behöver överspill hanteras? 24
(e) Skriv ner lösningen som pseudokod. 16. Inför nu en långsam cykel i ert program där I- och D-delen ska placeras, utgå från lösningen i föregående uppgift, ladder-programmet i figur 3.1 och algoritm 2. (a) Bryt ned punkt 2 i kapitel 4 till hanterbara bitar. (b) Vad finns tillgängligt och vad behöver beräknas? (c) Vilka skalfaktorer blir de efter varje uträkning och stämmer det med registren de skall lagras i? (d) Behöver överspill hanteras? (e) Skriv ner lösningen som pseudokod. 17. Utöka lösningen med villkorlig integration genom att utgå från lösningen i föregående uppgift och algoritm 3. Skriv ner lösningen som pseudokod. 18. Utöka lösningen med derivatafilter genom att utgå från lösningen i föregående uppgift och algoritm 4. Skriv ner lösningen som pseudokod. Notera att det skall gå att stänga av derivata-filtret genom att sätta N = 0. 19. Skapa ett komplett stegkodsprogram för algoritm 4 genom att utgå från psuedokoden från ovanstående uppgift. 25