Styrprojektet (LEU075) Process 4

Styrprojektet (LEU075) Process 4 Chalmers Lindholmen Mekatronikprogrammet 2004-12-07 Av Christian Gruffman och Kristinn Sigmundsson 1

1. Sammanfattning Syftet med vårat styrprojekt var att lära oss mer om mekatroniska system, öka våra engelska kunskaper samt lära oss mer om att arbeta tillsammans i grupp. Vår process 4, gick ut på att göra en sekvensstyrning av tre cylindrar styrda via monostabila ventiler, samt en likströmsmotor kopplad till en släde. Släden rörde sig längs en linjal, så man hela tiden kunde se vart den befann sig. Vi skulle även bygga en positioneringsenhet som digitalt med siffror kunde visa exakt på millimetern vart släden befann sig. Vi gick till väga på så sätt att vi programmerade PLC:n som styrde kopplingsplattan och med hjälp av en startknapp så startade processen. När vi byggde positioneringsenheten använde vi oss av PIC processor som vi programmerade i assemblerspråk samt en programmerbar PLD krets för att omvandla vår 6-bitars signal från PIC:en till två 4-bits signaler. De skickas sen vidare till två BCD (Binary Coded Decimal) enheter som sedan driver våra 7- segments LED displayer. Engelsk sammanfattning finnes i bilaga F. Fig 1.1 2

Innehållsförteckning Sida 1. Sammanfattning 2 2. Inledning 4 3. Presentation av uppgiften Process 4 5 4. Funktionsbeskrivning av PLC programmeringen 6 4.1 Programmering i SFC 6 4.1.1 Sekvens 1 6 4.1.2 Sekvens 2 7 4.1.2.1 Cylinder 2 7 4.1.2.2 Cylinder 3 8 4.1.2.3 Motorn 8 4.1.3 Sekvens 3 9 5. Funktionsbeskrivning av Positioneringsenheten 10 5.1 Beskrivning 10 5.2 Programmerbara Kretsar 11 5.2.1 PIC16F84 11 5.2.2 PLD (PALCE22V10H) 12 Bilagor Scheman och källkod Bilaga A Sequence Function Chart Bilaga B Function Block Diagram Bilaga C Källkod för PIC16F84 Bilaga D Källkod för PALCE22V10H Bilaga E Kretsschema Bilaga F English Summery 3

2. Inledning Detta arbete har utförts vid Chalmers Lindholmen under höstterminen 2004 i kursen Styrprojekt, med programkod LEU075. Vid första lektionstillfället blev vi tilldelade uppgiften att konstruera en positioneringsenhet till en sekvensstyrd Mecman-platta samt att programmera PLC:n som styrde Mecman-plattan. I denna rapport finns det utförligt förklarat hur vi gick till väga för att lösa vår uppgift samt programkoder och förklaringar på styrsystemen. 4

3. Presentation av uppgift Process 4 Vår uppgift var uppdelad i tre delar. Första uppgiften bestod av att sekvensstyra tre cylindrar samt en positioneringsenhet. Sekvensen skulle till synes vara så att: cylinder 1 ska gå till sitt främre läge och genast återgå till sitt bakre läge. Därefter ska positionering ske till 20 mm, varvid två andra sekvenser ska ske parallellt. Cylinder 2 ska gå fram och tillbaka 3 ggr och cylinder 3 ska gå fram, vänta i 2,5 sekund och därefter återvända till sitt bakre läge. När dessa tre parallella sekvenser alla är slutförda, ska cylinder 1 göra ett fram och återgående slag. Efter detta sker positionering till 43 mm, väntar där i 2 sekunder varefter den återvänder till sitt 0-läge. En presentation av slädens position mellan 0 till 63 mm skall också göras. Genom att bygga en positioneringsenhet och ta in pulssignalen från motoraxelns pulsgivare, samt en nollställningssignal från bakre gränslägesgivare till en enchipsdator PIC16F84, skall positionen bestämmas kontinuerligt. PIC:en ger ut en 6-bitars binär kod som motsvarar positionen i millimeter. Sist men inte minst var uppgiften att skriva en rapport om hela projektet. 5

4. Funktionsbeskrivning av PLC programmeringen Vi programmerade Mitsubishi PLC:n i ett program som heter GX IEC Developer, som arbetar med Function Block Diagrams (FBD) och Sequential Function Charts (SFC). Eftersom vi hade till uppgift att sekvensstyra flera olika processer så valde vi att arbeta till största delen i SFC. Detta gjorde att vi kunde programmera sekvensen i små steg, en enkel steg för steg programmering. Men vi var fortfarande tvungna att programmera en del i FBD för att kunna sätta och radera minnen och register. 4.1 Programmering i SFC 4.1.1 Sekvens 1 Vi började att med papper och penna rita upp flödesscheman som vi flitigt diskuterade om. Efter att ett fullskaligt flödesschema var skapat började vi föra in detta i programmet. Vi matade in det på så vis att vi testade sekvens för sekvens, i stället för att mata in allt, detta underlättade vår felsökning av schemat. Initial är början på programmet. Vår fysiska start sätter minnet drift (fig. 4.2). Fig. 4.2 Nästa steg kontrollerar om cylinder 1 är i bakre läge samt om drift är satt och om släden är i sitt bakre läge. Därefter startar cylinder 1, programmet väntar till att cylinder 1 är i sitt främre läge. Då nollställs drift samtidigt som drift2 och drift3 sätts (fig. 4.3). Fig. 4.4 Fig. 4.3 6

4.1.2 Sekvens 2 Efter steg ett så går sekvensen vidare till steg två. I steg två så har vi tre sekvenser som går parallellt: Cylinder 2 som skall gå tre gånger fram och tillbaka. Cylinder 3 som skall gå till sin främre position, vänta 2.5s och gå tillbaka. Positioneringsenheten skall flytta släden 20mm. 4.1.2.1 Cylinder 2 Vi börjar att kolla på cylinder 2 (fig. 4.5): Först så kan man se ett block som heter AktivDRIFT2. Detta är ett tomt block vars enda funktion är att uppfylla GX IEC Developers krav på att man inte kan ha två villkor efter varandra (det finns flera sådana block, men vi kommer inte ta upp dom mer). I nästa steg så kollar vi först och främst om cylinder 2 är i sitt bakre läge, är den det så aktiverar vi den så att den går framåt. Här har vi två villkor, ett som kontrollerar ifall count1 är satt, det andra att cylinder 2 är i sitt främre läge och att count1 inte är satt. Fig. 4.5 När cylinder 2 når det främre läget för första gången så hoppar den upp igen genom "Hopp samtidigt som en räknare ökas (fig. 4.6). När räknaren ökats tre gånger så aktiveras count1 och räknaren nollställs. Sekvensen kommer nu inte längre hoppa, utan nollställer drift2 och inväntar de andra sekvenserna. Fig. 4.6 7

4.1.2.2 Cylinder 3 Stanna satte även drift3 (fig. 4.3) som startar cylinder 3, vars uppgift är att stanna i sitt främre läge i 2,5 sekund. Programmet kollar om cylindern är i sitt bakre läge samt om drift3 är satt. Cylinder 3 aktiveras, så fort den har kommit till sitt främre läge startas en timer (fig. 4.8) som räknar tiden. Efter tiden nollställs drift3. Fig. 4.8 Fig. 4.7 4.1.2.3 Motor Blocket MOTORFRAM sätter mfram så att motorn börjar röra sig framåt. Mfram sätter även igång en räknare (fig. 4.9) som räknar pulserna givna från positioneringsenheten. Det går fem pulser per millimeter varav vi satte räknaren till att räkna upp till 100 (20mm). När positioneringsenheten rört sig 20mm framåt så sätter räknaren count2, som i sin tur nollställer mfram så att motorn stannar. Därefter så går den vidare till NTOHING (tomt block) där den inväntar de andra sekvenserna. Fig. 4.10 Fig. 4.9 8

4.1.3 Sekvens 3 Vi börjar sekvens 3 (fig4.11) med att kontrollera om alla de parallella sekvenserna är färdiga. Detta gör vi genom att kolla så att både cylinder 2 och 3 är i sin respektive bakre position samt att motorn inte rör sig framåt längre. När alla villkoren är uppfyllda så sätts cyl1 i AktivCyl1 så att den rör sig framåt. När den kommit till sin främre position så inaktiveras den genom att hoppa vidare till ett tomt block, varefter programmet inväntar på att den återvänder till sitt bakre läge. Vi går vidare till blocket MOTORFRAM2, där startar vi motorn återigen och en annan räknare (fig. 4.12), som även räknat pulserna ifrån föregående förflyttning, börjar räkna igen. Den här gången så har vi ställt in räknaren Fig. 4.11 på 215 (43mm). Då positioneringsenheten Fig 4.12 förflyttat sig sina ytterliga 23mm sätts count3, som i sin tur nollställer mfram (fig. 4.13). I WAIT blocket så startar vi en klocka (fig4.14) som låter positioneringsenheten vänta i 2s innan den sätter mbak. Motorn rör sig nu bakåt, och när positioneringsenheten kommit till sitt bakre läge är sekvensen färdig. Vi hoppar up till INITIAL och inväntar signal från startknappen igen. Fig. 4.13 Fig. 4.14 För kompletta scheman se bilaga A och B. 9

5. Funktionsbeskrivning av Positioneringsenhet 5.1 Beskrivning Positioneringsenhetens uppgift är att presentera slädens position på två stycken 7-segments Led Displayer. Enheten tar in pulssignaler från motoraxelns pulsgivare, den ska även kunna ta in en nollningssignal från den bakre gränslägesgivaren som släden aktiverar när den är i det bakre läget. Samt ta in en signal som anger om motorn går fram eller bak. Signalerna skickas till en enchipsdator PIC16F84 som ska behandla signalerna, samt skicka ut en 6-bitars binärkod som anger slädens nuvarande position till PLD:n. Sen omvandlar koden till två 4-bitars signaler, en för varje siffra. Signalen skickas vidare till två stycken BCD:er vars uppgift är att konvertera 4-bits signalen till 7-segmentskod och vidare in till Displayerna. Ett komplett kretsschema kan ses i bilaga E. Fig. 5.1 10

5.2 Programmerbara kretsar De programmerbara kretsarna i vår uppgift är en PIC16F84 och PALCE22010H som är en Programable Logic Device. 5.2.1 PIC16f84 PIC:en är designad som en liten dator med minnen, stack, adressregister, in och utgångar samt ett EEPROM (Electrically Erasable Programmable Read- Only-Memory). Programspråket vi använder oss av för att programmera kretsen är assembler. Fig 5.2 Vi ska gå in lite noggrannare på vilken uppgift PIC:en var tvungen att utföra åt oss. För det första så skall den ta emot pulser ifrån positioneringsenhetens pulsgivare, men vi får in fem pulser per millimeter. Alltså är PIC:en tvungen att räkna fem pulser innan den påverkar värdet på displayen. Detta gjorde vi genom att sätta in värdet 251(FBh) i tmr0 (som är vår pulsräknare). För att när PIC:en räknat fem pulser så är värdet i tmr0 0, och då blir Z-flaggan satt. Alltså kan vi efter var femte puls sätta tmr0 till 251 och vänta på att Z-flaggan blir satt. Då den blir satt ökar eller sänker vi värdet som går ut på portb, beroende på om motorn går framåt eller inte och sätter tmr0 till 251 igen. En annan viktig funktion är nollställningen. Varje gång som släden kommer tillbaka till sitt bakre läge och aktiverar gränslägesgivaren så nollställer vi värdet på portb och tmr0. Så att alla felande pulser och/eller värden rensas efter varje körning. För mer utförlig beskrivning se den kommenterade källkoden i bilaga C Kommentar: Ett problem med våran programmering av PIC:en är att den avger en 6-bitars signal, vilket gör att den kan aldrig räkna över 63. Detta var nu inget större problem för oss, då släden bara skulle gå 43 mm från utgångsläget. 11

5.2.2 PLD (PALCE22V10H) Från PIC:n kommer informationen om vilket läge som positioneringsenheten befinner sig vid, i binär form. Vi har programmerat PLD:n så att den har en 6-bitars ingång och två 4-bitars utgångar. De 6 bitarna på ingången kommer från PIC:n. De två 4-bitars utgångarna kopplas till ingångarna på två BCD:er som i sin tur driver segmenten på displayerna. Beroende på hur du skriver ditt program och när du kompilerar det, så väljer kompilatorn ut vilka portar som ska gå vart. På grund av detta har vi kopplat symboliskt i kretsschemat från PLD:n till BCD:erna. Fig. 5.3 För mer utförlig beskrivning se den kommenterade källkoden i bilaga D 12

.// $/ &5 0'12 3.-* 0'12-4* 0'12 3* 67(( $/. -5 0'12 3.-5* $/. -5 4757-4 0'12 3.-5* 0'785 * $/ $/ 576.) 0'785 * 0'12-4 75* 0'12-4 75* 67((.35.9.35.9 $/!.35.9 4757-4 :.5 0'12 3 12* 0'12-4* 0'12 3* 0'785 * 0'4(7& 3*..5.2;&5<(.// 43= &5<($/ 12= &5<(&5 &57(= &5<($/.-5 &5<($/ 12= &5<(.35.9 &5;.-5= &5<($/.-5!"#$%!" &$ '()*",!'&-* (

&5<($/ 12= &5<(.35.9 &5<(4757-4 4-4= &5<(576.) &5<($/! 12= &5<(.35.9 &5<(4757-4 4-4= &5<(:.5 28&5= 504(7&3= 50785= 50123= 5012-4= 50123 123 754-4= 50785= 5012-4 75785= 5012-4 75.-5= 50785= 50123.-5= 50123.-5= 50123= 5012-4= 50123.-5 4(7&3=!"#$%!" &$ '()*",!'&-*>/" ">/ /" (

311 35178 4,1 8'63*9 3178 6:1 "$-;./ 0% 12 8'63*9 3178 6:1; 311 3178 0:31 316' 3178 4,1 316' 35178 4,1 316' 35178 4,1; <0,8 6:1 ; 6:1578 "2 => "$-?./ 0% 12 317 4,1 3178 4,1!"#$%!" "&'()*"!&,* ) '

4,1 74 61 3178 6:1 <0;,8 1-2 16 4 '1 @ 51 3178 4,1; 8':03 6:1 6:1578 "2 => "$-;./ 0% 12 6:1 3178 8,8 8':03 6:1; 6:1578 "2 => 6:1; 3178 8,8 0:31 1-2 16 4 '1 @ 51 35178 8*9!"#$%!" "&'()*"!&,* )"$- '

status equ 0x03 ;Här sätter vi namn på olika addresser så vi slipper porta equ 0x05 ;att varje gång skriva den exakta addressen trisa equ 0x85 portb equ 0x06 trisb equ 0x86 tmr0 equ 0x01 optionr equ 0x81 clrf status ;Rensar status-minnet bsf status, 5 ;Använder bank1 movlw 0x00 movwf trisb movlw 0x1F movwf trisa movlw 0x28 movwf optionr ;Ställer in alla B-portar som utgångar ;Ställer in alla A-portar som ingångar ;Sätter TMR0 till en räknare. ;Och att den räknar på "rising-edge". bcf status, 5 ;Återgår till bank0 mloop movlw 0xFB movwf tmr0 fempuls_loop btfss porta, 3 goto ejbak clrf portb clrf tmr0 ;Kontrollerar om positionerings- ;enheten är i sitt bakre läge ;Om inte så hoppar programmet ;över nollställning av positionen ;Annars nollställer den positionen. ;Nollställer tmr0 så att inga felande ;pulser ligger kvar ejbak movf tmr0, 0 ;Kopierar tmr0 till sig självt för ;att påverka flaggorna btfss status, 2 ;Det här steget kontrollerar ifall ;Z flaggan har satts, och då vet vi ;att det hargått fem pulser, och vi ;kan gå vidare i programmet. Om det ;inte har gått fem pulser så hoppar goto fempuls_loop ;vi tillbaka och kontrollerar igen. btfss porta, 2 decf portb, 1 btfsc porta, 2 incf portb, 1 goto mloop END ;kontrollerar riktningen av motorn, genom ;att kontrollera ifall ingången RA0 är '1' ;eller '0'. Sen ökar den eller sänker ;värdet på portb beroende på riktning av motorn ;Hoppar tillbaka till början och startar om.

library ieee; use ieee.std_logic_1164.all; Här väljer vi vilket bibliotek vi vill använda samt vilken del av det. entity omvandlarn is port(x: in std_logic_vector(0 to 5); end omvandlarn; fyrbit: out std_logic_vector(0 to 7)); Ställer in att "omvandlarn" använder inport 0-5 Ställer in att "omvandlarn" användet utport 0-7 architecture utseende of omvandlarn is Påbörjar beskrivningen av hur kretsen är "byggd". Alltså vilka utsignaler som genereras av olika insignaler. begin fyrbit<="00000001" when x = "000001" else Här har vi alltså en väligt enkel "00000010" when x = "000010" else uppbyggnad av programmet, massvis av "00000011" when x = "000011" else "ersättningsvillkor". Som exempelvis det "00000100" when x = "000100" else första villkoret: insignalen på PLDn är: "00000101" when x = "000101" else 000100, så kommer utsignalen att vara: "00000110" when x = "000110" else 00000100. Nu ser dom tillsynes likadana "00000111" when x = "000111" else ut, men det beror på att vi inte kommit "00001000" when x = "001000" else upp till 10 än. Om vi tar ett exempel "00001001" when x = "001001" else lite längre ner (markerat med <-) så kan "00010000" when x = "001010" else man se att utsignalen skiljer sig "00010001" when x = "001011" else avsevärt från insignalen. "00010010" when x = "001100" else "00010011" when x = "001101" else I det markerade exemplet nedan ser vi "00010100" when x = "001110" else att insignalen är "011111" alltså "00010101" when x = "001111" else siffran 32 decimalt. Om vi tar en titt "00010110" when x = "010000" else på utsignalen så ser vi: "00110000". "00010111" when x = "010001" else Delar vi upp denna till två fyrabits- "00011000" when x = "010010" else värden får vi "0011" och "0001" "00011001" when x = "010011" else alltså siffrorna 3 och 1. Signalerna "00100000" when x = "010100" else kan sedan skickas till varsin BCD för "00100001" when x = "010101" else att på två 7-segments displayer, visa "00100010" when x = "010110" else siffran 31. "00100011" when x = "010111" else "00100100" when x = "011000" else "00100101" when x = "011001" else "00100110" when x = "011010" else "00100111" when x = "011011" else "00101000" when x = "011100" else "00101001" when x = "011101" else "00110000" when x = "011110" else "00110001" when x = "011111" else <- "31" "00110010" when x = "100000" else "00110011" when x = "100001" else "00110100" when x = "100010" else "00110101" when x = "100011" else "00110110" when x = "100100" else "00110111" when x = "100101" else "00111000" when x = "100110" else "00111001" when x = "100111" else "01000000" when x = "101000" else "01000001" when x = "101001" else "01000010" when x = "101010" else "01000011" when x = "101011" else "01000100" when x = "101100" else "01000101" when x = "101101" else "01000110" when x = "101110" else "01000111" when x = "101111" else

"01001000" when x = "110000" else "01001001" when x = "110001" else "01011010" when x = "110010" else "00000000"; Om PLDn skulle ta emot ett värde som vi inte gjort ett villkor för så skickas: "00000000" ut. end utseende;

Logic Control Project The purpose of our project was to learn more about mechatronical systems, enhance our English and to get more experience with team working. Our project tasks were to make a sequence steering with a position presentation. In plain English, our work was to steer three pneumatic cylinders and a position unit. The unit moved along a ruler so that you could see it s position. The mechanical parts were already assembled on a laboratory Mecman-plate, and connected with a Mitsubishi PLC-system. We had to program the system by ourselves with GX IEC Developer, which works with function block diagrams (FBD) and Sequential Function Charts (SFC). This project forced us to learn much about the Mitsubishi PLC-system and how to use a new type of programming that we had never used before. The three cylinders and the position unit would move independently of each other. We decide to do most of the programming with help of SFC instead of FBD. This allowed us to program the whole sequence in small steps. Because we did not have any user inputs, except the start button, which makes the programming of the PLC-system a simple step by step procedure. Some of the programming still had to be made in FBD, where we decided which inputs would set or reset the memories. The special sequence given to us by our lecturer was the following: 1. The first cylinder was to make a forth and back punch. 2. The second cylinder would move forth and back three times. Meanwhile the third cylinder was to move to it s front position, wait there for two and a half second and then return back. Our position unit was to move twenty millimetres. 3. Then the position unit waits for the first cylinder to make another forth and back punch. 4. The position unit moves another twenty three millimetres along the ruler and stops at forty three. When that was done we had to build a presentation unit of two Single Digit Displays, a seven-segment unit, a PIC16F84 and a PALCE22 circuit to present where the position unit stood. The PIC is designed like a small computer with memory, stack, address register, Input and Output ports and an EEPROM. The programmable part of the PIC is the EEPROM. The language used to program the circuit is assembler. When we programmed the PIC, we decided to use the special counter function that is integrated in one of the ports. The counter received the pulses given by the position unit. Then we programmed the PIC to calculate these pulses and then to send out a six-bit signal. Because we only use a six-bit signal the maximal number sent out by the PIC is sixty three. This is not a problem for us, because the position unit only moves to forty three and no further. 1

The six-bit signal is then sent to the PALCE22 circuit, which we also were to program to divide it into two four bit signals, and then send it further on to the seven-segment latch and driver. The seven-segment latch and driver sent the signal to our Leddisplay where the presentation was given. As this project proceeded, we learnt more about connecting different systems, both mechanical and electronical. We also learned some technical English. We had never programmed with the help of function block diagrams or Sequential function carts before this project, only with ladder diagrams. Therefore this has been a really healthy experience for us. By: Christian Gruffman and Kristinn Sigmundsson. 2