Embed Size (px)
Citation preview
Automazione Industriale –Esempi di programmazione IEC
61131-3
Marcello Bonfe
Dipartimento di Ingegneria
Universita’ di Ferrara
Novembre 2001
Capitolo 1
Linguaggi di programmazione basedello Standard IEC 61131-3
1.1 Introduzione
Lo Standard IEC 61131-3 definisce gli elementi basilari la programmazione di sistemi di controllobasati su Controllori Logici Programmabili (PLC), quali linguaggi, tipi di dato, unita organizzativedel software.
I dispositivi di controllo commerciali, d’altra parte, hanno molto spesso caratteristiche peculiarifortemente legate alla Casa Costruttrice, come:
• l’esatta sintassi del (o dei) linguaggi di programmazione supportati dall’ambiente di sviluppo.
• le modalita di dichiarazione ed utilizzo delle variabili di programma.
• i costrutti per la scomposizione del software in moduli riutilizzabili.
Tuttavia, e innegabile che le metodologie e le tecniche di programmazione siano maggiormente inrelazione con la funzionalita svolta da un certo dispositivo di controllo, piuttosto che con le suecaratteristiche hardware.
Pertanto, si desidera fornire con questi pochi esempi di programmazione, basati sulla sintassidei linguaggi standardizzati nel documento IEC 61131-3, un primo approccio, generico e svincolatoda particolari tecnologie proprietarie, alle problematiche di Controllo Logico e Supervisione tipichedell’Automazione Industriale. Sebbene lo Standard non sia vincolante sintatticamente come avvieneper altri linguaggi di programmazione (ANSI C, Java, ecc.), si auspica che l’acquisizione dei suoiconcetti basilari da parte dello studente permetta comunque una fase di apprendistato sui sistemireali, (eventualmente) fronteggiati in futuro, piu agevole (o almeno, meno “ostica”...).
Dal punto di vista pratico, nonostante il linguaggio maggiormente diffuso nella programmazionedei PLC sia il Ladder Diagram, in virtu della sua semplicita di comprensione anche da parte di tecnici(in particolare elettrotecnici) grazie alla similitudine con i diagrammi elettromeccanici a contatti ebobine (rele) utilizzati fino a qualche decina di anni fa nell’Automazione Industriale, si vedra comele stesse problematiche possano essere risolte in modo equivalente in ciascuno dei linguaggi IEC61131-3.
1.2 Controllo dell’avviamento di dispositivi di attuazione
Molte delle operazioni tipiche del controllo di Macchine Automatiche sono riconducibili alla abili-tazione di una singola uscita booleana, che potrebbe essere il comando di avviamento di un semplicedispositivo di attuazione, per tutta la durata della produzione dell’impianto. Un esempio di talenecessita e rappresentata dalla movimentazione di nastri trasportatori, i quali devono fare scorrereil prodotto all’interno dell’impianto automatizzato fintanto che tutte le macchine sono in funzione,
2
i quali sono normalmente azionati da motori elettrici la cui velocita viene regolata meccanicamentein funzione del carico del nastro. Per tali motori e quindi sufficiente la chiusura del contatto dialimentazione tramite un segnale logico in uscita dal PLC. Tale segnale sara disabilitato in fun-zione dell’arresto della macchina, sia esso dovuto al termine “normale” della produzione o ad unacondizione di emergenza.
Ipotizzando di avere dichiarato le seguenti variabili:
VARAvvio_Macchina: BOOL AT %I0.0;Stop_Macchina: BOOL AT %I0.1;Emergency: BOOL AT %M0.0;Motore_Nastro: BOOL AT %Q0.0;
END_VAR
uno schema di programma classico per l’avvio del motore del nastro trasportatore e rappresentatodal seguente segmento di codice LD, che realizza la cosiddetta “bobina con autoritenuta”:
| Avvio_Macchina Emergency Stop_Macchina Motore_Nastro |+-----| |---------+------|/|----------|/|---------------( )------+| | || Motore_Nastro |+-----| |---------+|
Ricordando che la scansione del programma da parte del PLC avviene in modo ciclico, e cheil valore delle variabili di memoria e di uscita viene mantenuto tra due cicli di elaborazione suc-cessivi, la valutazione del segmento permette l’inserimento del motore del nastro quando il segnaleAvvio Macchina e vero anche per un solo ciclo di elaborazione, mantre per tutti i cicli successiviverra mantenuto grazie al passaggio di “corrente virtuale” nel contatto condizionato dal valore del-l’uscita Motore Nastro (autoritenuta). Tale bobina sara eccitata fintanto che non si ha un valorevero ne dall’ingresso Stop Macchina, ne dalla condizione di allarme Emergency, variabile di memoriainterna del PLC modificata in altri segmenti di programma in funzione di eventuali condizioni dimalfunzionamento generale della macchina.
Naturalmente, questo semplice segmento puo essere modificato in maniera molto intuitiva perconsiderare altre condizioni necessarie all’avviamento o sufficienti per lo spegnimento, rispettivamenteinserite nel ramo a monte della diramazione di autoritenuta o a valle di essa.
Come si puo notare, tale schema risulta perfettamente compatibile con la creazione di un circuitoelettromeccanico reale, in quanto non utilizza nessun tipo di istruzione diversa da operazioni pura-mente logico-combinatorie. Inoltre, anche la sua implementazione con il linguaggio Instruction List(IL) risulta di facile lettura:
LD Avvio_MacchinaOR Motore_NastroANDN EmergencyANDN Stop_MacchinaST Motore_Nastro
Un’altra situazione molto comune nell’utilizzo di un attuatore semplice come un motore elet-trico direttemente connesso all’alimentazione, e quella nella quale il motore puo essere alimentatoin modalita perfettamente simmetrica, in maniera tale che si possa selezionarne anche la direzione
3
di marcia. In questo caso, una semplice soluzione consiste nel controllare l’abilitazione dei coman-di di rotazione oraria o anti-oraria con segmenti analoghi al precedente, ma nei quali sia inseri-to un “interblocco” che impedisca un’attivazione contemporanea dei due segnali (condizione cheprovocherebbe un cortocircuito sui terminali del motore).
VAR...Rotaz_Sx:BOOL AT %M0.1Rotaz_Dx:BOOL AT %M0.2Marcia_Nastro_Sx:BOOL AT %Q0.1Marcia_Nastro_Dx:BOOL AT %Q0.2
END_VAR
(* Avviamento macchina e condizioni per la rotazione oraria *)
| Avvio_Macchina Rotaz_Sx Emergency Stop_Macchina+-----| |-------------| |-----+------|/|----------|/|------>Continua>| || Marcia_Nastro_Sx |+-----| |---------------------+|
Marcia_Nastro_Dx Marcia_Nastro_Sx |>Continua>-------------|/|------------------( )------+
|
(* Avviamento macchina e condizioni per la rotazione anti-oraria *)
| Avvio_Macchina Rotaz_Dx Emergency Stop_Macchina+-----| |-------------| |-----+------|/|----------|/|------>Continua>| || Marcia_Nastro_Dx |+-----| |---------------------+|
Marcia_Nastro_Sx Marcia_Nastro_Dx |>Continua>-------------|/|------------------( )------+
Come si puo notare, l’interblocco e rappresentato dal valore dell’uscita di comando della rotazionesimmetrica a quella attivata dalla bobina in esame. In tal modo, e effettivamente impossibile abilitarecontemporaneamente entrambe le uscite, anche se per un errore del programma vi fosse un ciclo diesecuzione nel quale le variabili booleane Rotaz Dx e Rotaz Sx fossero contemporaneamente vere.
L’equivalente in IL dei due segmenti precedenti e:
(* Avviamento macchina e condizioni per la rotazione oraria *)
LD( Avvio_MacchinaAND Rotaz_Dx)OR Marcia_Nastro_SxANDN EmergencyANDN Stop_MacchinaANDN Marcia_Nastro_DxST Marcia_Nastro_Sx
4
(* Avviamento macchina e condizioni per la rotazione anti-oraria *)
LD( Avvio_MacchinaAND Rotaz_Sx)OR Marcia_Nastro_DxANDN EmergencyANDN Stop_MacchinaANDN Marcia_Nastro_SxST Marcia_Nastro_Dx
La realizzazione delle funzionalita equivalenti in linguaggio Function Block Diagram (FBD) eStructured Text (ST) e lasciato come esercizio allo studente.
1.3 Controllo diagnostico e rilevazione di allarmi
Una funzionalita indispensabile realizzata dai Controllori Logici Programmabili e rappresentata dalladiagnostica e dalla rilevazione di condizioni di malfunzionamento generale dell’automatismo control-lato. Tali condizioni possono essere, ad esempio, l’apertura di un pannello di protezione che permettel’accesso a zone della macchina pericolose per l’operatore, la segnalazione di un surriscaldamento odi una sovracorrente da parte del driver di un motore elettrico, ecc.
Le condizioni di errore e malfunzionamento di un automatismo possono generare da parte delcontrollore diverse reazioni, a seconda del livello di “gravita” dell’allarme. Tipicamente, vi possonoessere condizioni che richiedono un arresto immediato della macchina, nel qual caso il programmadi controllo deve in genere disabilitare il prima possibile tutte le uscite di comando degli attuatori(es. Motore Nastro), oppure condizioni che richiedono un arresto controllato della macchina (ilcosiddetto “arresto in fase”) in modo che al ripristino delle condizioni operative, la fase di riavviodella macchina richieda il minor tempo possibile.
Nell’esempio seguente, si considera il caso in cui il PLC debba monitorare i segnali provenientida sensori che rilevano la presenza di un incendio in una zona a rischio, come schematizzato in Figu-ra 1.1. Nella zona da controllare sono presenti tre sensori identici, posizionati in punti opportuni, esi desidera che nel caso in cui uno solo di questi sensori fornisca un segnale logico vero, venga avviatauna segnalazione di “pre-allarme” con l’accensione di un segnale luminoso. Tale segnalazione puoessere spenta se il sensore non fornisce piu un valore vero. Se invece, piu sensori sono attivi contem-poraneamente, allora verra generata una condizione di allarme e di arresto immediato della parteoperativa, condizione che potra essere resettata solamente attraverso un intervento dell’operatoreumano.
La sequenza di segmenti LD per il monitoraggio dei sensori e la seguente:
VARSens1:BOOL AT %I0.0Sens2:BOOL AT %I0.1Sens3:BOOL AT %I0.2MAN1:BOOL AT %I0.3 (* E’ possibile anche una segnalazione manuale
di incendio *)CL_Alarm:BOOL AT %I0.4 (* Reset manuale della condizione di allarme*)Alarm:BOOL AT %Q0.0Pre_alarm:BOOL AT %Q0.1
END_VAR
(* Verifica delle condizioni di pre-allarme *)
5
Figura 1.1: Sistema di controllo anti-incendio
| Sens1 Pre_alarm+-----| |------+-------------------------( )----|| || Sens1 |+-----| |------+| || Sens1 |+-----| |------+|
(* Verifica delle condizioni di allarme generale *)
| Sens1 Sens2 Alarm+-----| |-----| |----+-------------------------(S)----|| || Sens1 Sens3 |+-----| |-----| |----+| || Sens2 Sens3 |+-----| |-----| |----+| || MAN1 |+-----| |------------+
(* Reset manuale della segnalazione di allarme *)
| CL_Alarm Alarm+-----|P|-----------------------------(R)----||
6
Come si puo notare, in questo esempio si e fatto uso di istruzioni LD leggermente evolute rispettoalle semplici repliche di contatti e bobine elettromeccaniche, come le bobine ritentive (---(S)-- e---(R)--) e il contatto rilevatore di fronti di salita (---|P|---).
Per quanto riguarda una implementazione in IL dei segmenti precedenti, occorre notare che larilevazione del fronte di salita non e prevista come istruzione nativa del linguaggio, ma e necessarioutilizzare un’istanza del Function Block Standard di tipo R TRIG (Rising edge Trigger), unblocco avente un unico ingresso booleano, CLK ed un unica uscita booleana Q che assume valorevero in corrispondenza di un fronte di salita dell’ingresso.
Come per ogni Function Block, occorre che l’uso di tale trigger sia dichiarato espressamente trale variabili di programma. Pertanto il codice IL diventa:
VARSens1:BOOL AT %I0.0Sens2:BOOL AT %I0.1Sens3:BOOL AT %I0.2MAN1:BOOL AT %I0.3 (* E’ possibile anche una segnalazione manuale
di incendio *)CL_Alarm:BOOL AT %I0.4 (* Reset manuale della condizione di allarme*)Alarm:BOOL AT %Q0.0Pre_alarm:BOOL AT %Q0.1Fronte_Reset:R_TRIG;
END_VAR
(* Verifica delle condizioni di pre-allarme *)
LD Sens1OR Sens2OR Sens3ST Pre_alarm
(* Verifica delle condizioni di allarme generale *)
LD( Sens1AND Sens2)OR( Sens1AND Sens3)OR( Sens2AND Sens3)OR MAN1S Alarm
(* Reset manuale della segnalazione di allarme *)
LD CL_alarmCLK Fronte_ResetLD Fronte_Reset.QR Alarm
Si noti come sia possibile per il Function Block Standard R TRIG utilizzare l’ ingresso del bloc-co come un operatore del linguaggio. Infatti, la riga di codice CLK Reset trigger corrisponde in
7
modo implicito alla chiamata dell’FB ed all’assegnazione al suo ingresso del valore dell’accumulatore.Tale meccanismo di estensione del linguaggio puo essere utilizzato solamente per alcuni dei FunctionBlocks Standard (si veda per una panoramica completa la descrizione del linguaggio IL). L’uscitadel FB deve poi essere riferita esplicitamente e caricata nell’accumulatore: se ha valore vero, imponeil reset della variabile Alarm.
La realizzazione in FBD e ST viene lasciata come esercitazione allo studente (si noti che in FBDoccorrerebbe istanziare esplicitamente anche i Function Block di tipo SR, set/reset, utilizzati).
1.4 Elaborazione di numeri reali
L’evoluzione dei dispositivi di Controllo Logico, grazie all’utilizzo di microprocessori “general-purpose”(cioe non piu orientati esclusivamente ad operazioni logiche) ed all’espansione delle capacita di memo-ria ed elaborazione, ha fatto sı che le funzionalita che possono essere egregiamente svolte dai PLCnon siano limitate alle sole operazioni di logica combinatoria e sequenziale, ma anzi, siano semprepiu efficienti anche nell’esecuzione di operazioni matematiche che coinvolgano valori numerici interio reali.
Negli esempi successivi, vedremo appunto alcune semplici situazioni che richiedono operazioni diconfronto e aritmetiche su valori reali.
Si supponga di dover controllare la temperatura di un forno, avendo a disposizione un sensoreanalogico ed una serpentina comandata tramite un interruttore “acceso/spento”. Il tipo di controllonormalmente utilizzato in questi casi e il cosiddetto controllo on/off con isteresi. In sostanza,il valore numerico reale fornito dal sensore viene confrontato con il valore di temperatura che sidesidera mantenere. Se la serpentina e accesa e questi differiscono per una quantita maggiore di uncerto ε la serpentina viene spenta. Viceversa, se la serpentina e spenta e la temperatura scende oltreε al di sotto del riferimento, essa viene riaccesa, come schematizzato in Figura 1.2.
TemperaturaSet_Point
Comando
1
0
+ Eps-Eps
Figura 1.2: Controllo temperatura con ciclo di isteresi
Dato che tale tipo di controllo e molto comune nella pratica e che esso puo essere necessario permolteplici attuatori nello stesso sistema automatizzato, risulta molto efficiente incapsulare la fun-zionalita in un Function Block riutilizzabile, che abbia come ingressi il valore misurato, il riferimentodi temperatura ed ε, e come uscita il comando booleano di accensione della serpentina.
La realizzazione del controllo con isteresi in linguaggio ST e la seguente:
FUNCTION_BLOCK Isteresi
VAR_INPUTTemperatura:REAL;Set_Point:REAL;Eps:REAL;
END_VAR
8
VAR_OUTPUTComando:BOOL;
END_VAR
(* Algoritmo interno del Function Block *)
IF Comando THENIF Temperatura > (Set_Point + Eps) THEN Comando := FALSE;END_IF;
ELSIF Temperatura < (Set_Point - Eps) THEN Comando := TRUE;END_IF;
END_FUNCTION_BLOCK
Si noti che fintanto che il valore di comando e vero, viene testato solamente il superamento delvalore di temperatura piu alto consentito, resettando eventualmente il comando, il viceversa se talevalore e falso.
Per una realizzazione in IL del Function Block, occorre utilizzare delle operazioni di salto con-dizionato, come e intuibile per il fatto di aver utilizzato un costrutto di selezione nel linguaggio dialto livello ST. Il codice del FB diventa quindi:
(* Algoritmo interno del Function Block *)
LD ComandoJMPCN Caso_Spento (* Salto eseguito solo se Comando = FALSE *)
Caso_Acceso: (* se non esegue il salto continua da qui *)LD TemperaturaGT( Set_PointADD Eps)R ComandoJMP Fine (* Salto incondizionato *)
Caso_Spento:LD TemperaturaLT( Set_PointSUB Eps)S Comando
Fine:
END_FUNCTION_BLOCK
Per realizzare la funzionalita con un linguaggio grafico, sia LD che FBD occorre invece utilizzare iblocchi di istruzione di confronto, addizione e sottrazione, definiti nella IEC 61131-3 come FunctionsStandard (non Function Blocks, pertanto non occorre la loro dichiarazione). Ad esempio, i segmentiLD che permettono di realizzare il ciclo di isteresi potrebbero essere:
(* Algoritmo interno del Function Block *)
9
| +------------+| Comando | GT | Comando |+-------------| |----------------+ EN +-----(R)-----+| | | || Temperatura -----+ || | || +-------+ | |
| ADD | +---+ |Set_Point ---+ | | | |
| +---+ +------------+Eps ---+ |
| |+-------+
| +------------+| Comando | LT | Comando |+-------------|/|----------------+ EN +-----(S)-----+| | | || Temperatura -----+ || | || +-------+ | |
| SUB | +---+ |Set_Point ---+ | | | |
| +---+ +------------+Eps ---+ |
| |+-------+
Si noti come le operazioni di confronto siano abilitate o disabilitate (pertanto eseguite o meno) inrelazione al valore di Comando, e come l’uscita di tali blocchi permetta di settare o resettare tale valore.
Si supponga ora di avere la necessita di monitorare dal punto di vista statistico e diagnosticouna batteria di sensori di temperatura analogici, allo scopo di rilevarne il valore massimo, minimo eil valore medio. Per realizzare tale operazione, si puo pensare di collezionare il valore acquisito daisensori in un vettore di numeri reali e di eseguire quindi un ciclo di istruzioni con le operazioni disomma e confronto necessarie:
VARTemperature:ARRAY[1..32] OF REAL;Max, Min, Media: REAL;
END_VAR
VAR_TEMPSomma:REAL;Count:INT;
END_VAR
Max := 0;Min := 0;Somma := 0;
FOR Count := 1 TO 32 DO
10
Somma := Temperature[Count] + Somma;
IF Temperature[Count] > Max THEN Max := Temperature[Count];END_IF;
IF Temperature[Count] < Min THEN Min := Temperature[Count];END_IF;
END_FOR
Media := Somma / 32;
La realizzazione di tale funzionalita con il linguaggio IL, richiede ancora l’utilizzo di istruzioni disalto condizionato. Tuttavia, al contrario dell’esempio precedente, che realizzava un costrutto tipo IF.. THEN, in questo caso occorre realizzare un costrutto iterativo, pertanto e necessario introdurreanche salti “all’indietro”, per i quali cioe la label che indica il punto di arrivo del salto si trova inuna posizione precedente a quella dell’istruzione di salto:
(* Variabili ... *)
LD 1ST Count
Ciclo:LD SommaADD Temperature[Count]ST SommaLD Temperature[Count]GT MaxJMPCN Nonmassimo (* Salto condizionato dal risultato del
confronto *)LD Temperature[Count]ST Max
Nonmassimo:LD Temperature[Count]LT MinJMPCN Nonminimo (* Salto condizionato dal risultato del
confronto *)LD Temperature[Count]ST Min
Nonminimo:LD CountADD 1ST CountGT 32JMPCN Ciclo (* Se Count <= 32 riparte dalla label iniziale Ciclo *)LD Somma (* altrimenti esegue queste ultime istruzioni fuori dal
ciclo *)DIV 32ST Media
Fine: (* Label non strettamente necessaria *)
11
La realizzazione in LD e soggetta a problematiche analoghe relative all’utilizzo di istruzioni disalto, condizionate dall’uscita logica di blocchi come quelli utilizzati nell’esempio del ciclo di controllocon isteresi. In tal caso, occorrera inserire come elemento terminale del segmento LD contentente leistruzioni di confronto l’elemento grafica che indica il salto:
|+---- (* Elementi grafici di confronto ... *) -->>Nonmassimo|
...
Nonmassimo:...
La descrizione completa del codice LD e FBD (molto simile) e lasciata come esercizio allo studente.
1.5 Selezione tra molteplici alternative.
Nel controllo di un automatismo, puo talvolta essere necessario discriminare le operazioni da eseguirein risposta ad un determinato evento, quale potrebbe essere un comando dell’operatore, tra differentipossibili alternative. Tali alternative sono in genere condizionate dallo stato del sistema al momentodell’evento o dalla tipologia dell’evento stesso.
Si consideri, ad esempio, un serbatoio di materiale liquido che debba essere riempito o svuotato aseconda delle operazioni selezionate da un supervisore, umano o meno, dell’impianto. Il programmadi controllo deve agire opportunamente aprendo o chiudendo le valvole di ingresso prodotto e discarico in base al comando ricevuto ed al livello di liquido contenuto nel serbatoio. Si suppongainoltre che il materiale nel serbatoio possa essere mescolato azionando le pale di un agitatore, e chequest’ultimo possa essere attivato solamente quando il serbatoio sia completamente pieno. Il sistemae schematizzato in Figura 1.3.
Scarico
Livellobasso
Livello Alto
Riempimento
Agitatore
Figura 1.3: Serbatoio con miscelatore
Il livello della vasca puo essere determinato in base a due sensori logici che rilevano la presenzadi un galleggiante in posizioni opportune, Livello Basso e Livello Alto; ciascuna valvola viene
12
comandata con un unico segnale logici, se vero la valvola si apre, se falso si chiude; il motoredell’agitatore viene comandato con un segnale on/off. Il comando richiesto viene codificato conun numero intero: 1 per il riempimento del serbatoio, 2 per mantenere stabile il livello, 3 per lamiscelazione, 4 per lo svuotamento.
In questo caso, un metodo efficace per definire il programma di controllo puo essere basato sumeccanismi di selezione in grado di discriminare diversi casi possibili, come ad esempio il costruttoCASE .. OF nel linguaggio ST. Per migliorare ulteriormente la leggibilita del codice, prima dieffettuare il test sul comando richiesto, viene determinato lo stato del serbatoio, memorizzandolo inun variabile che puo assumere i soli valori Pieno, Non Pieno, Vuoto:
(* Definizione con enumerazione di un tipo di dato per memorizzare lostato della vasca *)
TYPE T_Serbatoio:(Pieno, Non_Pieno, Vuoto);END_TYPE;
VARComando:INT AT %IB0;Livello_Alto:BOOL AT %I1.0;Livello_Basso:BOOL AT %I1.1;
Apri/Chiudi_Valvola_Riempimento:BOOL AT %Q0.0;Apri/Chiudi_Valvola_Scarico:BOOL AT %Q0.1;Motore_Agitatore:BOOL AT %Q0.2;
Stato_Serbatoio:T_Serbatoio; (* Variabile interna *)END_VAR
(* Verifica dello stato del serbatoio *)IF NOT(Livello_Basso) THEN Stato_Serbatoio := Vuoto;
ELSIF NOT(Livello_Alto) THEN Stato_Serbatoio := Non_Pieno;ELSE Stato_Serbatoio := Pieno;
END_IF;
(* Selezione del comando *)CASE Comando OF
1: (* Riempimento *)Apri/Chiudi_Valvola_Scarico := FALSE;Motore_Agitatore := FALSE;IF Stato_Serbatoio <> Pieno THEN
Apri/Chiudi_Valvola_Riempimento := TRUE;ELSE Apri/Chiudi_Valvola_Riempimento := FALSE;
END_IF;
2: (* Mantenimento *)Apri/Chiudi_Valvola_Scarico := FALSE;Apri/Chiudi_Valvola_Riempimento := FALSE;Motore_Agitatore := FALSE;
3: (* Miscelazione *)Apri/Chiudi_Valvola_Scarico := FALSE;Apri/Chiudi_Valvola_Riempimento := FALSE;IF Stato_Serbatoio = Pieno THEN Motore_Agitatore := TRUE;
13
ELSE Motore_Agitatore := FALSE;END_IF;
4: (* Svuotamento *)Apri/Chiudi_Valvola_Riempimento := FALSE;Motore_Agitatore := FALSE;IF Stato_Serbatoio <> Vuota THEN
Apri/Chiudi_Valvola_Scarico := TRUE;ELSE Apri/Chiudi_Valvola_Scarico := FALSE;
END_IF;
END_CASE
La traduzione del costrutto di selezione multipla in un linguaggio differente dal ST, richiederebbeuna notevole quantita di salti condizionati dal risultato di operazioni di confronto, per verificare ognicaso possibile del valore della variabile intera. Tuttavia, nell’esempio in esame, si puo notare come leistruzioni eseguite nei vari casi non richiedono altro che di abilitare o meno certe uscite booleane. Inparticolare, il comando di apertura della valvola di scarico va abilitato solamente nel caso 4, quellodella valvola di riempimento nel caso 1 e cosı via. Pertanto, una soluzione piu efficiente potrebbeessere quella di memorizzare in variabili booleane interne del controllore il risultato dei confrontisulla variabile intera Comando, condizionando poi con queste il valore dell’uscita logica interessata.Ad esempio, una realizzazione delle funzionalita richiesta con il linguaggio LD potrebbe essere:
VAR...Comando1, Comando2, Comando3, Comando4:BOOL; (* Variabili interne *)
...END_VAR
(* Verifica del comando richiesto *)
| +------+ Comando1 |+------------+EN +-------( )----+| | | || Comando --+ EQ |
| |1 --+ |
+------+
| Comando1 +------+ Comando2 |+-----|/|------------+EN +-------( )----+| | | || Comando --+ EQ |
| |2 --+ |
+------+
| Comando1 Comando2 +------+ Comando3 |+-----|/|--------|/|------------+EN +-------( )----+| | | || Comando --+ EQ |
| |3 --+ |
+------+
14
| Comando1 Comando2 Comando3 +------+ Comando4 |+-----|/|-------|/|--------|/|---------+EN +-------( )----+| | | || Comando --+ EQ |
| |4 --+ |
+------+
(* Attuazione delle uscite in base al comando impostato *)
| Comando1 Livello_Alto Apri/Chiudi_Valvola_Riempimento |+----| |----------|/|-----------------------( )----------------+| |
| Comando4 Livello_Basso Apri/Chiudi_Valvola_Scarico |+----| |----------|/|-----------------------( )----------------+| |
| Comando3 Livello_Alto Motore_Agitatore |+----| |----------| |-----------------------( )----------------+| |
Si noti la semplificazione sulla controllo dello stato del serbatoio, limitata alla valutazione deicontatti di livello basso o alto, e l’inibizione delle operazioni di confronto successive a quella che diaun eventuale risultato positivo (che permette una riduzione del tempo di esecuzione del programma).
La realizzazione in linguaggio IL e FBD e lasciata come esercizio allo studente.
1.6 Operazioni con temporizzatori
Gran parte delle operazioni compiute da dispositivi come i PLC durante l’attivita di controllo esupervisione di impianti automatizzati richiedono istruzioni che permettano di verificare se siano omeno trascorsi determinati intervalli di tempo, dette istruzioni di temporizzazione o tempo-rizzatori (timers). Ad esempio, il ciclo operativo di una macchina automatica puo richiedere chetra due fasi successive vi sia un certo ritardo, oppure l’esecuzione di una di queste fasi deve esserecompletata entro un certo tempo limite, pena il malfunzionamento dell’impianto.
Si supponga di voler comandare l’apertura e chiusura di una valvola che regola il passaggio difluidi, verificando che tali operazioni siano completate entro un certo tempo limite. Se la posizionedella valvola non raggiunge il fine corsa richiesto (completamente aperta o completamente chiusa)prima di questo tempo, occorre generare una condizione di errore. Poiche tale funzionalita di controlloha spiccate caratteristiche di generalita e ripetibilita, si puo pensare di incapsularla in un FunctionBlock:
FUNCTION_BLOCK Valvola_Timeout
VAR_INPUTRichiesta_Apertura:BOOL;Richiesta_Chiusura:BOOL;FineCorsa_Aperta:BOOL;FineCorsa_Chiusa:BOOL;Reset_Errore:BOOL;Tempo_Limite:TIME;
END_VAR
15
VAR_OUTPUTComando_Apertura:BOOL;Comando_Chiusura:BOOL;Errore:BOOL;
END_VAR
VARTimer_Controllo:TON;
END_VAR
(* Attivazione e Disattivazione comando apertura *)
| Richiesta_Apertura Comando_Chiusura Comando_Apertura |+----------| |----------------|/|------------------(S)------+| |
| Comando_Apertura FineCorsa_Aperta Comando_Apertura |+---------| |----------------| |---------+-----------(R)----+| | || Errore |+---------| |----------------------------+|
(* Attivazione e Disattivazione comando chiusura *)
| Richiesta_Chiusura Comando_Apertura Comando_Chiusura |+----------| |----------------|/|------------------(S)------+| |
| Comando_Chiusura FineCorsa_Chiusa Comando_Chiusura |+---------| |----------------| |---------+-----------(R)----+| | || Errore |+---------| |----------------------------+|
(* Controllo sul timeout *) Timer_Controllo+-----------+
| Comando_Apertura FineCorsa_Aperta | TON |+-------| |---------------|/|------------+----+IN | Errore || | | Q+---(S)---+| Comando_Chiusura FineCorsa_Chiusa | | | |+-------| |---------------|/|------------+ | || | ET+--
Tempo_Limite ---+PT || |+-----------+
(* Richiesta di reset delle condizione di errore *)
16
| Reset_Errore Errore |+--------|P|----------------------------------(R)----+| |
END_FUNCTION_BLOCK
Per realizzare in modo analogo l’algoritmo del Function Block in linguaggio IL, occorre considerarenuovamente la necessita di rilevare fronti di salita di segnali, introducendo tre instanze del FunctionBlock Standard R TRIG, per le richieste di apertura e chiusura e per il reset dell’errore. Si noti inoltrel’utilizzo dell’istruzione CAL nella chiamata del blocco temporizzatore:
FUNCTION_BLOCK Valvola_Timeout
VAR_INPUT...VAR_OUTPUT...VAR...
Fronte_Reset_Err:R_TRIG;END_VAR
(* Attivazione e Disattivazione comando apertura *)
LD Richiesta_AperturaANDN Comando_ChiusuraS Comando_Apertura
LD Comando_AperturaAND FineCorsa_ApertaOR ErroreR Comando_Apertura
(* Attivazione e Disattivazione comando chiusura *)
LD Richiesta_ChiusuraANDN Comando_AperturaS Comando_Chiusura
LD Comando_ChiusuraAND FineCorsa_ChiusaOR ErroreR Comando_Chiusura
(* Controllo sul timeout *)
LD Comando_AperturaANDN FineCorsa_ApertaOR( Comando_ChiusuraANDN FineCorsa_Chiusa)ST Timer_Controllo.INLD Tempo_Limite
17
ST Timer_Controllo.PT
(* Dopo aver assegnato i parametri del timer, effettuo la chiamata *)
CAL Timer_Controllo
LD Timer_Controllo.QS Errore
LD Reset_ErroreCLK Fronte_Reset_ErrLD Fronte_Reset_Err.QR Errore
END_FUNCTION_BLOCK
Un altro esempio di uso di temporizzatori, non impiegati per scopi diagnostici, ma per controllarel’evoluzione stessa del ciclo operativo, e rappresentato dal tempratore ad induzione analizzato nelseguito.
+
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
FC Pistone Alto
FC Pistone Basso
Spruzzatore
Spira
Pezzo
Valvola salita pistone
Figura 1.4: Dispositivo per la tempra ad induzione di pezzi metallici
Il processo di tempra ad induzione richiede che un pezzo metallico sia posto in prossimita di uncircuito elettrico induttore, ottenendo cosı il riscaldamento ad elevatissima temperatura del pezzo,il quale viene poi raffreddato velocemente per mezzo di uno spruzzo di acqua. Nel sistema in esame,schematizzato in Figura 1.4, il pezzo viene avvicinato alla spira sollevandolo con uno spintore pneu-matico attivato con un singolo comando logico (1 = alza, 0 abbassa). Le fasi di riscaldamento e diraffreddamento del ciclo di lavoro devono avere una durata prestabilita, verificata tramite opportunitemporizzatori. La realizzazione del programma di controllo in linguaggio LD e la seguente:
VAR
Start_Ciclo:BOOL AT %I0.0;Emergenza:BOOL AT %I0.1Pezzo_Presente:BOOL AT %I0.3;FC_Pistone_Alto:BOOL AT %I0.4;FC_Pistone_Basso:BOOL AT %I0.5;
Salita_Pistone:BOOL AT %Q0.0;Riscaldamento_Pezzo:BOOL AT %Q0.1;Spruzzo_Acqua:BOOL AT %Q0.2;
18
Timer_Risc, Timer_Raff:TON;
END_VAR
(* Abilitazione del comando salita pistone *)
| Start_Ciclo FC_Pistone_Basso Pezzo_Presente Salita_Pistone |+------| |-------------| |---------------| |--------------(S)-----+| |
(* Disabilitazione del comando salita pistone => fine ciclo *)
| Timer_Raffr.Q Salita_Pistone |+------| |----------+----------(R)-------+| | || Emergenza |+------| |----------+
(* Pistone alto => partenza conteggio tempo di riscaldamento *)
Timer_Risc| Salita_Pistone FC_Pistone_Alto +------------++-------| |-------------| |----------+ IN Q+-| | TON || 20s ----+ PT ET+-
+------------+
(* Riscaldamento fino al termine del tempo conteggiato *)
| Salita_Pistone FC_Pistone_Alto Timer_Risc.Q Riscaldamento_Pezzo+--------| |------------| |-------------|/|----------------( )-------+|
(* Terminato il riscaldamento, conteggio del tempo di raffreddamento *)
Timer_Raffr| Timer_Risc +------------++------| |--------------------------+ IN Q+--| | TON |
10s ----+ PT ET+--+------------+
(* Attivazione spruzzatore fino al termine del tempo richiesto *)
| Timer_Risc Timer_Raffr Spruzzo_Acqua |+------| |----------|/|------------( )--------+| |
La realizzazione dei due esempi negli altri linguaggi non presentati e lasciata come esercizio allo
19
studente.
1.7 Operazioni di conteggio
Oltre ai temporizzatori, anche i blocchi funzionali di conteggio eventi, o contatori, sono moltoimportanti nel controllo logico e di supervisione di macchine automatiche. Tali istruzioni permettonodi tenere traccia del numero di occorrenze del fronte di salita o di discesa di una certa informazionelogica. Il sistema di controllo dovra poi valutare le operazioni da effettuare una volta raggiunto undeterminato numero di queste occorrenze, in modo analogo a quanto analizzato in precedenza peri temporizzatori. Vale a dire che raggiungere un certo valore di conteggio dell’evento di timeoutdi apertura di un valvola, rilevato come descritto nel paragrafo precedente, puo essere indice dellanecessita di sostituire l’azionamento, condizione che impedisce il ripristino della produzione. Oppure,il conteggio di un certo numero di prodotti su di un nastro trasportatore puo essere necessario perattivare il sistema di confezionamento dei prodotti.
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Fotocellula passaggio prodotto
Nastro1
Nastro2
Fine Passo Nastro2
Figura 1.5: Linea di movimentazione e raggruppamento prodotti
Si consideri ad esempio, il sistema automatizzato rappresentato in Figura 1.5, costituito da duenastri trasportatori in cascata, il primo dei quali movimenta in modo continuo dei prodotti che sipresentano con frequenza casuale, mentre il secondo serve per raggruppare i prodotti in un numeroadatto a riempire una confezione di cartone. Il secondo nastro viene attivato, con un movimento “apassi”, solamente quando il primo vi abbia trasferito tale quantita di prodotti, ed arrestato quandotutti questi prodotti siano stati trasferiti al sistema di confezionamento, condizione rilevata da unsensore di “fine-passo”. Durante il periodo di attivita del nastro a valle, quello a monte vienearrestato. Il passaggio di prodotti tra i due nastri viene rilevato da una fotocellula (sensore logico).
Il programma di controllo del movimento dei due nastri, potrebbe essere realizzato in linguaggioLD come segue:
VARStart_Linea:BOOL AT %I0.0;Stop_Linea:BOOL AT %I0.1;Passaggio_Prodotto:BOOL AT %I0.2;FinePasso_Nastro2:BOOL AT %I0.3;
Motore_Nastro1:BOOL AT %Q0.0;Motore_Nastro2:BOOL AT %Q0.1;
Attiva_Passo:BOOL; (* Variabile interna *)Conteggio_Prod:CTU;
END_VAR
20
(* Verifica delle condizioni di produzione con autoritenuta *)
| Start_Linea Stop_Linea Produzione |+------| |-------+-----|/|------------( )-----+| | || Produzione |+------| |-------+|
(* Conteggio dei prodotti trasferiti tra i due nastri *)
Conteggio_Prod+--------------+
| Produzione Passaggio_Prodotto | CTU |+------| |-------------| |-------------->CU || | Q+--| 5 ---+PV || Attiva_Passo | |+-------| |-----------------------------+R CV+--| | || +--------------+
(* Abilitazione e disabilitazione del movimento del nastro a passi *)
| Conteggio_Prod.Q Produzione Attiva_Passo |+--------| |-------------| |---------------(S)-------+| |
| Attiva_Passo FinePasso_Nastro2 Attiva_Passo |+--------| |-------------|P|---------------(R)-------+| |
(* Attivazione delle uscite di comando per i motori dei nastri *)
| Produzione Attiva_Passo Motore_Nastro1 |+--------| |--------------|/|--------------( )-------+| |
| Produzione Attiva_Passo Motore_Nastro2 |+--------| |--------------| |--------------( )-------+| |
Anche in questo caso, l’implementazione della funzionalita con gli altri linguaggi IEC 61131-3puo essere svolta come esercizio dallo studente.
21
Capitolo 2
Descrizione di sequenze operativecon SFC IEC 61131-3
2.1 Introduzione
Tra gli elementi comuni dello Standard IEC 61131-3 si trova anche la descrizione sintattica delformalismo chiamato Sequential Function Chart, il quale riveste un ruolo molto importante tra iconcetti introdotti nel documento IEC. Infatti, tale formalismo rappresenta prima di tutto un metododi modellazione del funzionamento richiesto al sistema automatizzato, in grado di fornire una specificaformale per la realizzazione del software di controllo esente da possibili errori di interpretazione.
In seconda analisi, esso rappresenta anche un metodo per organizzare il software scomponendo leistruzioni da eseguire in base alle sequenze operative che il sistema controllato deve compiere. Infine,essendo sempre piu numerosi gli Ambienti di Programmazione commerciali che supportano questoformalismo come un vero e proprio linguaggio di programmazione, esso rappresenta anche un modoper realizzare il programma di controllo in grado di rispecchiare fedelmente il risultato della faseiniziale di analisi, descrizione e modellazione del progetto.
Negli esempi che seguono, vedremo infatti come un diagramma SFC sia in grado di fornire unadescrizione dettagliata e non ambigua delle specifiche di funzionamento di un automatismo, dal puntodi vista del progettista del sistema di controllo logico.
2.2 Sistema di movimentazione con piattaforma rotante.
Si consideri la linea di nastri schematizzata in Figura 2.1, composta da due nastri trasportatori,disposti ad “L”, e da una piattaforma rotante dotata anch’essa di nastro trasportatore, necessariaper realizzare la continuita di trasporto prodotti dal nastro 1 al nastro 2.
La linea di trasporto deve funzionare nel seguente modo: il nastro 1 viene azionato fintanto cheun prodotto non arrivi al termine rilevato dalla fotocellula FC Nastro1. Se la piattaforma rotante eposizionata in modo tale che il suo nastro sia in linea con il nastro 1, questi ultimi possono essereazionati entrambi per permettere il trasferimento del prodotto tra i due, finche il prodotto nonviene piu rilevato dalla fotocellula sul nastro 1. A questo punto, occorre ruotare la piattaforma indirezione anti-oraria, fermando il suo nastro (il nastro 1 puo continuare a muoversi per far avanzareun prodotto successivo), in modo da porla in asse con il nastro 2. Quando cio avviene, vengonoazionati il nastro della piattaforma ed il nastro 2: il primo fino al rilevamento del prodotto da partedella fotocellula FC InNastro2, il secondo fino al rilevamento del prodotto da parte della fotocellulaFC OutNastro2. Il prodotto sara poi rimosso anche da quest’ultima posizione da un altro dispositivonon considerato. Quando il prodotto non occupa piu la piattaforma rotante, questa deve riportarsiin asse con il nastro 1 con ad una rotazione oraria, posizione che rappresenta anche quella inizialedel dispositivo.
Una descrizione con il formalismo SFC del programma di controllo puo essere realizzata in mo-do molto efficace scomponendo l’automatismo in moduli funzionali (nastro 1, piattaforma, nastro
22
Mov_Nastro1
Mov_Nastro2
Rot_OrariaRot_AntiOr
FC_Nastro1
FC_InNastro2
FC_OutNastro2
Figura 2.1: Linea di trasporto con nastri ad L
2) indipendenti, opportunamente sincronizzati grazie alle variabili booleane di attivazione di cias-cuno stato, definite nella sintassi del SFC dallo Standard IEC 61131-3 come elementi impliciti diprogramma.
VAR
(* Input del controllore *)
FC_Nastro1:BOOL;FC_InNastro2:BOOL;FC_OutNastro2:BOOL;Fine_Rot_AntiOr:BOOL; (* sensore che rileva il posizionamento in
asse con il nastro 2 da parte dellapiattaforma *)
Fine_Rot_Oraria:BOOL; (* sensore che rileva il posizionamento inasse con il nastro 1 da parte dellapiattaforma *)
(* Output del controllore *)
Mov_Nastro1:BOOL;Mov_Nastro2:BOOL;Mov_NastroPiatt:BOOL;Rot_Oraria:BOOL;Rot_AntiOr:BOOL;
END_VAR
23
S10
S11
S12
Mov_Nastro1
Mov_Nastro1
FC_Nastro1
S31.X
NOT FC_Nastro1
S20
S21
S22
Mov_Nastro2
S33.X
FC_OutNastro2
S30
S31
S32
Mov_NastroPiatt
Rot_AntiOr
S11.X
NOT FC_Nastro1
Fine_Rot_AntiOr
S34 Mov_NastroPiatt
FC_InNastro2
S33
S21.X
S35 Rot_Oraria
Fine_Rot_Oraria
NOT FC_OutNastro2
24
2.3 Piattaforma rotante con selezione direzione.
Si consideri il sistema rappresentato in Figura 2.2, composto da un nastro trasportatore, unapiattaforma rotante, due stazioni di foratura ed un nastro di scarico.
Il dispositivo di controllo deve essere in grado di gestire la selezione della stazione di foraturacon la quale lavorare il pezzo, in base alle dimensioni del pezzo stesso. A tale scopo, sul nastro diingresso e posizionata una fotocellula che permette di rilevare la lunghezza del prodotto in base altempo che esso impiega a transitare completamente oltre la fotocellula stessa. Se tale tempo risultaessere inferiore a 500 ms il pezzo dovra essere lavorato dalla stazione di foratura destra, altrimentida quella di sinistra. Il nastro prosegue la movimentazione del pezzo, solamente se la piattaforma ein uno stato ideneo (cioe un pezzo precedentemente ricevuto e stato espulso), ed e possibile valutarele dimensioni di un nuovo pezzo dopo che quello in esame e stato trasferito completamente sullapiattaforma (segnale FC Piattaforma attivo). Si suppone che i pezzi sul nastro di ingresso sianosufficientemente distanziati.
Per posizionare opportunamente la piattaforma, occorre azionare il motore di rotazione con unodei comandi ROT DX o ROT SX, fino al rilevamento di un fronte di salita del sensore di prossimitaFC Rotazione, che rileva una delle quattro tacche metalliche montate sulla piattaforma, in modoche essa effettui un quarto di giro. Terminata la lavorazione, una nuova rotazione di un quarto di gironella stessa direzione permettera di spingere il pezzo sul nastro di scarico, azionando per almeno 800ms il segnale di avanzamento dell’espulsore Espulsione (lo spintore ritorna in posizione di riposoper effetto di una molla se il segnale di comando non e attivato).
NASTRO A NASTRO B
FC_NASTRO
FC_PIATTAFORMA Stazione di Foratura sinistra
Stazione di Foratura destra
Espulsore pezzo
ROT_SX
ROT_DX
FC_Rotazione
Figura 2.2: Piattaforma rotante con stazioni di foratura
Trascurando per semplicita il controllo delle stazioni di lavorazione e del nastro di scarico, undiagramma SFC modulare per il controllo indipendente dei due moduli considerati (nastro A epiattaforma) e il seguente:
VAR
(* Input del controllore *)
FC_Nastro:BOOL;FC_Piattaforma:BOOL;FC_Rotazione:BOOL;Termine_Foratura_DX:BOOL; (* Segnale dal sottosistema di foratura
della stazione di destra che indica ilcompletamento della lavorazione *)
25
Termine_Foratura_SX:BOOL; (* Segnale dalla stazione di sinistra *)
(* Output del controllore *)
Mov_NastroA:BOOL;ROT_DX:BOOL;ROT_SX:BOOL;Espulsione:BOOL;
END_VAR
S10
S11
S12
Mov_NastroA
FC_Nastro
NOT FC_NastroS11.T > 500 msAND FC_Nastro
S13
S14 Mov_NastroA
FC_Piattaforma
S21.X S27.X
Figura 2.3: SFC del nastro trasportatore con selezione dimensione prodotto
Si noti, nella soluzione proposta, come il fronte di salita da parte del segnale FC Rotazione siarilevato dall’evoluzione di due passi consecutivi condizionata da un segnale prima falso e poi veroda parte di tale sensore. Una soluzione alternativa poteva essere rappresentata dall’utilizzo di unFunction Block R TRIG, chiamato in una azione del passo opportuno, la cui uscita Q fosse la condizionedi transizione del passo stesso. Si noti inoltre, come sia possibile che il SFC di controllo del nastrorilevi la dimensione di un pezzo e si ponga in attesa, mentre il SFC di controllo della piattaforma staancora elaborando un pezzo precedente. Al termine delle operazioni su quest’ultimo, il nastro sarariattivato e verra selezionata la corretta sequenza di lavorazione del pezzo.
26
S20
S21
S13.XS12.X
S27
S22
FC_Piattaforma
S28
FC_Piattaforma
ROT_SX ROT_DX
NOT FC_Rotazione
S23 ROT_SX
FC_Rotazione
S25 ROT_SX
Termine_Foratura_SX
S26 ROT_SX
NOT FC_Rotazione
S29 ROT_DX
FC_Rotazione
S31 ROT_DX
Termine_Foratura_DX
S32 ROT_DX
NOT FC_Rotazione
S24 S30
FC_Rotazione FC_Rotazione
S33 Espulsione
NOT FC_Rotazione
S33.T > 800 ms
Figura 2.4: SFC della piattaforma rotante con selezione direzione
2.4 Controllo di un distributore di bibite.
Si consideri una macchina distributrice di bibite che sia in grado di riconoscere monete da 0.1, 0.2 e0.5 Euro e di erogare tre differenti tipi di bibita, A, B e C. La bibita A costa 0.6 Euro, la bibita B necosta 0.8 e la bibita C costa 1 Euro. La macchina e dotata di display, sul quale viene visualizzata lastringa “Inserire Monete” fino a quando il cliente non inserisce una prima moneta, dopodiche vienevisualizzato l’importo totale inserito. L’utente ha a disposizione i pulsanti di selezione di ciascunabibita e un pulsante di espulsione monete, con il quale puo annullare l’operazione. La macchinainfatti non da resto!
Il riconoscimento della moneta viene effettuato da un sottosistema di scansione, il quale fornisceal sistema di controllo principale quattro soli segnali logici: Moneta 01, Moneta 02, Moneta 05,Non Valida. Ad ogni nuova moneta riconosciuta viene aggiornata la somma memorizzata e la mon-eta viene messa in uno scompartimento di pre-incasso, mentre se la moneta non e valida vieneimmediatamente espulsa. Se l’utente preme un tasto di selezione bibita e l’importo introdotto esufficiente, la bibita richiesta viene espulsa e le monete vengono incassate definitivamente.
La durata minima di apertura degli sportelli di contenimento bibite e monete della macchina e:
• 300 ms per lo sportello dello scomparto dell’ultima moneta inserita.
• 1 s per lo sportello dello scomparto di pre-cassa.
• 2 s per lo sportello degli scomparti contenenti le bibite.
27
Uno schema SFC in grado di descrivere il funzionamento del dispositivo di controllo potrebbeessere il seguente (si noti che l’importo inserito viene mantenuto in una variabile intera):
VAR
(* Input del controllore *)
Passaggio_Moneta:BOOL; (* Fotocellula d’ingresso delle monete *)
Richiesta_A:BOOL; (* pulsanti utente *)Richiesta_B:BOOL;Richiesta_C:BOOL;Richiesta_Annulla:BOOL;
Moneta_01:BOOL; (* Segnali ricevuti dal sottosistema di controlloMoneta_02:BOOL; monete *)Moneta_05:BOOL;Non_Valida:BOOL;
(* Output del controllore *)
PreCassa_Ultima:BOOL; (* Gestione monete *)Espulsione_Ultima:BOOL;Acquisizione_PreCassa:BOOL;Espulsione_PreCassa:BOOL;Espulsione_A:BOOL; (* Gestione bibite *)Espulsione_B:BOOL;Espulsione_C:BOOL;
Attiva_Controllo:BOOL; (* Segnale di attivazione sottosistemadi controllo monete *)
Importo:INT; (* Somma del valore delle monete riconosciute *)
END_VAR
28
Attiva_Controllo
S20
Passaggio_Moneta
Importo:=
Importo+1
Espulsione_Ultima
S22
S23
S24
S25
Moneta_01
Moneta_02
Moneta_05
Non_Valida
S22.T
>300msAND
(S10ORS11)
S21
PIm
porto:=
Importo+2
PIm
porto:=
Importo+5
P
S25.T
>300ms
PreCassa_Ultima
PreCassa_Ultima
PreCassa_Ultima
S23.T
>300msAND
(S10ORS11)
S24.T
>300msAND
(S10ORS11)
Figura 2.5: SFC per l’aggiornamento dell’importo inserito
29
Importo:=0
S10
S22.X
ORS23.X
ORS24.X
Importo
<6
Importo>=6
Importo
<8
Importo>=8
Importo<10
Importo>=10
Espulsione_PreCassa
Espulsione_C
Richiesta_A
Richiesta_B
Richiesta_C
Richiesta_Annulla
S11
S12
S13
S14
S15
S16
S17
S18
S11
S11
S15.T
>1s
Display("Inserire
Monete")
Display(Importo)
Acquisizione_PreCassa
Espulsione_A
Acquisizione_PreCassa
Espulsione_B
Acquisizione_PreCassa
S18.T
>2s
S17.T
>2s
S16.T
>2s
P
Figura 2.6: SFC di controllo dell’espulsione bibite e monete
30
2.5 Carroponte con elettromagnete.
Si consideri il sistema di movimentazione magazzino rappresentato schematicamente in Figura 2.7,costituito da un carrello sopraelevato in grado di sollevare o abbassare un elettromagnete. Il ciclo dimovimentazione che si desidera realizzare, prevede che il carroponte trasferisca uno per volta i pezzimetallici contenuti nel contenitore in basso a sinistra nella figura, in quello in alto a destra.
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
FC_DxPos_SicuraFC_Sx
Altezza_Scarico
Altezza_Carico
Altezza_Max
Figura 2.7: Carroponte con elettromagnete
Il carrello e supposto essere inizialmente nella posizione orizzontale indicata dal sensore di finecorsa FC Sx e con il magnete completamente sollevato. Pertanto, occorre innanzitutto, alla richiestadi inizio del ciclo, prelevare un pezzo abbassando il magnete ad Altezza Carico ed in seguito atti-vandone l’alimentazione. Si supponga che un tempo di attesa di 2 secondi dall’istante di attivazionedel magnete sia sufficiente per garantire la presa di un pezzo.
Per trasferire il pezzo, occorre effettuare il movimento di sollevamento e spostamento orizzontaleverso destra, in modo simultaneo per ottimizzare il tempo di ciclo, avendo cura di impedire che ilcarrello possa proseguire oltre la posizione indicata dal sensore Pos Sicura se l’elettromagnete nonha raggiunto la posizione Altezza Max, al fine di evitare possibili collisioni del pezzo con il pianorialzato.
Terminato il movimento orizzontale, il ciclo puo terminare abbassando il magnete ad Altezza Scarico,disattivandone l’alimentazione, e riportando il carrello nella posizione iniziale con l’elettromagnetecompletamente sollevato. Anche per il rilascio del pezzo, si richiede un tempo di attesa di 2 secondi,prima di effettuare ulteriori movimenti.
Tale sequenza operativa puo essere descritta con il seguente diagramma SFC:
VAR(* Input del controllore *)Altezza_Max:BOOL;Altezza_Carico:BOOL;Altezza_Scarico:BOOL;
FC_Dx:BOOL;FC_Dx:BOOL;Pos_Sicura:BOOL;
(* Output del controllore *)Abbassa_Magnete:BOOL;Solleva_Magnete:BOOL;
31
Attiva_Magnete:BOOL;
Motore_Carrello:BOOL; (* Segnale di attivazione del motore *)
Dir_Carrello_Dx:BOOL; (* Segnali di selezione della direzioneDir_Carrello_Sx:BOOL; di movimento del carrello *)
END_VAR
S10
S11
S12
Abbassa_Magnete
Attiva_Magnete
Start_Ciclo
Altezza_Carico
S
S12.T > 2 s
S13 Solleva_Magnete S14
Motore_Carrello
Dir_Carrello_Dx
Pos_SicuraAltezza_Max
S15 S16
True
S17
Motore_Carrello
Dir_Carrello_Dx
FC_Dx
S18 Abbassa_Magnete
Altezza_Scarico
S19 Attiva_MagneteR
S19.T > 2 s
FC_Sx
S20 Solleva_Magnete S21
Motore_Carrello
Dir_Carrello_Sx
Altezza_Max
S22 S23
True
32
2.6 Impilatore prodotti con spintore
Si consideri il sistema automatizzato indicato schematicamente in Figura 2.8 preposto allo stoccaggiodi prodotti in un deposito.
aaa aaa aaa aaa aaa
FC_SXFC_DX
MOTORE_NASTROFC_PRODOTTO
MOV_BARRA_DX
MOV_BARRA_SX
SOLLEVA_BARRA
ABBASSA_BARRA
BARRA_ALTA
BARRA_BASSA
Vista frontale griglia impilatrice
GRIGLIA_PIENA
GRIGLIA_IN_FASEMOTORE_GRIGLIA aaaaaaaaaaaa
GRIGLIA_LIBERA
Figura 2.8: Impilatore prodotti con spintore
La macchina riceve i prodotti opportunamente distanziati da un nastro trasportatore con fun-zionamento continuo, i quali vanno ad inserirsi in nel ripiano inferiore di una griglia. Attivando larotazione del motore connesso alla griglia si ha la traslazione verso l’alto di tutti i ripiani con unconseguente sollevamento ed impilatura dei prodotti. Il motore deve essere attivato fino a quandoun ripiano della griglia non sia nuovamente in fase con il nastro, condizione rilevata dal sensore diprossimita Griglia in fase.
Quando una pila di prodotti sia stata completata, vale a dire quando il sensore Griglia pienarilevi la presenza di un prodotto, occorre attivare la barra di spinta che permette il trasferimentodella pila nel deposito di stoccaggio, traslandola lungo le guide in linea con la griglia di impilatura.Durante il movimento iniziale dello spintore, occorre che il nastro di ingresso prodotti e l’impila-tore siano assolutamente inattivi, mentre quando lo spintore ha raggiunto la posizione orizzontaleGriglia libera, il procedimento di impilatura puo riprendere. Completato il movimento di spintafino al fine corsa FC Dx, lo spintore deve tornare nella posizione iniziale. Tuttavia, al fine di impedireche nel movimento di rientro della barra di spinta vi sia una collisione con i nuovi prodotti impilatinella griglia durante il completamento del ciclo di stoccaggio precedente, la barra deve essere solleva-ta attivando il comando Solleva barra fino all’altezza Barra alta. Questo movimento puo essereeffettuato in modo ottimizzato, cioe contemporaneamente alla traslazione orizzontale verso sinis-tra, avendo pero cura che il sollevamento sia completato prima del raggiungimento della posizioneindicata dal sensore Griglia libera.
La descrizione tramite diagramma SFC del ciclo operativo dei moduli macchina “Impilatore” e“Spintore” puo essere effettuata come segue:
VAR
(* Input del controllore *)
FC_Prodotto:BOOL;Griglia_In_Linea:BOOL;Griglia_Piena:BOOL;Barra_Alta:BOOL;Barra_Bassa:BOOL;FC_Sx:BOOL;
33
Griglia_Libera:BOOL;FC_Dx:BOOL;
(* Output del controllore *)
Motore_Nastro:BOOL;Motore_Griglia:BOOL;Mov_Barra_Sx:BOOL;Mov_Barra_Dx:BOOL;Solleva_Barra:BOOL;Abbassa_Barra:BOOL;
END_VAR
S1
S2
S3
FC_Prodotto
Griglia_In_LineaAND NOT Griglia_Piena
S4
Motore_Griglia
Motore_NastroS
Motore_Griglia
NOT Griglia_In_Linea
Griglia_In_LineaAND Griglia_Piena
S12.X
Motore_NastroR
Figura 2.9: Diagramma SFC per il controllo del modulo impilatore con nastro
34
S10
S11
S12
S4.X
Griglia_Libera
FC_Dx
S13 Solleva_Barra S14 Mov_Barra_Sx
Griglia_LiberaBarra_Alta
S15 S16
True
S17
FC_Sx
S18 Abbassa_Barra
Barra_Bassa
Mov_Barra_Dx
Mov_Barra_Dx
Mov_Barra_Sx
Figura 2.10: Diagramma SFC per il controllo dello spintore
35
2.7 Carrelli ferroviari con binario condiviso
Si consideri il sistema di trasporto rappresentato schematicamente in Figura 2.11, costituito da duedifferenti carrelli su rotaia automatizzati A e B, ciascuno dei quali deve trasferire del materiale dallapropria stazione di carico alla stazione di scarico. I carrelli vengono attivati dal relativo pulsante diinizio ciclo e percorrono un tratto di binario separato fino ad una determinata posizione di controllo,oltre la quale possono proseguire solamente se il tratto di binario centrale non e attualmente occupatodall’altro carrello. Se il carrello e abilitato a proseguire, terminera il proprio ciclo arrivando allapostazione di scarico, attendendo due minuti o la pressione di un pulsante di “recupero carrello”ed attivandosi per il rientro. Anche durante il rientro, occorre verificare prima di proseguire oltrela posizione di controllo, se il tratto di binario condiviso non sia occupato dall’altro carrello. Lapresenza dei carrelli nelle posizioni di carico, scarico e di controllo viene rilevata da sensori logiciopportunamente collocati.
AA
BB
Zona di Carico B
Zona di Carico A
Punto di attesa
andata
Punto di attesa
ritorno
Zona condivisa
Zona di Scarico A
Zona di Scarico B
Figura 2.11: Carrelli su rotaia con binario condiviso
Per evitare collisioni sul tratto di binario condiviso, una possibile soluzione e rappresentata dal-l’introduzione nel diagramma di un passo che rappresenta la condizione del binario centrale: se ilpasso e attivo, significa che il carrello che arrivi per primo alla posizione di controllo e abilitato aproseguire, se invece e disattivo significa che il binario e occupato. La gestione dell’attivazione edisattivazione di questo passo richiede una connessione tramite divergenze e convergenze parallelecon i diagrammi sequenziali di ciascuno dei due carrelli, ottenendo quindi il diagramma SFC globaledescritto nel seguito. Si noti che il passo S100 rappresenta appunto lo stato del tratto di binariocondiviso. Tale passo deve essere attivo affinche l’SFC del carrello A (a sinistra) o del carrello B (adestra) possano evolvere oltre i passi S13, S17, S23 o S27, secondo le regole delle convergenze simul-tanee. L’evoluzione del diagramma porta alla disattivazione del passo S100 e, a seconda dei casi, diuno dei passi precedentemente nominati, ed all’attivazione di uno fra i passi S14, S18, S24 o S28.Questi passi rappresentano una situazione nella quale uno dei due carrelli sta transitando, duranteil movimento di andata o di ritorno, sul binario condiviso, situazione che termina al passaggio delcarrello per la posizione di controllo opportuna. Si noti inoltre che in caso di arrivo contemporaneodei due carrelli in una posizione di controllo per l’avanzamento sul binario centrale, viene data laprecedenza sempre al carrello A.
VAR
(* Input del controllore *)
Start_A:BOOL;Start_B:BOOL;Recupero_A:BOOL;Recupero_B:BOOL;Scarico_A_OK:BOOL;Scarico_B_OK:BOOL;
36
Pos_A_Carico:BOOL;Pos_B_Carico:BOOL;Pos_A_Controllo_Andata:BOOL;Pos_B_Controllo_Andata:BOOL;Pos_A_Controllo_Rientro:BOOL;Pos_B_Controllo_Rientro:BOOL;Pos_A_Scarico:BOOL;Pos_B_Scarico:BOOL;
(* Output del controllore *)
Motore_A_Avanti:BOOL;Motore_A_Indietro:BOOL;Motore_B_Avanti:BOOL;Motore_B_Indietro:BOOL;
END_VAR
S10
S11
S12
Start_A
Pos_A_Controllo_Andata
S13 Motore_A_Avanti
Pos_A_Controllo_Ritorno
Motore_A_Avanti
S14 Motore_A_Avanti
Pos_A_Scarico
S15
S15.T > 2 minOR Recupero_A
S16
S17
Pos_A_Controllo_Ritorno
Motore_A_Indietro
S18
Pos_A_Controllo_Andata
Motore_A_Indietro
S19 Motore_A_Avanti
Pos_A_Carico
S100
S20
S21
S22
Start_B
Pos_B_Controllo_Andata
S23 Motore_B_Avanti
Pos_B_Controllo_Ritorno
Motore_B_Avanti
S24 Motore_B_Avanti
Pos_B_Scarico
S25
S25.T > 2 minOR Recupero_B
S26
S27
Pos_B_Controllo_Ritorno
Motore_B_Indietro
S28
Pos_B_Controllo_Andata
Motore_B_Indietro
S29 Motore_B_Avanti
Pos_B_Carico
True
True
NOT S12.X AND NOT S17,X
NOT S12.X AND NOT S17,X
37
2.8 Sincronizzazione robot mobili con postazione comune
Si consideri la cella robotizzata rappresentata schematicamente in Figura 2.12, costituita da duesemplici robot A e B preposti rispettivamente al carico ed allo scarico di prodotti da una piattaformadi saldatura. Quest’ultima e costituita da una tavola rotante con due postazioni per il collocamentodei prodotti, una idonea al ricevimento o al prelievo di prodotti da parte dei robot, l’altra idoneaalle operazioni di saldatura da parte di un terzo robot non considerato.
Presenza__Rob_Sx
Presenza_Rob_Centro
Presenza_Rob_Dx
Tavola_In_Fase
Pres_Pezzo_Carico
Motore_A_Avanti
Motore_A_Indietro Motore_B_Avanti
Motore_B_Indietro
Pres_Pezzo_Scarico
Solleva_Pinza_A
Abbassa_Pinza_A
Chiudi_Pinza_A
Pinza_A_Alta
Pinza_A_Bassa
Figura 2.12: Cella robotizzata con robot mobili e tavola rotante
I robot devono prelevare i pezzi abbassando completamente la pinza e chiudendola attivando ilsegnale Chiudi Pinza (A o B), che deve essere mantenuto attivo per tutta la durata del trasportopezzo, muoversi verso la destinazione finale (la postazione centrale per il robot A, quella di scaricoper il robot B), quindi abbassare la pinza e disattivarne il comando di chiusura. Al termine di questeoperazioni, il robot puo risollevare la pinza e tornare alla propria posizione iniziale.
Si desidera controllare la sequenza di lavoro dei due robot mobili in modo tale da impedire possibilicollisioni sulla postazione centrale, quella al di sopra della piattaforma di saldatura, trascurandoinvece le operazioni di saldatura e rotazione della tavola al termine dei cicli di lavoro di ciascunrobot. Si suppone pertanto, per semplicita, che le condizioni iniziali della cella siano tali per cuiil robot A occupa la posizione indicata dal sensore Presenza Rob Sx (con la pinza in alto), mentreil robot B occupa la posizione indicata dal sensore Presenza Rob Centro (con la pinza in alto),e che l’avvio del ciclo dei robot sia condizionato solamente dal segnale Pres Pezzo Arrivo per ilrobot incaricato del caricamento, e dai segnali Pres Pezzo Scarico e Tavola In Fase per il robotincaricato del prelievo dei pezzi gia saldati.
Un possibile diagramma SFC che descriva il funzionamento della cella e quindi il seguente:
VAR
38
(* Input del controllore *)Pinza_A_Alta:BOOL;Pinza_A_Bassa:BOOL;Pinza_B_Alta:BOOL;Pinza_B_Bassa:BOOL;Pres_Pezzo_Carico:BOOL;Pres_Pezzo_Scarico:BOOL;Tavola_In_Fase:BOOL;Presenza_Rob_Sx:BOOL;Presenza_Rob_Centro:BOOL;Presenza_Rob_Dx:BOOL;
(* Output del controllore *)Motore_A_Avanti:BOOL;Motore_A_Indietro:BOOL;Abbassa_Pinza_A:BOOL;Solleva_Pinza_A:BOOL;Chiudi_Pinza_A:BOOL;Motore_B_Avanti:BOOL;Motore_B_Indietro:BOOL;Abbassa_Pinza_B:BOOL;Solleva_Pinza_B:BOOL;Chiudi_Pinza_B:BOOL;
END_VAR
39
S10
S11
S12
Pres_Pezzo_Carico
Pinza_A_Bassa
Motore_B_Avanti
Pos_Rob_Dx
Abbassa_Pinza_A
Chiudi_Pinza_ASSolleva_Pinza_A
S13
Pinza_A_Alta
True
S20
S21
S22
Pres_Pezzo_Scarico ANDTavola_In_Fase
Pinza_B_Bassa
Abbassa_Pinza_B
Chiudi_Pinza_BSSolleva_Pinza_B
S23
Pinza_B_Alta
S13
S25Chiudi_Pinza_BR
Solleva_Pinza_B
Pinza_B_Alta
S24
Pinza_B_Bassa
Abbassa_Pinza_B
S26
Motore_A_Avanti
Pos_Rob_Centro
S14
S15
S16
Pinza_A_Bassa
Abbassa_Pinza_A
Chiudi_Pinza_ARSolleva_Pinza_A
Pinza_A_Alta
Motore_A_Indietro
Pos_Rob_Sx
S17
S13
True
Motore_B_Indietro
Pos_Rob_Centro
S27
40
2.9 Movimentazione e capovolgimento prodotti
Si consideri il sistema di movimentazione magazzino raffigurato schematicamente in Figura 2.13, ilcui compito e quello di scomporre pile costituite da due prodotti, capovolgere i singoli prodotti, econseguentemente ricomporre la pila in modo tale che il prodotto precedentemente in cima si ritrovial di sotto e viceversa.
Nastro_A Nastro_B Nastro_C
Peso_A Peso_CPresenza_B
Pinza_A_alta
Pinza_A_media
Pinza_A_bassa
Pinza_C_alta
Pinza_C_media
Pinza_C_bassa
Solleva_Pinza_A
Abbassa_Pinza_A
Solleva_Pinza_C
Abbassa_Pinza_C
Solleva_Pinza_B
Abbassa_Pinza_B
Rot_Pinza_B
Pinza_B_AltaPinza_B_BassaNB: + Chiudi_Pinza_A(B,C)
Pinza_B_Stop_Rot
Figura 2.13: Sistema di movimentazione e capovolgimento prodotti
Per realizzare tale procedura, vengono adoperati tre nastri trasportatori e tre semplici robot ingrado di afferrare gli oggetti su ciascuno di questi nastri e sollevarli. Il primo robot (A), pertanto,e incaricato della scomposizione della pila, sollevando dapprima il prodotto in cima, attendendo latraslazione dell’altro prodotto dal nastro A al nastro B, e quindi riposizionando il prodotto affer-rato sul nastro. L’ultimo robot (C) ha invece il compito di ricomporre la pila, sollevando il primoprodotto (gia capovolto) che arriva sul nastro C, attendendo l’arrivo del secondo prodotto e quindiriposizionando il prodotto afferrato in precedenza, sulla cima della pila. Il robot B al centro, infine,ha il compito di sollevare ogni prodotto che si trovi sul nastro sottostante, capovolgerlo agendo sulmotore di rotazione della pinza e riposizionare il prodotto sul nastro.
Come si puo notare dal disegno schematico dell’impianto, il movimento verticale dei robot A eC puo essere arrestato in tre posizioni, che permettono il prelievo o il posizionamento di un oggettoche poggia sul nastro, che poggia su un altro prodotto, oppure il completo sollevamento della pinza(che afferri o meno il prodotto). Il robot B ha invece solamente due possibili posizioni (alta e idoneaper la rotazione; bassa e idonea al prelievo o posizionamento prodotto). Il segnale di comando dellachiusura della pinza va mantenuto abilitato per tutta la durata della presa di un oggetto, avendo curadi attendere almeno 500 ms dall’attivazione o dalla disattivazione di tale segnale prima di iniziarequalunque movimento.
Trascurando per semplicita la sequenza di movimentazione dei nastri, regolata in base a sensoridi peso o di presenza, che permettono di rilevare la quantita di prodotti che gravano sul nastro, eapplicando una modularizzazione funzionale dell’impianto, e possibile definire il ciclo operativo diciascun robot con un diagramma SFC indipendente, come descritto nel seguito, nel quale si supponeche i robot siano inizialmente in posizione alta e non vi siano prodotti sui nastri:
VAR
(* Input del controllore *)Pinza_A_Alta:BOOL;
41
Pinza_A_Media:BOOL;Pinza_A_Bassa:BOOL;
Pinza_B_Alta:BOOL;Pinza_B_Bassa:BOOL;Pinza_B_Stop_Rot:BOOL;
Pinza_C_Alta:BOOL;Pinza_C_Media:BOOL;Pinza_C_Bassa:BOOL;
(* Output del controllore *)Solleva_Pinza_A:BOOL;Abbassa_Pinza_A:BOOL;
Solleva_Pinza_B:BOOL;Abbassa_Pinza_B:BOOL;Rot_Pinza_B:BOOL;
Solleva_Pinza_C:BOOL;Abbassa_Pinza_C:BOOL;
(* Variabili di sincronizzazione, semplificate, da parte delprogramma di controllo dei nastri *)
Nastro_A_Pronto:BOOL;Nastro_B_Pronto:BOOL;Nastro_C_Pronto:BOOL;
END_VAR
42
S10
S11
Nastro_A_Pronto
S12
Abbassa_Pinza_A
S12.T > 500 ms
Pinza_A_Media
Chiudi_Pinza_AS
S13 Solleva_Pinza_A
Pinza_A_Alta
S14
Nastro_A_Pronto
S15 Abbassa_Pinza_A
Pinza_A_Bassa
S16
S16.T > 500 ms
Chiudi_Pinza_AR
S17 Solleva_Pinza_A
Pinza_A_Alta
S30
S31
Nastro_C_Pronto
S32
Abbassa_Pinza_C
S22.T > 500 ms
Pinza_C_Bassa
Chiudi_Pinza_CS
S33 Solleva_Pinza_C
Pinza_C_Alta
S34
Nastro_C_Pronto
S35 Abbassa_Pinza_C
Pinza_C_Media
S36
S36.T > 500 ms
Chiudi_Pinza_CR
S37 Solleva_Pinza_C
Pinza_C_Alta
S20
S21
Nastro_B_Pronto
S22
Abbassa_Pinza_B
S22.T > 500 ms
Pinza_B_Bassa
Chiudi_Pinza_BS
S23 Solleva_Pinza_B
Pinza_B_Alta
S24
S25 Abbassa_Pinza_B
Pinza_B_Bassa
S26
S26.T > 500 ms
Chiudi_Pinza_BR
S27 Solleva_Pinza_B
Pinza_B_Alta
Rot_Pinza_B
Pinza_B_Stop_Rot
Come si puo notare, il funzionamento di ciascun robot e sostanzialmente identico, in particolareper il robot A e C: ogni robot effettua un primo movimento di presa di un oggetto (abbassamen-to, chiusura pinza, sollevamento), si pone in attesa delle condizioni idonee al riposizionamento delprodotto sul nastro e quindi effettua un secondo movimento di rilascio (abbassamento, apertura pin-za, sollevamento). Cio che differisce e solamente la posizione raggiunta durante ciascun movimentoverso il basso. Nella realizzazione del programma, sara quindi una soluzione efficiente creare unFunction Block che contenga il controllo del generico robot, vale a dire che realizzi un SFC identicoai precedenti, ma con azioni e transizioni basate sui parametri di Input/Output del Function Block,anziche su specifici segnali del controllore.
Occorrera poi creare due istanze differenti di tale Function Block, ed assegnare opportunamentei parametri di Input/Output richiesti, come descritto nel seguito. Si noti che per “adattare” taleblocco funzionale al controllo del robot B, occorrerebbe modificare la transizione di uscita dal passoS14, ed aggiungere un parametro di Input e uno di Output, rispettivamente per ricevere il segnaledi fine rotazione e per attivare il comando di rotazione.
VAR....Robot_A: Robot_FB;Robot_C: Robot_FB;
END_VAR
43
S10
S11
Nastro_Pronto
S12
Abbassa_Pinza
S12.T > 500 ms
Posizione_Abbassamento_1
Chiudi_PinzaS
S13 Solleva_Pinza
Pinza_Alta
S14
Nastro_Pronto
S15 Abbassa_Pinza
Posizione_Abbassamento_2
S16
S16.T > 500 ms
Chiudi_PinzaR
S17 Solleva_Pinza
Pinza_Alta
Nastro_Pronto
Abbassa_Pinza
Posizione_Abbassamento_1
Chiudi_Pinza
Solleva_Pinza
Pinza_Alta
Posizione_Abbassamento_2
Robot_FB
Robot_A
Nastro_A_Pronto
Nastro_Pronto
Abbassa_Pinza
Posizione_Abbassamento_1
Chiudi_Pinza
Solleva_Pinza
Pinza_AltaPosizione_Abbassamento_2
Robot_FB
Robot_C
Pinza_A_Media
Pinza_A_Bassa
Pinza_A_Alta
Abbassa_Pinza_A
Chiudi_Pinza_A
Solleva_Pinza_A
Nastro_C_Pronto
Pinza_C_Bassa
Pinza_C_Media
Pinza_C_Alta
Abbassa_Pinza_C
Chiudi_Pinza_C
Solleva_Pinza_C
44
