PID N7:0 N9:0 N9:2. PID-implementering i PLC. Laboration i industriella styrsystem. Denna version: 2 februari Namn: Personnr: Datum: Godkänd:

Transkript

1 Laboration i industriella styrsystem PID-implementering i PLC Denna version: 2 februari 2012 PID N7:0 N9:0 N9:2 REGLERTEKNIK Namn: Personnr: AUTOMATIC LINKÖPING CONTROL Datum: Godkänd:

2

3 Innehåll 1 Introduktion Tidsåtgång Utgångspunkt Uppgift 7 3 Arbetsgång Omskrivning av regulatoruttrycket Aritmetik med heltal Flaggan minor error bit Skalade variabler Nerklockning Villkorlig integration Plan för minnesanvändning Strukturering av problemet Användbara instruktioner Processdatorkopplingen Förberedelseuppgifter pid och integratoruppvridning Timing och tidskalor Den inbyggda regulatorns tidkonstanter Samplingsintervallet och den nya regulatorns tidkonstanter Heltal och överspill Programmets struktur Tips Allmäna tips Felsökning Hur vet ni att det ni implementerat fungerar?

4 A Kompletterande information 29 A.1 Addition av fler än två tal A.2 Problem med en alltför frekvent uppdatering av integraldelen. 31 4

5 Kapitel 1 Introduktion I den här laborationen ska en pid-regulator implementeras i en plc. Laborationen handlar därmed både om implementering av pid-regulatorer, och hur en plc kan programmeras. Dessutom tvingas man stifta viss bekantskap med att genomföra beräkningar i relativt små heltal. 1.1 Tidsåtgång Förväntad tidsåtgång för laborationen är 12 h (exklusive förberedelsetid), varav 4 h utförs med tillgång till assistent under schemalagd tid. 1.2 Utgångspunkt Laborationen förutsätter viss bekantskap med pid-regulatorer och fenomenet integratoruppvridning. Vi utgår från en formeln för en regulator utan skydd mot integratoruppvridning, där styrsignalen u vid tidpunkten t ges av: 1 ( t ) u(t) = K e(t) T D ẏ(t) + 1TI e(τ) dτ (1.1) t 0 där y är processens utsignal som vi vill reglera, och e = r y är reglerfelet (r är alltså referenssignalen). Skydd mot integratoruppvridning innebär att integraldelen, t t 0 e(τ) dτ, bara räknas upp när styrsignalen, u(t), inte har mättat. 1 Att vi bara deriverar y och inte e = r y beror på att vi tänker oss en referens som normalt sett ändras stegvis, och att det i regel får oönskade konsekvenser om man deriverar steg. 5

6 Reläschemat nedan beskriver det program som ska modifieras. Några interna hjälpvariabler (N9:0, N9:1 och N9:2) har använts för att skala givarnas signaler, samt signalen till pumpen. Det är den färdiga pid-instruktionen i det här programmet som ska kompletteras med en egen implementation. Bilden nedan är en stiliserad variant av programmet så som det visas i RSLogix. Se kompendium för laborationen i processdatorsystem för ytterligare detaljer. DIV I:3.0 2 N9:0 DIV I:3.1 2 N9:1 PID N7:0 N9:0 N9:2 N7:0/1 MOV N9:3 N9:2 MUL N9:2 2 O:3.0 6

7 Kapitel 2 Uppgift Uppgiften kan delas in i obligatoriska och frivilliga uppgifter enligt följande. Obligatoriska uppgifter PLC Gör det möjligt att via en flagga styra om det är er eller den inbyggda regulatorn som är aktiv, se tabell 3.5. Som ett första steg mot en pid-regulator så ska en p-regulator implementeras. Utöka p-regulatorn med en integrerande del, så att den egen-implementerade regulatorn är av pi-typ. Implementera skydd mot integratoruppvridning för den egen-implementerade pi-regulatorn. Gör det möjligt att med hjälp av en flagga styra om skydd mot integratoruppvridning är aktivt eller inte. 7

8 InTouch Utöka ert gränssnitt från processdatorlabben med följande funktionalitet: Gör det möjligt att styra om det är den egen-implementerade regulatorn eller den inbyggda som är aktiv. Gör det möjligt att via processdatorn följa integratortillståndet i regulatorn, så att skyddet mot integratoruppvridning kan studeras. Gör det möjligt att nollställa integratortillståndet. Gör det möjligt att stänga av skyddet mot integratoruppvridning från processdatorn. Gör det möjligt att ställa in regulatorparametrar för den egna regulatorn från processdatorn. Frivilliga uppgifter Utöka pi-regulatorn med en deriverande del för att få en pid-regulator. Inför ett derivatafilter på pid-regulatorn för att minska regulatorns bruskänslighet. Trimma regulatorn för att styra den undre tanken. Inför stötfri modomkoppling mellan manuell och automatisk styrning. 8

9 Kapitel 3 Arbetsgång Även om uppgiften lätt kan formuleras som att en pid-regulator med skydd mot integratoruppvridning ska implementeras, kan det visa sig oväntat svårt att genomföra uppgiften med den enkla hårdvara som står till buds. Det här kapitlet bryter ner problemet och ger ledning för hur problemet med den aktuella datatypens tillkortakommanden kan hanteras. I beskrivningen kommer alla tre delarna ( p, i och d) av regulatorn att behandlas men det är bara de två första som det är obligatoriskt att implementera. 3.1 Omskrivning av regulatoruttrycket Som ett första steg närmare en implementation av (1.1) noterar vi att regulatorparametrarna kan ändras av användaren medan regulatorn är igång. Detta spelar främst roll för hur integralen beräknas, och vi väljer att se det så här: u(t) = K(t)e(t) K(t) T D (t) ẏ(t) + t t 0 K(τ) 1 e(τ) dτ (3.1) (t) Framöver håller vi tidsberoendet hos parametrarna i bakhuvudet, och tar bort det från notationen igen. Genom att kasta om ordningen av faktorerna i integranden blir uttrycket u(t) = Ke(t) K T D ẏ(t) + t t 0 1 Ke(τ) dτ (3.2) 9

10 För att gå från kontinuerlig till diskret tid, med samplingstidpunkter t k och samplingsintervall t k t k 1 = T s, utnyttjar vi approximationerna tk t 0 ẏ(t k ) y(t k) y(t k 1 ) T s e(τ) dτ l k T s e(t l ) Vi får alltså den diskreta beskrivningen av (3.2) u(t k ) = Ke(t k ) K T D T s ( y(t k ) y(t k 1 ) ) + l k T s Ke(t l ) (3.3) Vanligtvis brukar man 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 u(t k ) = Ke(t k ) + a(t k ) a(t k ) = K T D T s ( y(t k ) y(t k 1 ) ) + l k T s Ke(t l ) (3.4) Vidare så finns det begränsningar på hur stor styrsignalen, u(t k ), kan vara. I vårt 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. 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 en trunkerad version av v(t k ) som sedermera skickas till pumpen. Regulatorn ges alltså av v(t k ) = Ke(t k ) + a(t k ) a(t k ) = K T D T s ( y(t k ) y(t k 1 ) ) + l k T s Ke(t l ) 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) Jämför gärna denna beskrivning med den som ges i kurskompendiet! 10

11 3.2 Aritmetik med heltal Den plc som används i den här laborationen tillhandahåller primärt endast en typ av tal, 16-bitars heltal med tecken. Det är en högst påtaglig begränsning, och här ges ledning till hur det kan hanteras Flaggan minor error bit Begränsningen till 16 bitar för heltal med tecken innebär att alla siffror är begränsade till intervallet [ 32768, ]. Beräkningar som leder till tal utanför det här intervallet leder till ogiltiga resultat och måste således tas speciell hänsyn till. Problemet kallas överspill (på engelska: overflow). Den plc som används i laborationen, Allen Bradley, har den bekvämliga finessen att beräkningar som egentligen leder till tal utanför det intervall som kan representeras, ger ett svar som är det närmsta tal som finns att tillgå. För beräkningar som egentligen resulterar i mer än blir svaret alltså 32767, och på motsvarande sätt när det egentligen ska vara mindre än När detta sker sätter (dess värde blir 1) plcn biten S:5/0 (som kallas minor error bit). Sedan förväntas ert program på något sätt ta hand om felet, och återställa S:5/0. Att inte återställa S:5/0 betraktas som ett programmeringsfel, och kommer leda till att plcn avbryter exekveringen. 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 eller För att återställa S:5/0 till sitt normalläge (alltså nollställa) kan man använda operationen OTU (unlatch). I koden visas operationen som ett rundat relä med ett U i. I sektion behandlas hur vi kan använda flaggan minor error bit för att öka noggrannheten i de beräkningar som utförs. Utöver det så behöver vi bara se till att den inte är satt i slutet av en exekveringscykel, då det uppfattas som ett fel, se sektion 5.2. Längst ner i hela plc-koden kan det alltså se ut så här: 11

12 S:5/0 U END Skalade variabler För att kunna använda heltal i ett begränsat intervall för att representera reella tal (alla pid-formler är ju uttryckta i reella tal), måste man bestämma sig för hur heltalen ska tolkas. Här låter vi heltalet motsvara det reella talet multiplicerat med en skalfaktor. Tabell 3.1 exemplifierar hur skalfaktorn ska tolkas när vi låter ett reellt tal sparas i ett register i plcn. Tabell 3.1. Kolumnen Reellt tal är talets verkliga värde, medan Registervärde är det värde som används i plcn. Kolumnen Faktor anger skalfaktorn mellan dessa. Reellt tal Faktor Registervärde När vi manipulerar tal, t.ex. adderar, multiplicerar, dividerar, i plcn så måste vi beakta att värdena i plcns register har olika skalfaktorer. Utöver informationen i den här sektionen så är också lektionsuppgifterna ett bra stöd till att förstå skalade variabler. Addition När uttryck ska adderas måste de ha samma skalfaktor, vilket då blir skalfaktorn även för summan. Om talen har olika skalfaktorer så måste således något av dem antingen skalas upp eller ner innan vi kan addera dem. Vilket av dessa alternativ som är att föredra beror på om vi vill behålla upplösning eller undvika överspill. I laborationen är det viktigare att undvika överspill än att behålla upplösningen och således ska vi välja att skala ner den faktor som är störst. Detta illustreras med ett exempel. 12

13 Vill vi, exempelvis, addera N10:9 och N10:15 (vars summa ska läggas i N10:16) så får vi först dela N10:9 med fyra så att det får samma skalfaktor som N10:15, se tabellen på sidan 20. Därefter kan vi addera dem och lägga resultatet i N10:16 enligt reläschemat nedan DIV N10:9 4 N10:16 ADD N10:15 N10:16 N10:16 Märk att N10:16 kan användas för att hålla mellanresultat, och att instruktioner som beräknar mellanresultat måste komma ovanför instruktioner där mellanresultatet används. Multiplikation Ska uttryck multipliceras kan man ha olika skalfaktorer hos faktorer såväl som produkten, men man måste se till att resultatet inte blir för stort. Låt oss som exempel titta på hur K Ts e beräknas så som det representeras i N10:14. Vi börjar med att notera att det vi vill utföra på plcn är att multiplicera registren N10:2 och N10:13 och lägga svaret i registret N10:14. Utöver det behöver vi också se till att svaret i registret N10:14 har korrekt skalfaktor. Vid multiplikation hanterar vi skalfaktorerna på samma sätt som vi gör med de faktiska talen vi multiplicerar. Eftersom produkten av de ingående skalfaktorerna är 1 }{{} 2 }{{} 256 = 128 (3.6) N10:2s faktor N10:13s faktor och resultatet ska ha skalfaktorn 1, måste produkten av N10:13 och N10:2 divideras med 128 = 128 innan själva beräkningen kan anses vara slutförd. 1 Alltså kan multiplikationen av K Ts e utföras enligt 13

14 MUL N10:13 N10:2 N10:14 DIV N10: N10:14 I flertalet fall fungerar det här sättet att utföra multiplikation utmärkt. En situation som kräver ett annat tillvägagångsätt är när vi har stora reglerfel, alltså när N10:13 är stor. Den initiala multiplikationen N10:13 N10:2 leder då till överspill och vi förlorar därmed information. Utförs divisionen istället först på någon eller båda av de ingående faktorerna förloras precision, men istället är det möjligt att erhålla produkter som använder hela dynamiken i registret. Att dividera N10:2 skulle leda till förlorad upplösning i K Ts, och skulle vara detsamma som att ändra skalningen av N10:2. Då skalningen är vald med omsorg för att få tillräcklig precision vid inställningen av K Ts är detta inte ett bra alternativ. Låt oss istället börja med att utföra divisionen på N10:13, med konsekvensen att vi förlorar upplösning i reglerfelet e. Om vi inte vidtar några extra åtgärder vid överspill blir programmet: DIV N10: N10:14 MUL N10:14 N10:2 N10:14 Sammanfattningsvis kan sägas att det finns två sätt att utföra multiplikation på. Antingen så multipliceras talen och därefter divideras deras produkt så att den får korrekt skalfaktor, eller så utförs division på ett av talen innan multiplikationen så att produktens skalfaktor blir korrekt. Ett program som utför beräkningen multiplikationen av N10:13 och N10:2 kan alltså se ut enligt figur 3.1. Notera hur biten S:5/0 används för att detektera överspill. 14

15 S:5/0 U MUL N10:13 N10:2 N10:14 DIV N10: N10:14 S:5/0 DIV N10: N10:14 MUL N10:14 N10:2 N10:14 Figur 3.1. Beräkning av K Ts e så som det kan utföras i plcn. 3.3 Nerklockning Den tidsdiskreta regulatorn enligt (3.5), här återgiven utan trunkeringen som sker innan styrsignalen skickas till vattenpumpen v(t k ) = Ke(t k ) + a(t k ) a(t k ) = K T D T s ( y(t k ) y(t k 1 ) ) + l k T s Ke(t l ) (3.7) uppdateras med ett visst tidsintervall, T s. Vanligtvis vill man köra regulatorn med så liten samplingstid som möjligt bland annat för att då kommer regulatorn att snabbt reagera på eventuella ändringar. Det finns dock två problem med att köra pid-regulatorn med för hög sampel-frekvens. Båda dessa härrör till att en för snabb uppdatering av a(t k ) kan leda till problem. För det första kommer eventuell derivering av insignaler leda till hög förstärkning av mätbrus. Ett sätt att motverka detta är genom ett derivatafilter, men att implementera ett sådant ligger utanför laborationens innehåll. För det andra orsakar den begränsade upplösningen på plcn i kombination med ett 15

16 litet T s problem med integratordelen. Varför så är fallet är ganska intrikat och ligger utanför laborationens innehåll 1. Lösningen på dessa problem är att låta a(t k ) uppdateras mer sällan än den övriga koden. För den aktuella processen är en sampeltid, T s, på 0.5 s en bra kompromiss. Matematiskt skulle vi kunna uttrycka regulatorn enligt v(t k ) = Ke(t k ) + a( t k ) a( t k ) = K T D T s ( y( t k ) y( t k 1 ) ) + l k T s Ke( t l ) (3.8) där u(t k ) uppdateras med frekvensen 100 Hz och a( t k ) uppdateras med frekvensen 2 Hz. Alltså kommer a( t k ) bara att uppdateras var 50:e gång som koden körs. Övriga gånger kommer regulatorn att skicka ut det värdet a( t k ) hade förra gången som a( t k ) uppdaterades. Här ges ett förslag på hur man kan göra för att exekvera en del av sin programkod i lägre frekvens än resten. Ett sätt att klocka ner en del av koden är att använda en timer. Den timer vi föreslår att man använder heter TON och finns illustrerad i figur 3.2. De TON Timer Time Base Preset Accum Tn:0 t i end i start Tn:0/EN Tn:0/DN Figur 3.2. Timer TON som kan användas för att klocka ner kod. olika registrenas funktion finns förklarade i tabell 3.2. TON fungerar som så Tabell 3.2. Sammanfattning av registrena som används av TON. Namn Förklaring Timer Det timerregister som används. Välj t.e.x. T4:0. Time Base Den bas som klockan räknar i. Preset Det antal tidsenheter timern räknar upp till. Accum Det antal tidsenheter timer räknat upp till. EN Signal som är hög när timern är aktiv, dvs när insignalen till timern är hög. DN Signal som är hög när Accum Preset att när insignalen till timern är hög börjar TON att räkna. Accum ökar med ett 1 Den intresserade kan läsa mer i Appendix??. 16

17 för varje tidsintervall som går tills dess att Accum har nått upp till Preset. När detta sker slutar TON att räkna och DN blir hög. Vi skulle alltså kunna använda en TON som räknar så lång tid vi vill ett samplingsintervall skall vara, och när timern räknat upp så lång tid, detektera detta genom att titta på DN-flaggan. Då gör vi de beräkningar som skall göras med låg frekvens, och därefter nollställer vi räknaren med hjälp av funktionen RES. Detta illustreras i figur 3.3. TON Timer T4:0 Time Base 0.01 Preset 1000 Accum 0 T4:0/EN T4:0/DN T4:0/DN (stuff) Blah... T4:0/DN T4:0 RES Figur 3.3. Kod för att skapa långsam cykel. Instruktionerna i den mellersta raden (som illustreras med blocket (stuff) och Blah...) körs var tionde sekund. 3.4 Villkorlig integration För att implementera villkorlig integration i regulatorn måste man detektera när styrsignalen mättar, alltså när vattenpumpen går för fullt eller står stilla. Villkorlig integration innebär att integralen, N10:9, bara räknas upp när styrsignalen är omättad. En omättad styrsignal svarar mot ett värde i N9:2 (skalfaktor 1 ) som ligger i intervallet [ 0, ]. För att undvika risken att 2 någon av de tre delarna (p, i eller d) kommer att bli dominerande 2 använder vi istället N10:17 (v) och N10:8 (u) (båda med skalfaktor 1 ) för att detektera 4 om styrsignalen mättat. I N10:17 läggs den icke-trunkerade styrsignalen, medan den trunkerade läggs i N10:8, därav kommentaren Begränsat intervall i tabell 3.4. På så sätt blir mättningstestet enkelt; om N10:8 inte är lika med N10:17 har styrsignalen mättat. 2 Detta kommer sig av att vi adderar tre termer och då kan det spela roll i vilken ordning additionen utförs. För den intresserade förklaras problematiken utförligare i appendix A.1. 17

18 När systemet är i stationaritet, alltså när tanknivån hålls stabil och pumpen går med en viss spänning, så är det integratordelen som står för styrsignalen. Utöver att implementera ett skydd mot integratoruppvridning behövs ytterligare en justering av integratordelen för att få bra prestanda hos regulatorn. Vi vet vidare att spänningen till pumpen som minst kan vara 0. Då finns det inte heller någon poäng att integralen, N10:9, håller ett lägre värde, utan kan trunkeras så att dess minsta värde blir 0. 18

19 3.5 Plan för minnesanvändning Här presenteras ett noga genomtänkt 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. Register Uttryck Faktor Kommentar N7:2 r 1/2 Börvärdet N7:3 K 100 Parameter för inbyggda regulatorn N7:4 100 Parameter för inbyggda regulatorn N7:5 T D 100 Parameter för inbyggda regulatorn N9:0 y upper 1/2 Tanknivå övre tanken N9:1 y lower 1/2 Tanknivå undre tanken N9:2 u pump 1/2 Styrsignal till pumpen Förslaget bygger på att allt minne som hör till den nya regulatorn ska samlas i datafilen N10. Till att börja med har filen delats in i olika avsnitt enligt tabell 3.3. Den viktigaste hjälpen ges i tabell 3.4, där vi dels har brutit ner (3.4) i bitar så att det blir rättframt att implementera, och dels ger förslag på hur olika värden ska skalas för att kunna representeras med heltal i plcn. Var 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 3.5. Att en flagga är satt (lika med 1) ska tolkas som att motsvarande funktion är aktiv. 19

20 Tabell 3.3. Uppdelning av minnet i datafilen N:10. Avsnitt Kategori N10:0 Flaggor N10:1 N10:3 Parametrar N10:4 N10:6 Mellanresultat N10:7 N10:8 Signaler N10:9 Värden för inspektion i InTouch N10:10 N10:11 Mellanresultat N10:12 N10:17 Värden för internt bruk Tabell 3.4. Skalfaktorer för fixpunkt-representationen. Notationen q 1 är en operator för bakåt-skift i tiden. Om t k 1 och t k är två på varandra följande sampeltidpunkter har vi alltså q 1 y(t k ) = y(t k 1 ). Kommentaren Begränsat intervall förklaras i avsnitt 3.4. Register Uttryck Faktor Kommentar N10:1 K 4 N10:2 K Ts 256 N10:3 K T D Ts 1 N10:4 Fritt för mellanresultat N10:5 Fritt för mellanresultat N10:6 Fritt för mellanresultat N10:7 y 1/2 Vanligtvis kopia av y upper N10:8 u 1/4 Begränsat intervall t K N10:9 t 0 e(τ) dτ l:t l t K Ts e(t l ) 1 N10:10 Fritt för mellanresultat N10:11 Fritt för mellanresultat N10:12 q 1 y 1/2 N10:13 e 1/2 N10:14 K Ts e 1 N10:15 K T D ẏ K T D Ts ( y q 1 y ) 1/4 Begränsat intervall t t 0 1 Ke(τ) dτ K T D ẏ 1/4 Begränsat intervall N10:16 N10:17 v 1/4 Tabell 3.5. Flaggor och heltalsvariabler. Att flaggan är satt (biten är = 1) tolkas som att funktionen är aktiv. Register N10:0/0 N10:0/1 Kommentar Egna pid-regulatorn inkopplad Integratoruppvridningsskydd aktivt 20

21 3.6 Strukturering av problemet Här ges en kort rekommendation för hur plc-programmet kan struktureras. Programmet ska alltså innehålla kod som gör det möjligt att exekvera en långsam cykel. I den snabba cykeln (det vill säga kod som exekveras varje gång programmet körs) återstår det att: Välja reglerstorhet genom att kopiera en mätsignal till N10:7, och beräkna reglerfelet N10:13 (innan eventuell långsam cykel). Beräkna K e med skalfaktor 1/4, på ett sätt så att en division med 4 är det sista som händer, och beräkna sedan v som summan av K e och de andra termerna (N10:16). Trunkera en kopia av v enligt ovan för att erhålla u. Ställa ut styrsignalen på N9:2. Följande saker behöver göras i den långsamma cykeln (dvs kod som enbart exekveras när T4:0/DN är hög). Gör villkorlig uppdatering (bara när styrsignalen inte mättar) av integraltermen N10:9. Gör så att uppdatering av integraltermen alltid görs då N10:0/1 är hög för att skyddet mot integratoruppvridning ska kunna stängas av. Se till att summan inte blir negativ. Dela N10:9 med 4 och lägg resultatet i N10:16. Addera eventuell derivataterm. Dessutom måste regulatorn på något sätt kunna stängas av. Programmet kan förväntas bli runt 40 instruktioner långt. 21

22 3.7 Användbara instruktioner Följande tabell listar en tillräcklig uppsättning instruktioner för att lösa uppgiften: Kod Symbol Förklaring MOV Kopiera OTU OTL x:x/x U x:x/x L x:x/x Nollställa bit Ettställa bit OTE Håll bit hög (använd inte!) ADD Addition SUB Subtraktion MUL Multiplikation DIV Division EQU Testa = GEQ Testa GRT Testa > LEQ Testa LES Testa < XIC x:x/x x:x/x Testa för hög bit XIO Testa för låg bit TON Timer för nedklockning RES RES Nollställ timer 3.8 Processdatorkopplingen Glöm inte bort den del av uppgiften som hör till användargränssnittet! 22

23 Kapitel 4 Förberedelseuppgifter Att utvecklingsmiljön för den här laborationen (RSLogix) kan kännas obekant och motsträvig är något man bör vara beredd på, men det är också en nyttig erfarenhet att ha med sig ut i industrin man får ta det onda med det goda. Övningarna i det här kapitlet kan inte heller överbrygga den tröskel man måste över när man börjar arbeta med utvecklingsmiljön, utan syftar till att underlätta förståelsen av lösningsgången. För att på bästa sätt vara förberedda inför laborationen och för att den ska gå så snabbt som möjligt att genomföra, ska ni göra följande uppgifter innan ert laborationstillfälle (detta kommer att kontrolleras av laborationsassistenten innan ni får börja med laborationen): Gör lektionsuppgifterna tillhörande lektion 1-3. Läs noga igenom detta labb-pm och gör förberedelseuppgifterna i detta kapitel. Ta med kurskompendiet och anteckningarna från lektionerna till laborationstillfället. 4.1 pid och integratoruppvridning Uppgift: I en PID-regulator ingår 3 delar, en proportionell, en integrerande och en deriverande del. Vad har dessa för uppgift i regulatorn? Uppgift: Beskriv problemet med integratoruppvridning. Vilka konsekvenser riskerar man? 23

24 Uppgift: Hur kan villkorlig uppdatering skydda mot integratoruppvridning? Förklara hur denna fungerar och nämn ytterligare en algoritm för att skydda mot integratoruppvridning. 4.2 Timing och tidskalor Med Rå i tabellerna menas de (skalade) värden som sparas i tillhörande register i plcn Den inbyggda regulatorns tidskonstanter Den inbyggda pid-regulatorn hämtar och T D från registren N7:4 respektive N7:5. Påminn dig om hur heltalen i dessa register tolkas om till tid. Eftersom våra vattentankar är en process där förlopp tar tider som är i storleksordningen sekunder, är det naturligt att använda just sekund som ingenjörsenhet för dessa variabler. Uppgift: Hur ska förhållandet mellan råa värden och ingenjörsenheter ställas in? Ta i rejält och hantera intervallet 0 10 min. Fyll i tabellen nedan: och T D Min Max Ingenjör [min] Ingenjör [s] Rå Samplingsintervallet och den nya regulatorns tidskonstanter För den nya regulatorn kommer samplingsintervallet T s, samt tidskonstanterna och T D bara finnas på övervakningsdatorn. De variabler som ställs in i plcn är istället kvoterna R I = K Ts och R D = K T D Ts. Uppgift: Antag att K = 12, = 1 [min], T D = 0.1 [min] och T s = 0.5 [s]. Vad blir dessa värden i ingenjörsenhet och vilka värden sparas i registren N10:2 och N10:3? Tänk på att exempelvis tider måste uttryckas i samma enhet. R I R D Ingenjör [ ] 24 Rå

25 Uppgift: Vi vill kunna hantera K i intervallet 0 30, i min och T D i 0 5 min. Hur ska skalningstabellerna se ut för kvoterna? R I Min Max Ingenjör [ ] 0 2,5 Rå R D Min Max Ingenjör [ ] Rå I InTouch går det att sätta upp kod som ska köras varje gång en variabel ändrar värde (data change script). Det kan vi använda för att hålla alla variabler synkroniserade. Uppgift: Vilka variabler ska ändras beroende på vilka, och hur? Uppgift: Varför är det bättre att implementera detta i InTouch än direkt i RSLogix? 4.3 Heltal och överspill Uppgift: Vilket intervall kan representeras med 16 bitar (med teckenbit)? I figur 3.1 visas två olika sätt att göra en multiplikation samt skalning. Antingen kan man göra multiplikationen först och sedan skalningen, eller omvänt. Uppgift: Vilka är för- och nackdelarna med de olika sätten och varför är lösningen i figuren ett bra val? Uppgift: 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:13? Motivera. 25

26 4.4 Programmets struktur På sida 15 finns ett förhållandevis stort program för ett göra en så konceptuellt sett enkel sak som att utföra multiplikationen K Ts e. På en hög nivå skulle vi kunna symbolisera samma program med en pseudoinstruktion: MUL e K Ts N910:14 Uppgift: Utgå från reläschemat på sida 6. Tänk igenom vad ert program ska utföra (det som skall implementeras under laborationen), ta gärna hjälp av avsnitt 3.6 (Strukturering av problemet). Vilka steg behöver utföras i de olika delarna, i vilken ordning? Gör ett programskelett genom att rita upp hela programmet med pseudoinstruktioner. 26

27 Kapitel 5 Tips 5.1 Allmäna tips De PLC:er som är kopplade till Pumba respektive Timone är av olika modeller vilket gör att kommunikationen mellan PC och PLC är olika. Det går alltså inte att byta dator utan att ändra dessa inställningar, så fortsätt arbeta på den labbstation där ni började. Spara era filer på EDU-servern, ej fillager. Gör en tabell med era mellanvariabler där ni specificerar vad som lagras i de olika registren och med vilken faktor de är sparade. Fundera på vad som görs enklast i RSLogix och vad som görs enklast i InTouch. Ändringar i koden kan bara göras i Offline-läge. Kommentera er kod. Högerklicka på en rung, välj Edit Comment och se till att den är kopplad till Attach to File/Rung. Vissa programmeringsfel kan upptäckas med hjälp av Verify rung (högerklicka på en rung) eller Verify file i menyn i överkanten. Om ingen fellista dyker upp är kodningen okej. 27

28 5.2 Felsökning Nedan följer en lista över vanligt förekommande fel. Om de inte kan lösas med nedanstående hjälp, kontakta laborations-/kursassistenten. I rullisten med Download/Upload/... står det FAULTED i rött. Välj Goto Error. Undersök om S:5/0 är ettvärd. Om så är fallet har det i någon beräkning blivit överspill som inte har tagits hand om (se teorin avsnitt 3.2.1). PLC FAULTED - FLT lyser rött på PLCn. Det är troligtvis fel på kommunikationen. Se separat dokument om konfiguration. 5.3 Hur vet ni att det ni implementerat fungerar? Några enkla tips för att se om/hur bra er kod fungerar. Er regulator och den inbyggda bör ha liknande beteende då de är inställda med samma parametervärden. För att lättare se hur er anti-windup fungerar: implementera en graf för att kunna följa integratortillståndet tidigt. Beter den sig som den ska? Vad händer då styrsignalen mättar? Då den inte mättar? Vad borde hända? 28

29 Bilaga A Kompletterande information A.1 Addition av fler än två tal Utöver att hantera integratoruppvridning måste även eventuellt överspill vid beräknande av styrsignalen hanteras. Då styrsignalen är summan av tre termer, se (3.8), är det inte helt rättframt att hantera överspill, vilket här illustreras genom att betrakta ett exempel. Beroende på i vilken ordning som additionen görs i programmet så kan man få olika svar. Vi har att den icketrunkerade styrsignalen till pumpen ges av v(t k ) = Ke(t k ) K T D T s ( y( t k ) y( t k 1 ) ) + l k T s Ke( t l ) (A.1) och vi ska genomföra additionen av de tre termerna i plcn. Antag för enkelhetens skull att de tre termerna har skalfaktorn 1 och värdena Ke(t k ) = K T D ( y( t k ) y( t k 1 ) ) = T s T s Ke( t l ) = l k Genomförs additionen så vill vi att styrsignalen ska bli = men på grund av att plcn bara kan representera tal upp till så kommer resultat av additionen att bero på i vilken ordning som vi gör summeringen 29

30 i koden. Om vi i vårt program beräknar styrsignalen genom att först addera och erhålls att v(t k ) = ( ) = }{{} =32767 p.g.a. överspill (A.2) Ett generellt och ganska enkelt sätt att hantera den här problematiken på är att se till att de tre termerna var och en är tillräckligt liten för att inte orsaka överspill när de adderas. Kräver vi exempelvis att alla termer ligger intervallet [ 10922, ] så vet vi att svaret av de tre termerna kommer att ligga intervallet [ 32766, ] och vi får inget överspill. Ett sätt att erhålla detta vore således att innan additionen utförs, trunkera de tre termerna till intervallet [ 10922, ]. I exemplet ovan skulle resultatet av additionen då bli }{{} trunkerat }{{} trunkerat + } {{} = trunkerat vilket uppenbarligen inte heller är vad vi önskade. Det fiffiga är att det går att utnyttja skalfaktorerna till att erhålla en typ av trunkering som inte kommer att tappa lika mycket information. Om vi istället delar alla termer med 3 innan additionen så är vi garanterade att alla tre termerna i additionen ligger i intervallet [ 10922, ] utan att tappa så mycket information. Efter omskalning får vi alltså att Ke(t k ) = 8000 K T D ( y( t k ) y( t k 1 ) ) = 4000 T s T s Ke( t l ) = 5333 l k och vid additionen av dessa erhålls = 9333 som har skalfaktorn 1 och således representerar det reella talet vilket 3 är nära det vi ville åstadkomma (28000). I implementationen av den egna pid-regulatorn måste något liknande implementeras, men i det fallet är skalfaktorerna för p-, i- och d-delarna inte längre 1 vilket kräver ytterligare eftertanke. Här presenteras det sätt som vi föreslår 30

31 att man löser ovanstående problematik på. Den beräknade styrsignalen, v, läggs i N10:17 som har skalfaktorn 1. Det innebär att styrsignalen ges av 4 N10:17 = Ke(t k ) }{{} med skalfaktor N10:16 }{{} har redan skalfaktor 1 4 (A.3) Om dessa två termer ligger i intervallet [ 16384, ] (efter att vi skalat Ke(t k )) så kan vi garantera att inte få problem med överspill. För Ke(t k ) löser det sig automatiskt när vi skalar om den till skalfaktorn 1. Tittar vi 4 vidare på N10:16 (som är summan av i- och d-delarna) så ges den av N10:16 = N10:9 4 + N10:15 (A.4) vilken vi vill ska ligga i intervallet [ 16384, ], vilket uppfylls om både N10:15 och N10:9 ligger i intervallet [ 8192, 8191 ]. För den senare löser det 4 sig automatiskt tack vare divisionen med fyra, medan vi i vårt program själva måste trunkera N10:15 till intervallet [ 8192, 8191 ]! Detta motiverar kommentaren Begränsat intervall i tabell 3.4. Notera att det kommer att krävas stora T D -värden för att derivatadelen ska slå i begränsningen [ 8192, 8191 ]. A.2 Problem med en alltför frekvent uppdatering av integraldelen Det kan uppstå två problem med att uppdatera integraldelen alltför frekvent. Båda dessa härrör till den begränsade upplösningen i plcns register. För det första så är det rimligt att man har ett reglerfel så att värden i storleksordningen 100 kommer att adderas till N10:9 vid varje iteration. Skulle det reglerfelet (av någon anledning) kvarstå så leder det till överspill efter 2 15 /100 3 sekunder vilket är en omotiverat kort tid med tanke på att tidskonstanten för systemet är 10 sekunder. För det andra så påverkas skalfaktorn för N10:2 som håller det skalade värdet av K Ts. Med T s = 1 används skalfaktorn 256 vilket ger tillräcklig upplösning 2 för att kunna fintrimma regulatorn. Om istället T s = 1 skulle användas så 100 skulle skalfaktorn tvingas bli cirka 50 gånger större för att behålla samma upplösning. Det skulle innebära skalfaktorn 2 13 = Vid beräkningen av K Ts e så som den utförs på sidan 15 skulle vi då byta ut 128 mot Att dividera med ett så pass stort tal (jämfört med registrens omfång) leder till 31

32 att både dynamiken och upplösningen försämras. Detta kan inses om vi betraktar fallet att vi har ett stort respektive ett litet reglerfel. I diskussionen nedan antar vi att K = 10 och = 30 sekunder, vilket är den föreslagna regulatortrimningen. Med dessa parametrar och kommer N10:2 att hålla värdet }{{} K Ts 8192 }{{} = 27 skalfaktorn Låt oss börja med små reglerfel, alltså när den initiala multiplikationen N10:13 N10:2 inte ger överspill. För att bidraget till integraldelen ska vara nollskiljt måste den multiplikationen ge ett värde enligt N10:13 N10:2 > 4096 för att att den efterföljande divisionen med 4096 inte ska ge svaret 0. För den föreslagna trimningen fås att vi måste kräva att N10:13 > 152 och således kan vi inte reglera bort reglerfel mindre än 304. För jämförelse så ska det nämnas att för skalfaktorn 1 fås att det minsta reglerfelet som kan regleras bort är 8! För stora reglerfel kommer multiplikationen N10:13 N10:2 att ge överspill och vi hamnar i situationen att vi måste dividera N10:2 med Den divisionen kommer att resultera i en kraftig informationsförlust, exempelvis kommer värdena 8000 och 5000 både resultera i att svaret blir 1. Det går att minska själva informationsförlusten genom att införa fler mellansteg genom att exempelvis inte dividera N10:2 med 4096 så fort den första multiplikationen resulterar i överspill. För att bibehålla samma informationsinnehåll som med skalfaktorn 256 skulle det dock krävas många operationer, och det skulle ta lång tid att exekvera koden. 32