Soluzione degli esercizi del Capitolo 7 - Ateneonline

Sistemi di automazione industriale - C. Bonivento, L. Gentili, A. Paoli 1 

Soluzione degli esercizi del Capitolo 7 

Soluzione dell’Esercizio E7.1 

Il sistema deve controllare il ciclo di carico e scarico dei carrelli A, B e C. Come 

si evince dal testo, i carrelli A e B condividono una parte del binario e pertanto il 

controllo del loro moto deve essere progettato in modo da evitare le collisioni tra 

i due. Nella seconda parte del percorso il carrello che impegna il binario (carrello 

A o B) lo condivide con il carrello C, quindi anche in questo caso la movimentazione 

deve essere controllata in modo da evitare collisioni. Queste considerazioni 

suggeriscono l’utilizzo di due strutture semaforiche per la mutua esclusione una 

innestata dentro l’altra. Come sarà maggiormente chiaro in seguito, la più esterna 

regolerà le precedenze tra i carrelli A e B, quella più interna regolerà il passaggio 

di uno tra i carrelli A o B e il carrello C. 

Le specifiche funzionali di massima che devono essere eseguite dal codice 

SFC sono pertanto le seguenti: 

1. avvio del processo a seguito dell’attivazione del comando Start; 

2. gestione della messa in pausa e del riavvio del processo a seguito dell’attivazione 

del comando emergenza; 

3. gestione dell’emergenza in seguito al malfunzionamento di entrambi gli attuatori 

scarA e scarB; 

4. controllo del ciclo di carico e scarico dei carrelli A, B e C; 

5. diagnostica automatica dei guasti degli attuatori scarA e scarB; 

6. gestione della lavorazione a prestazioni ridotte a seguito della rottura di uno 

degli attuatori scarA o scarB. 

È immediato intuire che le specifiche 1-3 sono specifiche di alto livello, mentre le 

specifiche 4-6 sono specifiche di basso livello; pertanto le prime saranno realizzate 

mediante un diagramma SFC di alto livello (Main), mentre le restanti saranno 

gestite da un diagramma di livello gerarchico inferiore (Controllo) secondo la 

struttura padre/figlio. La struttura del codice è indicata in Figura 1. 

Il diagramma padre Main è riportato in Figura 2. Tale diagramma, non dovendo 

eseguire nessuna operazione di inizializzazione o di messa in opera del 

sistema, avvia immediatamente il processo figlio Controllo e, in seguito, attende 

una delle due situazioni da gestire: attivazione del comando emergenza o, in maniera 

mutuamente esclusiva, diagnosi della rottura di entrambi gli attuatori scarA 

e scarB (condizione guastoA*guastoB). Nel caso di messa in pausa del processo 

si utilizza il comando Gfreeze per congelare il diagramma SFC Controllo e, solo 

in seguito alla disattivazione del comando emergenza, si riavvia il processo figlio 

mediante il comando GRST; si noti come in questo caso il codice rimandi allo 

stato dummy 2 evitando in questo modo la generazione di un’ulteriore istanza 

del figlio Controllo in seguito al transito nello stato 1. La situazione di guasto 

degli attuatori scarA e scarB viene segnalata al Main mediante le variabili interne 

booleane guastoA e guastoB che, in accordo alla struttura mostrata in Figura 1, 

Copyright © 2010 - The McGraw-Hill Companies srl

2 Sistemi di automazione industriale - C. Bonivento, L. Gentili, A. Paoli 

Main: 

avvio del processo (Start); 

gestione della messa in pausa e del riavvio del processo (emergenza); 

gestione dell'emergenza in seguito al malfunzionamento di (scarA) e (scarB); 

Controllo: 

controllo del ciclo di carico e scarico dei tre carrelli; 

diagnostica automatica dei guasti di (scarA) o (scarB); 

gestione della lavorazione in di caso di guasto di (scarA) o (scarB); 

Figura 1 Strutturazione del codice SFC relativo all’Esercizio E7.1. 

Main 

3 

4 

1 

guastoA*guastoB 

1 

2 

Action(P): 

Gkill(Controllo); 

end_action; 

AllarmeGuasto; 

GuastoRisolto 

true 

guastoA(R); 

guastoB(R); 

true 

Action(P): 

num:=0; 

Gstart(Controllo); 

end_action; 

5 

2 

Emergenza*not(guastoA*guastoB) 

Action(P): 

Gfreeze(Controllo); 

end_action; 

not(emergenza) 

Action(P): 

GRST(Controllo); 

end_action; 

Figura 2 Diagramma SFC relativo all’Esercizio E7.1: diagramma principale 

main. 

saranno gestite nel diagramma SFC Controllo. In seguito al verificarsi della condizione 

guastoA*guastoB, il diagramma figlio Controllo viene terminato mediante 

il comando Gkill e, successivamente all’avvenuta riparazione degli attuatori guasti 

(segnalata dalla variabile GuastoRisolto), il processo riparte da capo mediante 

il rimando allo stato 1. Si noti come nello stato 1 viene definita e inizializzata la 

variabile interna intera Num che servirà nel figlio Controllo per contare i pacchi 

trasportati dai carrelli A e B (è infatti necessario attivare il carrello C ogni volta 

che i carrelli A e B hanno trasportato quattro prodotti). 

Il diagramma SFC Controllo, mostrato in Figura 3, si occupa del controllo del 

6 

true 



101 

102 

103 

104 

true 

S1 

105 

scambio1(S); 

avantiA; 

posA>=40 

106 

macro1 

Start 

carA; 

pienoA 

avantiA; 

posA>=20 

Num


ciclo di carico e scarico dei tre carrelli gestendo le situazioni di possibile collisione. 

Come detto precedentemente dal testo si evince la necessità di una doppia 

struttura semaforica di mutua esclusione. Questo è possibile utilizzando opportunamente 

i due stati semaforici S1 e S2. Lo stato S1, mediante la struttura semaforica 

a due vie, permette di gestire in maniera mutuamente esclusiva l’accesso 

al binario condiviso dai carrelli A e B. Entrambi i carrelli attendono l’accesso 

alla zona condivisa in una zona di attesa sicura caratterizzata dalla condizione posX≥20 

(X= {A;B}). Il carrello A è considerato maggiormente prioritario come 

indicato dalla condizione true tra gli stati 104 e S1 e lo stato 105 e dalla condizione 

not(GS104.X) tra gli stati 204 e S1 e lo stato 205. Appena uno dei due carrelli 

occupa il semaforo (disattivando lo stato S1) imposta il valore corretto per l’attuatore 

scambio (true per il carrello A e false per il carrello B) e, successivamente, 

impegna il binario condiviso. Lo stato S2 permette di gestire in maniera mutuamente 

esclusiva l’accesso al binario condiviso dai carrelli A o B con il carrello C. 

Dato che a priori è impossibile stabilire chi tra i carrelli A e B sia passato al semaforo 

S1, il secondo semaforo è un semaforo a tre vie. I carrelli A e B attendono 

l’accesso alla zona condivisa in una zona di attesa sicura caratterizzata dalla condizione 

posX≥40 (X= {A;B}); il carrello C attende l’accesso alla zona condivisa 

in una zona di attesa sicura caratterizzata dalla condizione posC≥40. La priorità 

è a questo punto indifferente dato che è impossibile che entrambi i carrelli A e B 

siano nella zona di attesa, il carrello A e B deve entrare nella zona condivisa solo 

se sono presenti meno di quattro prodotti (Num


not(vuotoA)* 

(GS108.T>t#120s) 

114 guastoA(S); 

dietroA; 

posA=60 

S1 

116 avantiA; 

posrip 

S2 

117 AllarmeGuasto; 

GuastoRisolto 

118 dietroA; 

119 

120 

121 

112 

posA=100+num*10 

108 scarA; 

109 

vuotoA 

Action(P): 

num:=num+1; 

end_action; 

not(GS104.X)*not(GS204.X)*(num


In Figura 4 è presentato il macrostato macro1; in tale macrostato sono descritte 

le operazioni che il carrello A deve eseguire una volta che ha avuto accesso 

all’ultima zona del percorso. Il carrello A, una volta impostati i valori corretti 

per gli attuatori di scambio scambio2 e scambiodead, viene portato nella zona 

di scarico, la cui posizione dipende dal numero del prodotto trasportato (posA≥140+Num*10), 

il prodotto viene scaricato e il contatore dei prodotti viene 

incrementato mediante l’azione di tipo P Num:=Num+1. Dato che durante tali 

operazioni si utilizza l’attuatore scarA (soggetto a guasto), nel caso in cui il 

carrello non risulti vuoto entro 120 secondi, si segnala il guasto mediante l’attivazione 

della variabili interna booleana guastoA. A questo punto, dato che in caso di 

guasto singolo occorre continuare a prestazioni ridotte la lavorazione, il carrello 

A viene portato nella zona di manutenzione grazie all’attuatore scambiodead e, 

appena la zona condivisa è superata (posA≥60), vengono liberati entrambi i semafori 

S1 e S2 per permettere al carrello sano di continuare il proprio ciclo. Una 

volta raggiunta la posizione di manutenzione posrip, si segnala il guasto mediante 

l’attuatore AllarmeGuasto e, quando la riparazione è avvenuta, si riporta il carrello 

in zona di carico. Dato che durante questa operazione occorre passare per 

le zone condivise, bisogna occupare entrambi i semafori S1 e S2 nel momento in 

cui si è sicuri che nè il carrello B nè il carrello C stanno transitando (condizione 

not(GS104.X)*not(GS204.X)*(num¡4)*not(GS106.X)*not(GS206.X)). 

Il macrostato macro2, mostrato in Figura 5, presenta le operazioni che il carrello 

B deve eseguire una volta che ha avuto accesso all’ultima zona del percorso. 

Queste sono del tutto simili a quelle del carrello A e, pertanto, non saranno qui 

descritte. 

Infine in Figura 5 è riportato il macrostato macro3 che descrive le operazioni 

del carrello C. Il carrello C, una volta impostati i valori corretti per gli attuatori 

di scambio scambio2 e scambiodead, viene portato nella zona a lui dedicata (posC≥140), 

viene caricato con i quattro prodotti trasportati dai carrelli A e B, viene 

movimentato fino a che posC≥200 e viene nuovamente scaricato. A questo punto 

il carrello C, avendo terminato il proprio compito, può tornare nella posizione 

iniziale non prima di aver azzerato il contatore (Num:= 0) in modo da iniziare il 

trasporto di altri quattro prodotti. 



not(vuotoB)* 

(GS208.T>t#120s) 

214 guastoB(S); 

dietroB; 

posB=60 

S1 

216 avantiB; 

posrip 

S2 

217 AllarmeGuasto; 

GuastoRisolto 

218 dietroB; 

219 

220 

221 

212 

posB=100+num*10 

208 scarB; 

209 

vuotoB 

Action(P): 

num:=num+1; 

end_action; 

not(GS104.X)*not(GS204.X)*(num


macro3 

Figura 6 Macrostato macro3. 

304 scambio2(R); 

scambiodead(R); 

avantiC; 

posC>=140 

305 carC; 

308 

pienoC 

306 avantiC; 

posC>=200 

307 scarC; 

vuotoC 

Action(P): 

num:=0; 

end_action; 




Il sistema da controllare è composto da tre stazioni di lavorazione che possono 

operare in parallelo; le tre stazioni sono collegate da una linea di trasporto che 

provvede alla movimentazione dei blister da una stazione all’altra. Appare chiara 

quindi la necessità di sincronizzare l’inizio e la fine delle lavorazioni delle tre stazioni 

con il movimento del nastro: le tre macchine devono iniziare a lavorare solo 

quando il nastro trasportatore ha movimentato i blister, le lavorazioni possono a 

questo punto procedere in maniera indipendente e, solo quando tutte le stazioni 

hanno terminato il loro lavoro, è possibile nuovamente azionare il nastro trasportatore 

per movimentare opportunamente i blister. Queste considerazioni suggeriscono 

l’utilizzo di una struttura di parallelismo e sincronizzazione che permetta il 

coordinamento delle tre stazioni di lavorazione con il nastro trasportatore. 



1. avvio del processo a seguito dell’attivazione del comando start; 


del comando Allarme; 

3. gestione dell’emergenza in seguito al malfunzionamento dell’attuatore salda; 

4. controllo delle operazioni delle tre stazioni e del nastro di trasporto blister; 

5. diagnostica automatica dei guasti dell’attuatore salda; 

6. gestione della lavorazione a prestazioni ridotte di 10 blister a seguito della 

rottura dell’attuatore salda; 

7. controllo del nastro di trasporto delle pasticche. 

È immediato intuire che le specifiche 1-3 sono specifiche di alto livello, mentre 

le specifiche 4-7 sono specifiche di basso livello; inoltre la specifica 7 è indipendente 

dalle specifiche 4-6. Pertanto le specifiche 1-3 saranno realizzate mediante 

un diagramma SFC di alto livello (Main), le specifiche 4-6 saranno gestite da 

un diagramma di livello gerarchico inferiore (Lavorazione) e la specifica 7 sarà 

implementata da un secondo diagramma SFC di livello gerarchico inferiore NastroPillola. 

Per organizzare tali diagrammi si sfrutterà la struttura padre/figlio: il 

diagramma Main genererà i due programmi figlio Lavorazione e NastroPillola. 

La struttura del codice è indicata in Figura 7. 

Il diagramma padre Main è riportato in Figura 8. Tale diagramma, non dovendo 

eseguire nessuna operazione di inizializzazione o di messa in opera del 

sistema, a seguito dell’attivazione del comando start, avvia immediatamente i processi 

figlio Lavorazione e NastroPillola. In seguito il Main attende una delle due 

situazioni da gestire: attivazione del comando Allarme o, in maniera mutuamente 

esclusiva, diagnosi della rottura dell’attuatore salda e lavorazione a prestazioni 

ridotte di 10 blister (condizione guasto*(npezzi=10)). Nel caso di messa in pausa 

del processo si utilizza il comando Gfreeze per congelare i diagrammi SFC Lavorazione 

e NastroPillola e, solo in seguito alla disattivazione del comando Allarme, 

si riavviano entrambi i processi figlio mediante il comando GRST; si noti come 

in questo caso il codice rimandi allo stato dummy 3 evitando in questo modo la 

generazione di un’ulteriore istanza dei processi Lavorazione e NastroPillola in 



Main: 

avvio del processo (start); 

gestione della messa in pausa e del riavvio del processo (Alalrme); 

gestione dell'emergenza in seguito al malfunzionamento di (salda); 

Lavorazione: 

controllo delle operazioni delle stazioni e del nastro di trasporto blister; 

diagnostica automatica dei guasti di (salda); 

gestione della lavorazione a prestazioni ridotte in caso di guasto di (salda); 

NastroPillola: 

controllo del nastro di trasporto delle pasticche; 


seguito al transito nello stato 2. La situazione di guasto dell’attuatore salda viene 

segnalata al Main mediante la variabile interna booleana guasto che, in accordo 

alla struttura mostrata in Figura 7, sarà gestita nel diagramma SFC Lavorazione. 

In seguito al verificarsi della condizione guastoA*(npezzi=10), i diagrammi figlio 

Lavorazione e NastroPillola vengono terminati mediante il comando Gkill, gli attuatori 

che potrebbero essere rimasti settati vengono resettati e, successivamente 

all’avvenuta riparazione dell’attuatore guasto (segnalata dalla variabile GuastoRisolto), 

il processo riparte da capo mediante il rimando allo stato 1. Si noti come 

nello stato 2 vengono definite e inizializzate le variabili interne intere npezzi, nx, 

ny e n che vengono utilizzate nel figlio Lavorazione rispettivamente per contare i 

pezzi prodotti a prestazione ridotte in seguito a un guasto sull’attuatore salda, per 

gestire le coordinate lungo gli assi x e y al fine del posizionamento delle pasticche 

nel blister e per contare le pillole posizionate nel blister (un blister è completato 

dopo aver posizionato opportunamente quattro pasticche). 

In Figura 9 sono mostrati i diagrammi SFC Lavorazione e NastroPillola. Il 

processo figlio NastroPillola si occupa del controllo del nastro di trasporto delle 

pasticche. Molto semplicemente si movimenta il nastro fino a che una pasticca 

non è posizionata nella zona di presa della stazione di posizionamento (condizione 

pillpres); a questo punto si arresta il nastro fino a che la pasticca è stata prelevata 

(condizione not(pillpres)). 

Il diagramma SFC Lavorazione si occupa del controllo del ciclo operativo 

delle tre stazioni di lavorazione e della sincronizzazione di queste con il movimento 

del nastro di trasporto dei blister. Questo avviene grazie alle strutture di 

parallelismo e sincronizzazione: quando lo stato 10 è attivo il nastro di trasporto 

dei blister è fermo e i blister da lavorare sono nelle posizioni corrette; le tre stazioni 

di lavorazione possono pertanto iniziare in parallelo le sequenze operative. 

Quando tutte e tre le stazioni hanno terminato il proprio lavoro (gli stati 105, 218 

e 407 sono contemporaneamente attivi), la struttura di sincronizzazione riattiva 

il movimento del nastro (stato 20) portando un nuovo blister e movimentando i 



Main 

4 

5 

3 

Allarme 

Action(P): 

Gfreeze(Lavorazione); 

Gfreeze(NastroPillola); 

end_action; 

LuceAllarme; 

not(Allarme) 

true 

1 

2 

3 

Start 

Action(P) 

GRST(Lavorazione); 

GRST(NastroPillola); 

end_action; 

Action(P): 

npezzi:=0; 

n:=0; 

nx:=70; 

ny:=50; 

Gstart(Lavorazione); 

Gstart(NastroPillola); 

end_action; 

true 

6 

7 

1 

(npezzi=10)*guasto*not(allarme) 

Action(P): 

Gkill(Lavorazione); 

Gkill(NastroPillola); 

end_action; 

pinza(R); 

LuceAllarme; 

GuastoRisolto 

true 

guasto(R); 


main. 

blister semilavorati tra le stazioni (condizione PosLav). Si noti come tutti i dettagli 

operativi siano a questo livello mascherati all’interno dei macrostati Carico, 

Posizionamento e Rifinitura e Scarico dedicati al controllo delle tre stazioni. Si 

noti in ultimo come la condizione di partenza del diagramma SFC Lavorazione 

sia data dalla condizione start; in questo modo, nel caso il comando start venga 

disattivato durante una lavorazione, le operazioni avviate possono essere portate 

a termine e, solo al momento di iniziare un nuovo ciclo di lavoro (stato 10), il 

processo si ferma in attesa di una nuova attivazione del comando start. 

Il macrostato Carico, mostrato in Figura 10, si occupa del controllo della 

stazione di carico blister. Dato che non è sempre assicurata la presenza di un 

blister in tale stazione, si utilizza una struttura di scelta a due vie per evitare, nel 

caso di assenza del blister (condizione not(blisterCar)), di bloccare la struttura di 

sincronizzazione finale. In caso di assenza di blister si segnala immediatamente il 

termine delle operazioni mediante l’attivazione dello stato 104. Nel caso in cui il 



Lavorazione 

10 

NastroPillola 

start 

Carico Posizionamento Rifinitura e Scarico 

true true true 

105 218 407 

20 

10 

true 

Nastro; 

PosLav 

Figura 9 Diagrammi figlio Lavorazione e NastroPillola. 

501 

502 

501 

nastropill; 

pillpres 

not(pillpres) 

blister sia presente lo si carica nel sistema mediante l’attuatore carica. 

In Figura 10 è riportato il diagramma SFC del macrostato Posizionamento che 

si occupa del controllo della stazione di posizionamento delle pasticche nel blister. 

Anche in questo caso, visto che non è sempre assicurata la presenza di un 

blister in tale stazione, si utilizza una struttura di scelta a due vie per evitare, nel 

caso di assenza del blister (condizione not(blisterPos)), di bloccare la struttura di 

sincronizzazione finale. In caso di assenza di blister si segnala immediatamente 

il termine delle operazioni mediante l’attivazione dello stato 217. Nel caso in cui 

il blister sia presente, si movimenta il manipolatore fino alla zona di presa (Finegiu, 

x≤0, y≤0) e si attende la presenza di una pasticca da afferrare (condizione 

PillPres). A questo punto si afferra la pasticca mediante l’attuatore pinza (si noti 

che il comando è di tipo set per continuare l’afferraggio anche durante la movimentazione 

della pasticca) e la si trasporta nella posizione desiderata del blister 

(Finegiu, x≥nx, y≥ny). Si noti che la posizione della pasticca è parametrizzata 

dalle variabili nx e ny che dipendono dal numero di pillola che si sta posizionando 

(memorizzato nella variabile n). Quindi, appena la pasticca è stata posizionata, si 

incrementa il contatore delle pillole mediante l’azione di tipo P n:=n+1 e si aggiornano 

opportunamente gli indici nx e ny in modo da stabilire dove si posizionerà 

la pillola successiva. Questo è possibile mediante la struttura di scelta a quattro 

vie dipendente da n: nel caso in cui n


Carico 

101 

blisterCar not(blisterCar) 

102 carica; 

103 

FCCA 

FCCI 

104 

406 

401 

blisterScar not(blisterScar) 

guasto not(guasto) 

402 

salda; 

(GS402.t>t#10s)* 

not(saldaOK) 

405 guasto(S); 

not(guasto) 

400 

406 scarica; 

Action(P): 

npezzi:=npezzi+1; 

end_action; 

FCS 

Figura 10 Macrostati Carico e Rifinitura e Scarico. 

Rifinitura e Scarico 

404 

saldaOK 

403 scarica; 

segnala il completamento del blister mediante l’attivazione dello stato 217. 

Infine in Figura 9 è riportato il diagramma SFC del macrostato Rifinitura e 

Scarico che gestisce le operazioni della stazione di saldatura e scarico blister finiti. 

Similmente agli altri macrostati, visto che non è sempre assicurata la presenza di 

un blister in tale stazione, si utilizza una struttura di scelta a due vie per evitare, nel 

caso di assenza del blister (condizione not(blisterScar)), di bloccare la struttura di 

sincronizzazione finale. In caso di assenza di blister si segnala immediatamente il 

termine delle operazioni mediante l’attivazione dello stato 404. Nel caso in cui il 

blister sia presente, si provvede a saldarlo (attuatore salda) e a scaricarlo (attuatore 

scarica). Dato che durante tali operazioni si utilizza l’attuatore salda (soggetto 

a guasto), nel caso in cui la saldatura non risulti eseguita entro 10 secondi, si 

segnala il guasto mediante l’attivazione della variabili interna booleana guasto. 

Da questo istante occorrerà scaricare i blister senza averli saldati ed aggiornare 

ad ogni blister scaricato il contatore npezzi in modo da permettere al diagramma 

main di interrompere la lavorazione dopo aver lavorato dieci blister non saldati. 

FCS 



202 

202 

A; 

Finesu 

203 dietroX; 

xt#3ms 

208 A; 

Finesu 

209 avantiX; 

210 

n=1 

x>=nx 

y>=ny 

212 Action(P): 

n:=n+1; 

End_action; 

Pinza(R); 


nx:=80; 

ny:=50; 

End_action; 

true 

202 

n=2 


nx:=80; 

ny:=30; 

End_action; 

true 

201 

blisterPos not(blisterPos) 

204 dietroY; 

y


Si noti che in ogni ciclo operativo, nel caso in cui si sia già diagnosticato il guasto, 

la struttura di scelta a due vie a valle dello stato 401, permette di velocizzare le 

operazioni senza attendere ogni volta i 10 secondi necessari per la diagnosi del 

guasto (rimando allo stato 406). 




La maggior difficoltà dell’esercizio consiste nel dover gestire allo stesso tempo 

molti componenti: i due nastri di arrivo materiali, i due robot, il nastro centrale e 

la macchina per la stampa con buffer per i pezzi in ingresso. Leggendo attentamente 

il testo, si evince tuttavia che il comportamento di tali entità sono indipendenti 

l’uno con l’altro e il loro coordinamento avviene semplicemente utilizzando 

i sensori che monitorano le posizioni di interferenza tra questi. Strutturando opportunamente 

il codice SFC è possibile risolvere il problema mediante una serie di 

diagrammi molto semplici. L’unica struttura degna di nota è il semaforo di mutua 

esclusione necessario per controllare i due manipolatori evitando collisioni. 




2. inizializzazione del sistema; 

3. arresto del processo a seguito di comando dell’operatore (segnale off attivo per 

più di due secondi); 

4. gestione dell’emergenza in seguito al malfunzionamento di entrambi i nastri di 

arrivo materiali; 

5. controllo dei nastri di ingresso; 

6. diagnostica automatica dei guasti degli attuatori nastro1 e nastro2; 

7. controllo manipolatori in concorrenza evitando le collisioni; 

8. controllo del nastro centrale; 

9. controllo del ribaltatore a ventosa; 

10. controllo della macchina di stampa con nastro di ingresso; 

11. filtraggio del segnale off per registrare solo permanenze al livello logico alto 

che durano più di due secondi. 

Le specifiche 1-4 sono gestite dal diagramma di alto livello main. Le specifiche 

5-6 saranno gestite dai due diagrammi figlio ctrl-nastro1 e ctrl-nastro2. La necessità 

di coordinamento tra i due manipolatori e il nastro centrale suggerisce di 

considerare le specifiche 7-8 in un unico processo figlio Robot. Le specifiche 9- 

10 saranno gestite rispettivamente da due processi figli denominati ctrl-Ventosa e 

Buffer. Infine si è deciso di considerare la specifica 11 in un ulteriore processo 

figlio off filter dedito a monitorare e filtrare il segnale off. La struttura del codice 

è indicata in Figura 12 

Il diagramma padre main è riportato in Figura 13. Tale diagramma attende 

l’attivazione da parte dell’operatore del comando Start e, in seguito a questo 

evento, gestisce le operazioni di inizializzazione del sistema, ovvero la movimentazione 

dei manipolatori verso i nastri di ingresso e del ribaltatore verso l’ingresso 

della macchina di espulsione. Terminata la fase di inizializzazione, vengono 

avviati tutti i processi figlio e si attende una delle due situazioni da gestire: attivazione 

del comando off per almeno due secondi o, in maniera mutuamente 

esclusiva, diagnosi della rottura di entrambi gli attuatori nastro1 e nastro2 (condizione 

guasto1*guasto2). La situazione di guasto di entrambi i nastri di ingresso 



Main: 


inizializzazione del processo; 

arresto del processo (stop); 

gestione dell'emergenza in seguito al malfunzionamento di entrambi i nastri; 

ctrl-astro1: 

gestione del controllo del nastro 1; 

diagnostica automatica dei guasti del nastro 1; 

ctrl-nastro2: 

gestione del controllo del nastro 2; 

diagnostica automatica dei guasti del nastro 2; 

ctrl-Ventosa: 

controllo del ribaltatore a ventosa; 

Buffer: 

controllo della macchina di stampa con buffer di ingresso; 

Robot: 

controllo dei due robot con sequenze mutuamente esclusive; 

controllo del nastro centrale; 

off_filter: 

filtraggio del segnale (off) e generazione del segnale (stop); 


viene segnalata al main mediante le variabili interne booleane guasto1 e guasto2 

che, in accordo alla struttura mostrata in Figura 12, vengono gestite nei diagrammi 

SFC ctrl-nastro1 e ctrl-nastro2. In seguito al verificarsi della condizione 

guasto1*guasto2, tutti i diagrammi figli vengono terminati mediante il comando 

Gkill, gli attuatori che potrebbero essere rimasti settati vengono resettati e, 

successivamente all’avvenuta riparazione (segnalata dalle variabili oktecnico1 e 

oktecnico2), il processo riparte da capo mediante il rimando allo stato 1. Dato 

che si è deciso di realizzare il filtraggio della variabile off in un processo figlio, la 

situazione di richiesta di arresto della macchina verrà segnalata al main tramite la 

variabile interna booleana stop. Anche nel caso di spegnimento del sistema (condizione 

stop) tutti i diagrammi figli vengono terminati e il codice SFC rimandato 

allo stato 1. Si noti come nello stato 8 vengono inizializzate a zero le variabili 

interne intere n e nbuff utilizzate nei processi figlio rispettivamente per contare 

il numero dei semilavorati trasportati dai manipolatori (ogni due semilavorati si 

ottiene un prodotto finito) e per gestire il conteggio dei pezzi contenuti nel buffer 



true 

main 

2 

3 

FCD1 

Dietro1; 

stop 

true 

8 

9 

1 

4 

5 

Start 

FCD2 

Dietro2; 

true 

Action(P): 

n:=0; 

nbuff:=0; 

Gstart(ctrl-nastro1); 

Gstart(ctrl-nastro2); 

Gstart(Robot); 

Gstart(ctrl-Ventosa); 

Gstart(Buffer); 

Gstart(off_filter); 

end_action; 

10 ventosa(R); afferra1(R); 

afferra2(R); 

guasto1(R); guasto2(R); 

Action(P): 

Gkill(ctrl-nastro1); 


1 

Gkill(Robot); Gkill(ctrl-Ventosa); 

Gkill(Buffer); Gkill(off_filter); 

end_action; 

6 

7 

FWD; 

FCFWD 

11 

1 

501 

501 

not(off) 

pres1 

guasto1*guasto2*not(stop) 

ventosa(R); afferra1(R); 

afferra2(R); 

guasto1(R); guasto2(R); 

Action(P): 



Gkill(Robot); Gkill(ctrl-Ventosa); 

Gkill(Buffer); Gkill(off_filter); 

end_action; 

luceallarme1; 

luceallarme2; 

oktecnico1*oktecnico2 

off_filter 

(GS502.t>=t#2s)* 

off 

503 stop; 


main. 

di ingresso della macchina di espulsione. 

Sempre in Figura 13 è riportato il diagramma SFC del processo off filter dedicato 

a registrare le richieste di spegnimento della macchina da parte dell’operatore. 

Tale diagramma esce dallo stato iniziale appena rileva il comando off ; dallo 

stato 502 il codice può evolvere se il comando off si disattiva prima di due secondi 

(in questo caso la richiesta è abortita e il diagramma torna nello stato iniziale 501) 

o se dopo due secondi il comando off è ancora attivo. In questo secondo caso 

si transita nello stato 503, si memorizza la richiesta di spegnimento attivando la 

variabile interna booleana stop e si attende indefinitamente che il main prenda il 

502 

501 

false 



302 

301 

pres1 

ctrl-nastro1 

301 

not(pres1) 

nastro1; 

(GS301.t>=t#60s)* 

not(pres1) 

303 guasto1(S); 

luceallarme1; 

oktecnico1 

304 guasto1(R); 

301 

true 

402 

401 

pres2 

ctrl-nastro2 

401 

not(pres2) 

Figura 14 Diagrammi figlio ctrl-nastro1 e ctrl-nastro2. 

nastro2; 

(GS401.t>=t#60s)* 

not(pres2) 

403 guasto2(S); 

luceallarme2; 

oktecnico2 

404 guasto2(R); 

controllo (condizione false). 

In Figura 14 sono mostrati i diagrammi SFC ctrl-nastro1 e ctrl-nastro2 che si 

occupano del controllo dei nastri di trasporto dei semilavorati. Molto semplicemente 

si movimenta il nastro fino a che un semilavorato non è posizionato nella 

zona di presa del corrispondente manipolatore (condizioni pres1 e pres2); a questo 

punto si arresta il nastro fino a che il materiale è stata prelevato (condizioni 

not(pres1) e not(pres1)). Dato che gli attuatori nastro1 e nastro2 sono soggetti a 

guasti, nel caso in cui, movimentando un nastro, non arrivi un semilavorato entro 

un minuto, si segnala il malfunzionamento mediante le variabili interne booleane 

guasto1 e guasto2 rispettivamente per gli attuatori nastro1 e nastro2. Una volta 

rilevato il guasto, il processo figlio si posiziona nello stato 303 o 403 e attende la 

riparazione (condizioni oktecnico1 e oktecnico2) per ripartire con il funzionamento 

nominale. Nel caso in cui entrambi i nastri siano rotti (entrambe le condizioni 

guasto1 e guasto2 sono verificate) il main prende il controllo come descritto in 

precedenza. 

Il diagramma SFC Robot, mostrato in Figura 15, si occupa del controllo dei 

due manipolatori e del nastro centrale. La presenza di una zona di lavoro condivisa 

dai robot (la zona di deposito dei semilavorati sul nastro centrale) e, dunque, la 

possibilità di collisione, suggerisce l’utilizzo della struttura semaforica di mutua 

esclusione con stato semaforo S (si rammenti che lo stato semaforo deve essere 

stato iniziale). Il manipolatore 1 attende un semilavorato nella zona sicura rappresentata 

dal finecorsa indietro FCD1; in presenza di un semilavorato sul nastro 

di ingresso 1 (condizione pres1) impegna immediatamente il semaforo disattivando 

lo stato S (impedendo in questo modo l’accesso al manipolatore 2), afferra il 

semilavorato e lo trasporta aggiornando il contatore dei pezzi presenti sul nastro 

centrale (azione P n:=n+1). A questo punto può tornare in posizione di sicurezza 

(condizione FCD1 e attendere un nuovo prodotto); si noti tuttavia che il 

semaforo non viene liberato immediatamente, ma solo all’uscita del macrostato 

401 

true 



101 

102 

103 

104 

true 

afferra1(S); 

GS103.t>=t#3ms 

FCA1 

105 afferra1(R); 

106 

101 

pres1 

Avanti1; 


Action(P): 

n:=n+1; 

end_action; 

Dietro1; 

FCD1 

Robot 

S 

salda 

true 

203 

204 

201 

202 

pres1 

not(GS102.x) 

afferra2(S); 


FCA2 

205 afferra2(R); 

206 

Avanti2; 


Action(P): 

n:=n+1; 

end_action; 

Dietro2; 

FCD2 

Figura 15 Diagramma figlio Robot e macrostato salda. 

201 

salda 

107 

(n=2)* 

not(PresCentro) 

108 salda; 

109 

GS108.t>=t#1s 

NastroCentro; 

Action(P): 

n:=0; 

end_action; 

PresCentro 

salda che si occupa del controllo del nastro centrale (se sul nastro centrale c’è un 

solo semilavorato occorre trasportarne un altro, se ce ne sono due occorre movimentare 

il nastro centrale per permettere l’espulsione del prodotto terminato). Il 

manipolatore 2 viene controllato allo stesso modo; la priorità in caso di ingresso 

contemporaneo dei manipolatori è data al manipolatore 1 (si notino la condizione 

true tra gli stati 102 e S e lo stato 103 e la condizione not(GS102.x) tra gli stati 202 

e S e lo stato 203). Sempre in Figura 15 è mostrato il macrostato salda. Appena 

un manipolatore ha trasportato un semilavorato sul nastro centrale occorre testare 

il valore di n: se sul nastro centrale c’è un solo semilavorato (condizione n=1) si 

sblocca subito il semaforo per permettere ai manipolatori di portare il secondo; 

se sul nastro centrale ci sono due semilavorati (condizione n=2) e nella posizione 

di prelievo del ribaltatore non è già presente un ulteriore prodotto (condizione 

not(PresCentro)), si salda il prodotto, lo si movimenta verso la posizione di prelievo 

(attuatore NastroCentro) e si azzera la variabile interna n per poter contare 

altri due semilavorati. A questo punto è possibile sbloccare il semaforo S. 

Il controllo del ribaltatore a ventosa è gestito dal processo figlio ctrl-Ventosa 

riportato in Figura 16. Se nella zona di prelievo è presente un prodotto (condizione 

PresCentro) si movimenta il ribaltatore per andare a prenderlo (attuatore BACK 

fino all’attivazione di FCBACK). A questo punto, se nel buffer di ingresso c’è 

109 

S 

n=1 



ctrl-Ventosa 600 Buffer 700 

true 

PresCentro 

601 BACK; 

602 

FCBACK 

nbuff=t#3ms 

603 FWD; 

FCFWD 

604 Ventosa(R); 

Action(P): 

nbuff:=nbuff+1; 

end_action; 

600 

Figura 16 Diagrammi figlio Ventosa e Buffer. 

true 

nbuff>=1 

701 Stampa; 

GS701.T>=t#120s 

702 Espelli; 

GS702.T>=t#1s 


nbuff:=nbuff-1; 

end_action; 

posto (condizione nbuff



L’esercizio richiede di controllare un lettore cd multiplo con sei dischi; la principale 

difficoltà dell’esercizio risiede nel fatto che, una volta che l’utente richiede 

quale cd suonare (mediante la variabile nuovo), non è possibile associare la posizione 

del carrello della lente (e quindi il disco che si sta suonando) ad un sensore 

dedicato. Il sistema è invece equipaggiato con un unico sensore di posizione sens 

che si attiva ogni volta che il carrello della lente passa in corrispondenza di un disco, 

generando in questo modo un’onda quadra; nel codice SFC occorrerà contare 

dunque il numero di attivazioni e disattivazioni del segnale sens per memorizzare 

in una variabile interna intera corr la posizione attuale del carrello. Confrontando 

il valore di corr con il valore desiderato nuovo è possibile controllare il movimento 

del carrello. 



1. avvio del processo a seguito dell’attivazione del comando on; 

2. gestione dello spegnimento immediato a seguito dell’attivazione del comando 

off ; 


del comando pausa; 

4. gestione dell’emergenza in seguito al malfunzionamento del motore del carrello; 

5. inizializzazione e messa in opera del sistema; 

6. gestione del controllo del carrello della lente; 

7. diagnostica automatica dei guasti del motore del carrello. 

Le specifiche 1-4 sono specifiche di alto livello, mentre le specifiche 5-7 sono specifiche 

di basso livello; pertanto le prime saranno realizzate mediante un diagramma 

SFC di alto livello (main), mentre le restanti saranno gestite da un diagramma 

di livello gerarchico inferiore (controllo) secondo la struttura padre/figlio. La 

struttura del codice è indicata in Figura 17. 

Main: 

avvio del processo (on); 

arresto del processo (off); 

gestione della messa in pausa e del riavvio del processo (pausa); 

gestione dell'emergenza in seguito al malfunzionamento del motore del carrello; 

Controllo: 

inizializzazione e messa in opera del sistema; 

gestione del controllo del carrello della lente; 

diagnostica automatica dei guasti del motore del carrello; 




main 

4 lente(R); 

spin(R); 

Action(P): 

Gkill(controllo); 

End_action; 

1 

off 

true 

1 

2 

3 

on 

Action(P): 

Gstart(controllo); 

nuovo:=0; 

corr:=0; 

end_action; 

true 

5 lente(R); 

spin(R); 

Action(P): 

Gkill(controllo); 

End_action; 

LuceAllarme; 

oktecnico 

1 

guasto*not(off ) 

6 

7 

3 

pausa*not(guasto)*not(off) 

lente(R); 

Action(P): 

Gfreeze(controllo); 

end_action; 

not(pausa) 

true 

lente(S); 

Action(P): 

GRST(controllo); 

end_action; 


main. 

Il diagramma padre main è riportato in Figura 18. Tale diagramma attende l’attivazione 

da parte dell’operatore del comando on e, in seguito a questo evento, 

avvia il processo figlio controllo; successivamente il main attende, in maniera 

mutuamente esclusiva, una delle tre situazioni da gestire: attivazione del comando 

off, attivazione del comando pausa, diagnosi della rottura del motore del carrello 

(condizione guasto). Nel caso di messa in pausa del processo si utilizza il comando 

Gfreeze per congelare il diagramma SFC Controllo e si resetta l’attuatore lente 

(al fine di evitare che il cd continui a suonare il disco). Solo in seguito alla disattivazione 

del comando pausa, si riavvia il processo figlio mediante il comando 

GRST; si noti come in questo caso il codice rimandi allo stato dummy 3 evitando 

in questo modo la generazione di un’ulteriore istanza del figlio controllo in seguito 

al transito nello stato 2. La situazione di guasto del motore del carrello viene 

segnalata al Main mediante la variabile interna booleana guasto che, in accordo 

alla struttura mostrata in Figura 17, viene gestita nel diagramma SFC controllo. In 

seguito al verificarsi della condizione guasto, il diagramma figlio controllo viene 

terminato mediante il comando Gkill, gli attuatori che potrebbero essere rimasti 

settati vengono resettati e, successivamente all’avvenuta riparazione (segnalata 

dalla variabile oktecnico), il processo riparte da capo mediante il rimando allo 

stato 1. Anche nel caso di spegnimento del sistema mediante il comando off il 



112 

controllo 

nuovot#5s 

115 S; 

114 guasto; 

sens 


corr:=corr-1; 

end_action; 

nuovocorr 

101 

false 

101 

true 

iniz 

112 

not(sens)* 

GS115.t>t#5s 

116 guasto; 

101 

false 

nuovo=corr 

118 spin(S); 

119 

112 

GS118.t>t#10ms 

true 

lente(S); 

Figura 19 Diagramma figlio controllo. 

true 

112 

nuovo>corr 

120 spin(R); 

lente(R); 

D; 

sens* 

not(sens) 

GS120.t>t#5s 

122 D; 

121 guasto; 

sens 


corr:=corr+1; 

end_action; 

nuovocorr 

101 

false 

not(sens)* 

GS122.t>t#5s 

123 guasto; 

101 

false 

nuovo=corr 

125 spin(S); 

126 

112 

GS125.t>t#10ms 

true 

lente(S); 

diagramma figlio controllo viene terminato e il codice SFC rimandato allo stato 1. 

Si noti come nello stato 2 vengono inizializzate a zero le variabili intere nuovo e 

corr utilizzate nel figlio controllo per la movimentazione del carrello della lente. 

In Figura 19 è riportato il codice SFC per il processo figlio controllo; questo, 

in accordo allo schema di Figura 17, si occupa della fase di messa in opera del 

sistema (macrostato iniz) e del controllo del moto del carrello. Dopo la fase di 

inizalizzazione e messa in opera il codice attende che l’utente faccia una richiesta 

diversa da quella che si sta attualmente servendo (nuovo̸=corr); questa situazione 

è divisa nelle due condizioni esclusive nuovocorr necessarie per 

decidere la direzione del moto del carrello (verso sinistra nel primo caso e verso 

destra nel secondo caso). Appena si verifica una di queste due condizioni si ferma 

la lettura del cd attuale (resettando gli attuatori lente e spin) e si movimenta 



iniz 

FCD 

105 S; 

not(FCS)*sens not(FCS)*not(sens)* FCS 

106 S; 

GS105.t>t#5s 

108 

Action(P): 

nums:=nums+1; 

end_action; 

sens* 

not(sens) 

GS106.t>t#5s 

107 guasto; 

false 

101 

nums=6 

110 

105 

111 guasto; 

101 

false 

Figura 20 Macrostato iniz. 

102 

Action(P): 

nums:=0; 

end_action; 

true 

103 D; 

not(FCD)*GS103.t>t#30s 

104 guasto; 

101 

false 

nums6 

109 guasto; 

opportunamente il carrello nella direzione opportuna. Ogni volta che durante il 

moto del carrello si rileva una nuova attivazione del segnale sens si aggiorna il 

valore di corr (azione P corr:=corr-1 nel caso di moto verso sinistra, azione P 

corr:=corr+1 nel caso di moto verso destra). Si noti che si rileva il fronte di salita 

del segnale sens solo in caso di una sua disattivazione (condizione not(sens)) 

seguita da una successiva riattivazione; questo è necessario per evitare che l’esecuzione 

ciclica real time time-driven del codice causi la rilevazione successiva 

della stessa posizione (a causa delle dimensioni fisiche del sensore magnetico) 

falsando il conteggio. Il moto del carrello si arresta quando si raggiunge la posizione 

desiderata (condizione nuovo=corr); in questo caso si inizia a suonare il 

cd (settando gli attuatori lente e spin) e si rimanda il codice SFC allo stato 112 in 

attesa di una nuova richiesta dell’utente. Dato che il carrello del motore è soggetto 

a guasto, ogni volta che il carrello è in movimento, si sfrutta l’informazione che 

due posizioni devono sempre essere raggiunte entro 5 secondi per diagnosticare 

un eventuale guasto: se il motore del carrello è attivo e il segnale sens rimane allo 

stesso valore per più di 5 secondi, si attiva la variabile interna booleana guasto per 

segnalare al main la rilevazione di un malfunzionamento. 

In Figura 19 è mostrato il codice SFC relativo al macrostato iniz dedicato alla 

101 

false 



messa in opera del sistema. Dato che non è nota la posizione iniziale del carrello, 

è inizialmente necessario portare questo in uno dei due punti di ancoraggio (finecorsa 

sinistro FCS o destro FCD); in questo caso si è scelto di portare il carrello 

al finecorsa destro. Nel caso in cui non si raggiunga tale posizione in 30 secondi 

si segnala un guasto al motore del carrello. Una volta raggiunto il finecorsa destro 

si porta il carrello al finecorsa sinistro e si utilizza la variabile interna intera nums 

per contare il numero di attivazioni successive di sens che si incontrano. Durante 

tale movimentazione se il motore del carrello è attivo e il segnale sens rimane allo 

stesso valore per più di 5 secondi, si attiva la variabile interna booleana guasto per 

segnalare al main la rilevazione di un malfunzionamento. Una volta raggiunto il 

finecorsa destro, se si sono contate meno di sei attivazioni di sens si segnala un 

guasto al sensore di posizione; se invece nums è pari a sei, l’inizializzazione è 

andata a buon fine e si può continuare con il funzionamento nominale. 



Main: 


inizializzazione e messa in opera del sistema; 

gestione della messa in pausa e del riavvio del processo (Pause); 

gestione dell'emergenza in seguito al malfunzionamento di (riempiA) e (riempiB); 

Controllo: 

produzione ed imbottigliamento del composto (Ricetta); 

diagnostica automatica dei guasti di (riempiA) o (riempiB); 

gestione della lavorazione in di caso di guasto di (riempiA) o (riempiB); 



Il sistema deve produrre ed imbottigliare un composto chimico seguendo una delle 

quattro ricette possibili secondo le indicazioni dell’operatore. Leggendo il testo 

si evince che, indipendentemente dalla ricetta da seguire, le operazioni da eseguire, 

e quindi la struttura del codice, è la medesima; quello che cambia a seconda 

della ricetta sono solo gli attuatori usati per le varie operazioni. Pertanto la struttura 

del processo SFC che si occupa della produzione e dell’imbottigliamento del 

composto sarà caratterizzato da una struttura a macrostati fissa in cui le operazioni 

in ogni macrostato dipendono dalla ricetta richiesta dall’operatore (e quindi dal 

comando Ricetta). 




2. inizializzazione e messa in opera del sistema; 


del comando Pause; 

4. gestione dell’emergenza in seguito al malfunzionamento di entrambi gli attuatori 

riempiA e riempiB; 

5. produzione ed imbottigliamento del composto secondo la ricetta desiderata; 

6. diagnostica automatica dei guasti degli attuatori riempiA e riempiB; 

7. gestione della lavorazione a prestazioni ridotte a seguito della rottura di uno 

degli attuatori riempiA o riempiB. 

È immediato intuire che le specifiche 1-4 sono specifiche di alto livello, mentre le 

specifiche 5-7 sono specifiche di basso livello; pertanto le prime saranno realizzate 

mediante un diagramma SFC di alto livello (Main), mentre le restanti saranno 

gestite da un diagramma di livello gerarchico inferiore (Controllo) secondo la 

struttura padre/figlio. La struttura del codice è indicata in Figura 21. 

Il diagramma padre Main è riportato in Figura 22. Tale diagramma attende 

l’attivazione da parte dell’operatore del comando Start e, in seguito a questo 



main 

2 

3 

livA 

true 

6 

1 

riempiA; 

palaA; 

7 

Start 

8 Action(P): 

Gkill(Controllo); 

end_action; 

NiDX(R); NiSX(R); 

palaX(R); riempiX(R); 

ApriX(R); VX(R); 

pulisciX(R); 

Nastro(R); 

4 

5 

livB 

riempiB; 

palaB; 

true 

Action(P): 

Gstart(Controllo); 

end_action; 

guastoA*guastoB Pause*not(guastoA*guastoB) 

OK 

9 guastoA(R); guastoB(R); 

luceA(R); luceB(R); 

true 

1 

true 

10 Action(P): 

Gfreeze(Controllo); 

End_action; 

not(Pause) 

11 Action(P): 

GRST(Controllo); 

End_action; 


main. 

evento, gestisce le operazioni di inizializzazione del sistema, ovvero il riempimento 

in parallelo delle cisterne A e B mantenendo le pale in movimento. Terminata 

la fase di inizializzazione, viene avviato il processo figlio Controllo e si attende 

una delle due situazioni da gestire: attivazione del comando Pause o, in maniera 

mutuamente esclusiva, diagnosi della rottura di entrambi gli attuatori riempiA e 

riempiB (condizione guastoA*guastoB). Nel caso di messa in pausa del processo 

si utilizza il comando Gfreeze per congelare il diagramma SFC Controllo e, solo 

in seguito alla disattivazione del comando Pause, si riavvia il processo figlio mediante 

il comando GRST; si noti come in questo caso il codice rimandi allo stato 

dummy 7 evitando in questo modo la generazione di un’ulteriore istanza del figlio 

Controllo in seguito al transito nello stato 6. La situazione di guasto degli attuatori 

riempiA e riempiB viene segnalata al Main mediante le variabili interne booleane 

guastoA e guastoB che, in accordo alla struttura mostrata in Figura 21, saranno 

7 



Controllo 

VersaA 

PuliscieriempiA 

true 

S1 

Figura 23 Diagramma figlio Controllo. 

101 

Start*(Ricetta0) 


Aux:=Ricetta; 

Ricetta:=0; 

end_action; 

true 

Moto 

true 

true 

Imbottiglia 

101 

S2 

true 

VersaB 

true 

PuliscieriempiB 

gestite nel diagramma SFC Controllo. In seguito al verificarsi della condizione 

guastoA*guastoB, il diagramma figlio Controllo viene terminato mediante il comando 

Gkill, gli attuatori che potrebbero essere rimasti settati vengono resettati 

e, successivamente all’avvenuta riparazione degli attuatori guasti (segnalata dalla 

variabile OK), il processo riparte da capo mediante il rimando allo stato 1. 

Il diagramma SFC Controllo, mostrato in Figura 23, si occupa principalmente 

della produzione e dell’imbottigliamento del composto desiderato. Dal testo 

si evince la necessità di una struttura di sincronizzazione, infatti le operazioni di 

preparazione e trasporto dei reagenti A e B devono avvenire in parallelo e, appena 

queste sono terminate, le operazioni di aggiunta dell’additivo corretto e di imbottigliamento 

del composto devono immediatamente partire. Contemporaneamente 

a queste ultime, le operazioni di pulitura e successivo riempimento delle cisterne 

A e B devono essere eseguite non appena le fasi di preparazione del reagente A 

o B sono terminate. Questo è possibile utilizzando opportunamente i due stati di 

sincronizzazione S1 e S2. Il diagramma SFC Controllo attende che la variabile 



Aux=1 

104 N1DX(S); 

N1SX(R); 

N2DX(R); 

N2SX(S); 

N3DX(R); 

N3SX(S); 

N4DX(R); 

N4SX(S); 

N5DX(R); 

N5SX(R); 

true 

Figura 24 Macrostato Moto. 

Aux=2 

Moto 

103 

105 N1DX(S); 

N1SX(R); 

N2DX(R); 

N2SX(S); 

N3DX(R); 

N3SX(S); 

N4DX(S); 

N4SX(R); 

N5DX(R); 

N5SX(R); 

true 

108 

Aux=3 

106 N1DX(S); 

N1SX(R); 

N2DX(R); 

N2SX(S); 

N3DX(S); 

N3SX(R); 

N4DX(R); 

N4SX(R); 

N5DX(R); 

N5SX(S); 

true 

Aux=4 

107 N1DX(S); 

N1SX(R); 

N2DX(R); 

N2SX(S); 

N3DX(S); 

N3SX(R); 

N4DX(R); 

N4SX(R); 

N5DX(S); 

N5SX(R); 

Ricetta sia diversa da 0 per iniziare la produzione del composto desiderato; l’ultima 

variazione di Ricetta viene memorizzata nella variabile interna Aux in modo 

da evitare che ulteriori variazioni nel segnale Ricetta portino ad una variazione in 

corso del composto da preparare. La variabile Ricetta viene inoltre resettata in 

modo da evitare che, una volta terminato il composto desiderato, si riparta con 

la produzione dello stesso composto anche senza un’ulteriore richiesta dell’operatore. 

Si noti come tutti i dettagli operativi siano a questo livello mascherati 

all’interno dei macrostati Moto (che si occupa della movimentazione dei cinque 

nastri per il trasporto dei reagenti), VersaA e VersaB (che gestiscono le operazioni 

di introduzione dei reagenti A e B), PuliscieriempiA e PuliscieriempiB (dedicati 

alle operazioni di pulitura e riempimento delle cisterne A e B) e Imbottiglia 

(che gestisce l’imbottigliamento del composto). Si noti come anche l’informazione 

sulla ricetta che si desidera preparare (dipendente dal segnale Ricetta) è 

anche essa nascosta all’interno dei macrostati. Una volta terminate le operazioni 

di imbottigliamento, il ciclo di lavoro riparte dall’inizio con l’attesa di una nuova 

richiesta da parte dell’operatore (rimando allo stato 101). Si noti in ultimo come 

la condizione di partenza Ricetta̸=0 sia arricchita anche dalla condizione Start; in 

questo modo, nel caso il comando Start venga disattivato durante la preparazione 

di un composto, le operazioni avviate possono terminare e, solo nel momento di 

valutazione di una ulteriore ricetta da produrre (stato 101), il processo si ferma in 

attesa di una nuova attivazione del comando Start. 

In Figura 24 è presentato il macrostato Moto; in tale macrostato, grazie alla 

struttura di scelta a quattro vie, l’ultimo valore utile di Ricetta, memorizzato nella 

true 



VersaA 

109 

not(guastoA) 

110 palaA(S); 

apriA; 

GS110.t>=t#120s 

111 palaA(R); 

true 

112 

guastoA 

Figura 25 Macrostati VersaA e VersaB. 

VersaB 

113 

not(guastoB) 

114 palaB(S); 

apriB; 

GS114.t>=t#120s 

115 palaB(R); 

true 

116 

guastoB 

variabile interna Aux, viene utilizzato per attivare i nastri corretti a seconda della 

richiesta dell’operatore. 

I macrostati VersaA e VersaB, mostrati in Figura 25, comandano le operazioni 

di introduzione dei reagenti; è importante notare che tali operazioni sono eseguite 

solo nel caso in cui non si sia precedentemente diagnosticato un guasto del singolo 

attuatore riempiA o riempiB; infatti, in quest’ultimo caso, la produzione deve 

continuare a prestazioni ridotte utilizzando un solo reagente. Questa struttura è 

necessaria al fine di evitare che un guasto in un attuatore possa bloccare l’intero 

processo (occorre attivare entrambi gli stati di sincronizzazione S1 e S2 per 

proseguire con le operazioni di preparazione e imbottigliamento). 

In Figura 26 sono riportati i macrostati PuliscieriempiA e PuliscieriempiB 

che controllano le operazioni di pulizia e successivo riempimento delle cisterne 

A e B. Dato che durante tali operazioni si utilizzano gli attuatori riempiA e riempiB 

(soggetti a guasti), nel caso in cui il riempimento di una cisterna non termini 

entro 180 secondi, si segnala il guasto mediante l’attivazione delle variabili interne 

booleane guastoA e guastoB. Anche in questo caso, se il guasto è già stato 

segnalato in un ciclo di produzione precedente, le operazioni non vengono eseguite 

e si sblocca immediatamente la struttura di sincronizzazione finale mediante 

l’attivazione degli stati dummy 121 o 126. 

Il macrostato Imbottiglia, presentato in Figura 27, è dedicato alle operazioni 

di imbottigliamento. Dato che questo stato è attivato al termine di entrambe 

le operazioni di versamento dei reagenti, inizialmente si attendono ulteriori 30 

secondi prima di arrestare tutti i nastri in modo da terminare il trasporto della 

corretta quantità di reagenti. Successivamente, mediante una struttura di scelta 

a quattro vie, a seconda dell’ultimo valore utile di Ricetta memorizzato nella 

variabile interna Aux, si procede con l’aggiunta dell’additivo corretto e con l’im- 



PuliscieriempiA 

117 

not(guastoA) 

118 pulisciA; 

not(LivA)* 

GS119.t>=t#180s 

120 guastoA(S); 

luceA(S); 

true 

119 riempiA(S); 

121 

GS118.t>=t#60s 

LivA 

guastoA 

PuliscieriempiB 

122 

not(guastoB) 

123 pulisciB; 

not(LivB)* 

GS124.t>=t#180s 

125 guastoB(S); 

luceB(S); 

true 

Figura 26 Macrostati PuliscieriempiA e PuliscieriempiB. 

124 riempiB(S); 

126 

GS123.t>=t#60s 

LivB 

guastoB 

bottigliamento. Queste operazioni sono a questo livello mascherate all’interno 

dei macrostati NastroX, X= {1, 2, 3, 4}, raffigurati in Figura 28. Nei macrostati 

NastroX (X= {1, 2, 3, 4}), si procede con l’aggiunta dell’additivo X concorde 

con la ricetta che si sta producendo e si imbottiglia il composto ottenuto fino allo 

svuotamento del reattore X (condizione LivX≤5). Per l’imbottigliamento è necessario 

portare sotto l’elettrovalvola X una bottiglia, riempire la bottiglia versando 

il composto per 10 secondi e, in seguito, rimuovere la bottiglia dalla posizione di 

riempimento in modo da far spazio alla successiva bottiglia. Dato che il posizionamento 

della bottiglia avviene mediante la fotocellula FX che è sensibile anche 

alle paratie di contenimento, occorre distinguere le due situazioni (si rammenti 

che non è detto che lo spazio tra due paratie contenga sempre una bottiglia). Per 

fare ciò utilizziamo l’informazione che le paratie sono distanti 30 cm e che il nastro 

procede ad una velocità costante di 1 m/sec; quindi nel caso due attivazioni 

consecutive della fotocellula FX distino meno di 0.3 sec siamo in presenza di una 

bottiglia, mentre, nel caso in cui trascorrano almeno 0.3 sec tra due attivazioni 

consecutive della fotocellula FX, siamo in presenza di una paratia. 



Imbottiglia 

Aux=1 

Figura 27 Macrostato Imbottiglia. 

127 

Aux=2 

130 

GS127.t>=t#30s 

128 N1DX(R); N1SX(R); 

N2DX(R); N2SX(R); 




129 

true 

Aux=3 Aux=4 

Nastro1 Nastro2 Nastro3 Nastro4 

true true true true 



NastroX 

2X3 

2X1 

LivX>=100 

2X2 Nastro(S); 

2X4 

FX 

ApriX; 

2X3 Nastro(S); 

not(FX) 

FX*(GS2X4.t>=t#0.3s) 

2X2 

Figura 28 Macrostato NastroX. 

2X5 

not(FX)*LivX>5 

FX*(GS2X4.t=t#10s 

2X7 Nastro; 

2X7 

not(FX)*LivX


Esercizi risolti 

Esercizio E7.6 

Si consideri la macchina di foratura a giostra descritta nel Paragrafo 7.4.1; si supponga 

che la presenza di un pezzo in una delle quattro stazioni di lavorazione sia 

da dedurre da solo sensore pezzoC (i sensori pezzoF, pezzoSB e pezzoSD sono 

assenti e la loro informazione deve essere ricostruita). Modificare in maniera opportuna 

il codice di controllo SFC. 

Soluzione 

Al fine di colmare la mancanza dei sensori pezzoF, pezzoSB e pezzoSD, vengono 

definite le variabili interne booleane virtF, virtSB e virtSD; quando la giostra 

viene movimentata, spostando di conseguenza i pezzi da una stazione all’altra, 

le variabili interne devono essere opportunamente aggiornate: viene attivato il 

segnale relativo alla postazione successiva se il pezzo è presente in quella attuale. 

Dato che nella stazione di carico i pezzi arrivano con cadenza irregolare, un 

pezzo da caricare potrebbe arrivare dopo il time out previsto: il sensore pezzoC 

segnalerebbe in questo caso un pezzo da caricare e non un pezzo già caricato. 

Occorre dunque definire una ulteriore variabile interna booleana (incarico) per 

memorizzare la presenza di un pezzo caricato nella prima stazione. 

In Figura 1 è riportato il diagramma SFC principale: è possibile notare che 

inizialmente le variabili interne vengono inizializzate al valore false per indicare 

che nessun pezzo è presente nella macchina. Ad ogni giro di giostra le variabili 

interne vengono aggiornate in ordine inverso rispetto alla locazione della stazione 

(partendo quindi da scarico pezzi difettosi e arrivando alla stazione di foratura) in 

modo da non corrompere l’informazione relativa alla presenza dei pezzi. Si noti 

inoltre come ad ogni ciclo si rimandi allo stato dummy 2 per evitare di inizializzare 

le variabili ad ogni ciclo di lavoro. 

Nelle Figure 2 e 3 sono raffigurati i macrostati Lavorazione Misura e scarico 

buoni, Carico e Scarico difettosi e il diagramma SFC figlio Riscalda: si noti come 

vengano utilizzate le variabili interne virtF, virtSB e virtSD per segnalare la presenza 

di un pezzo nella stazione corrispondente. Inoltre, in seguito al caricamento 

di un pezzo, viene settata la variabile ausiliaria incarico altrimenti resettata. 



Carico 

1 

2 

3 

2 

true 

start 

Lavorazione 

Action(P): 

incarica(R); 

virtF(R); 

virtSB(R); 

virtSD(R); 

end_action; 

Misura e 

scarico 

buoni 

true 

Action(P): 

virtSD:=virtSB; 

virtSB:=virtF; 

virtF:=incarico; 

end_action; 

RotG; 

PosLav 

Figura 1 Diagramma SFC relativo all’Esercizio E7.6. 

Scarico 

difettosi 



201 

virtF not virtF 


Gstart(Riscalda); 

end_action; 

temp>=200 

203 

Macrostato 

Lavorazione Misura e scarico buoni 

204 

virtF not virtF 

205 ROT(S); 

FORA(S); 

206 

207 

208 

FCTGIU 

true 

GS206.T>=t#2s 

FORA(R); 

FCTSU 

true 

ROT(R); 

Action(P): 

Gkill(Riscalda); 

end_action; 

209 

300 

true 

S 

210 

301 

virtSB not virtSB 

302 Mis; 

GS302.T>=t#20s 

true 

303 

true 

304 

not virtSB virtSB 

Figura 2 Macrostato Lavorazione Misura e scarico buoni. 

307 

305 

not Ris Ris 

306 EVB(P); 

SCB 



Macrostato Carico 

101 

pezzoC (not pezzoC)* 

(GS101.T>=t#25s) 

102 pistoC; 

incarico(S); 104 incarico(R); 

103 

FCCA 

FCCI 

105 

Child: Riscalda 

501 

502 

501 

heat; 

temp>=202 

temp

Soluzione degli esercizi del Capitolo 7 - Ateneonline

Create successful ePaper yourself

Delete template?

Save as template?