Manuale di Utilizzo di

MultiProg wt
Prof.Ing.Salvatore Cavalieri
 Contents

1. ESEMPIO......................................................................................................................................................2

1.1. DESCRIZIONE DEL PROBLEMA.................................................................................................................2

1.2. COMPONENTI PER IL CONTROLLO...................................................................................................... 2

1.3. VARIABILI........................................................................................................................................ 3

1.4. ALGORITMO DI CONTROLLO............................................................................................................. 4

1.5. ORGANIZZAZIONE IN TASK................................................................................................................ 4

2. MULTIPROG WT........................................................................................................................................6

2.1. PREDISPOZIONE DI UN NUOVO PROGETTO..........................................................................................6

2.1.1. CREAZIONE DEL NUOVO PROGETTO............................................................................................... 6

2.1.2. PREDISPORRE IL WORKSPACE PER IL CONTROLLO...........................................................................8

2.1.3. PREDISPORRE IL WORKSPACE PER LA CONVERSIONE.....................................................................14

2.1.4. STATO FINALE DEL PROGETTO..................................................................................................... 15

2.2. NOZIONI UTILI............................................................................................................................... 15

2.2.1. CONTATTI, COIL E BLOCCHI FUNZIONALI......................................................................................15

2.3. DEFINIZIONE DELLE VARIABILI........................................................................................................ 19

2.4. CREAZIONE DELL’ALGORITMO “CONTROLLO”..................................................................................20

2.4.1. ALGORITMO PRINCIPALE IN SFC.................................................................................................. 20

2.4.2. DEFINIZIONE DELLE AZIONI E DELLE TRANSIZIONI.......................................................................21

3. Download ed esecuzione...............................................................................................................................22

Il presente manuale si basa su una tesina svolta dallo studente Simone Massaro, al quale
vanno i miei ringraziamenti.

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 1
1. Esempio
1.1. Descrizione del Problema
L’applicazione d’esempio che realizzeremo, sarà un semplice
miscelatore automatico per due liquidi.

Due valvole determinano l’afflusso dei due liquidi A e B all’interno di un

miscelatore. Una volta aggiunti i liquidi nelle dovute proporzioni, si procederà
alla miscelazione degli stessi attraverso un’elica connessa ad un motore.
Successivamente il contenuto del serbatoio del miscelatore sarà svuotato
attraverso una valvola d’uscita.

1.2. Componenti per il controllo

Al fine di realizzare l’algoritmo di controllo useremo:

 Una valvola digitale per il controllo dell’immissione del liquido A

nel miscelatore.

 Una valvola digitale per il controllo dell’immissione del liquido B

nel miscelatore.

 Un sensore analogico per misurare il livello all’interno del

miscelatore.

 Un motore con elica per il mescolamento dei due liquidi.

 Una valvola digitale per lo svuotamento del miscelatore

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 2
1.3. Variabili
Per rappresentare lo stato dei componenti necessari a realizzare
l’algoritmo di controllo, saranno utilizzate le seguenti variabili:

 valv_comp_A : è di tipo booleano; è vera quando la valvola A è

aperta. Il suo stato verrà visualizzato sul bit 0 del rack 0 di uscita (AT
%QX0.0).

 valv_comp_B : è di tipo booleano; è vera quando la valvola B è

aperta. Il suo stato verrà visualizzato sul bit 1 del rack 0 di uscita (AT
%QX0.1).

 motore : è di tipo booleano; è vera quando il motore è acceso. Il suo

stato verrà visualizzato sul bit 2 del rack 0 di uscita (AT %QX0.2).

 valv_uscita : è di tipo booleano; è vera quando la valvola d’uscita è

aperta. Il suo stato verrà visualizzato sul bit 3 del rack 0 di uscita (AT
%QX0.3).

 level : è di tipo intero senza segno; indica il livello all’interno del

serbatoio.

 rack0: è di tipo byte; indicherà lo stato di tutti e 8 i bit del rack 0 di

ingresso (AT %IB0). Il suo stato sarà utilizzato per codificare il livello. Il
bit 0 verrà interpretato come il meno significativo, ed il bit 7 come il più
significativo.

1.4. Algoritmo di controllo

Il miscelatore automatico eseguirà in modo ciclico il seguente
algoritmo di controllo:

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 3
 1) Apri la valvola del componente A

2) Quando il livello del serbatoio è 63 litri (in binario 00111111), chiudi

la valvola A ed apri la valvola del componente B.

3) Quando il livello del serbatoio è 127 litri (in binario 01111111),

chiudi la valvola B

4) Accendi il motore per 10 secondi per mescolare A e B

5) Apri la valvola di svuotamento del serbatoio

6) Quando il livello del serbatoio giunge a 0 riprendi dal punto (1)

1.5. Organizzazione in task

Il programma sarà organizzato in due task che eseguiranno in
parallelo ed in modo ciclico.

Il primo task si occuperà semplicemente di effettuare una conversione

inerente il livello del serbatoio: tale livello va infatti convertito dalla
rappresentazione binaria del rack 0 di ingresso, ad una più comoda
rappresentazione intera. Questa conversione può essere effettuata grazie a
semplici blocchi funzionali in LADDER.

Il secondo task si occuperà di implementare l’algoritmo di controllo

vero e proprio. L’algoritmo di controllo è intrinsecamente organizzato in
“passi” logici, durante i quali si compiono delle semplici operazioni. Le
transizioni da un passo all’altro sono governate da semplici condizioni
logiche (confronti sul livello e su timer). L’algoritmo va ripetuto all’infinito.

Proprio per queste sue caratteristiche l’algoritmo si presta ad essere

implementato attraverso l’uso del linguaggio SFC (Sequential Flow Chart).

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 4
Ognuno dei passi dell’algoritmo avrà un corrispondente step all’interno di un
diagramma SFC. Ognuno degli step compirà delle azioni. Il passaggio da
uno step al successivo avverrà attraverso transizioni SFC.

Le azioni da compiere durante ognuno degli step consistono in

apertura e chiusura di valvole ed interruttori, e si prestano per tanto ad
essere realizzate attraverso il linguaggio LADDER con contatti e coil. Le
transizioni saranno realizzate grazie a dei semplici blocchi logici con il
linguaggio LADDER.

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 5
2. Multiprog wt
2.1. Predispozione di un nuovo progetto
2.1.1. Creazione del nuovo progetto
Lanciare Multiprog wt e creare un nuovo progetto scegliendo l'opzione
“Template 16 Bit Simulation”, come mostrato in figura:

Verrà creato un progetto di default come il precedente: il progetto

contiene svariati elementi: librerie, tipi di dati, POU (Program Organization
Unit) e risorse Hardware. Le risorse hardware contengono per default una

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 6
configurazione che fa riferimento ad un simulatore di PLC, sul quale faremo
girare dei Tasks.

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 7
 Multiprog wt crea per default alcune cose delle quali noi non
necessitiamo e che vanno per tanto rimosse. Come prima cosa occorre
cancellare le POUs ed i Task ad esse relativi, che vengono creati in
automatico. Rimuovere dal progetto i seguenti rami:
Logical POUs->untitle*

Physical Hardware->CONFIGURATION_IPC->SIMULATION->Tasks->DEFAULT

2.1.2. Predisporre il workspace per il controllo

Come prima cosa occorre predisporre un workspace all’interno del
quale scriveremo il programma. Bisogna successivamente creare una
istanza del programma ed eseguirla in modo ciclico nel contesto di un task.

Iniziamo con il creare il workspace per il programma. Premere il tasto

destro su “Logical POUs” nel progetto, e scegliere “insert”.

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 8
 Un dialog consentirà di specificare i parametri della nuova Program
Organizzation Unit: il nome, il tipo ed il linguaggio della POU. Specificare il
nome “controllo”, scegliere il tipo “program” ed il linguaggio SFC (attenzione:
la figura precedente riporta un differente nome di programma e un differente
linguaggio).

Accertarsi che il tipo di PLC e di processore target sia <indipendent>

per assicurare un corretto funzionamento della simulazione. Notare come
sia possibile usare uno qualunque dei linguaggi dello standard IEC 1131.3.

Riempiremo successivamente il workspace del programma. Creiamo

invece un task di tipo ciclico all’interno del quale eseguire una istanza del

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 9
programma. Premere il tasto destro su “Tasks” nel progetto e creare un
nuovo task ti tipo “cyclic” e di nome “task1”:

E’ possible specificare il periodo d’esecuzione del Task e del processo

Watch Dog che ne controlla il risveglio e la schedulazione. E’ possibile
specificare la priorità di esecuzione: 0 è la priorità massima possibile. E’
possibile specificare la dimensione della memoria da assegnare allo stack:
quest’opzione risulta importante solo nel caso in cui l’algoritmo di controllo
debba essere eseguito su PLC dotati di scarse risorse di memoria, ma non
ha molta rilevanza nel nostro caso, in cui il target è un PLC virtuale.

Lasciare tutto ai valori di default e premere il tasto OK

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 10
 Adesso bisogna creare un’istanza del programma “controllo” e bisogna
fare in modo che quest’istanza sia eseguita all’interno del task ciclico
appena creato. Premere il tasto destro su “task1” nel progetto e selezionare
“insert” per inserire una nuova istanza all’interno di task:

Come prima cosa occorre specificare il tipo di istanza: selezionare

“program”. Adesso occorre dare un nome all’istanza: scrivere “istance1”
nell’apposita casella di testo. Come ultima cosa occorre selezionare un
programma fra quelli creati, in modo da creare un’istanza dello stesso: nel
nostro esempio noi creeremo un’istanza dell’algoritmo “controllo”.

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 11
 Riepilogando abbiamo creato un nuovo progetto Multiprog usando un
template per le simulazioni (“16 Bit Simulation”). Abbiamo creato una nuova
POU (“controllo”) che utilizza il linguaggio SFC e che riempiremo
successivamente. Abbiamo quindi creato una istanza di questa POU
(“instance1”) che verrà eseguita nel contesto di un task di tipo ciclico
(“task1”). Alla fine il progetto avrà la seguente struttura:

Occorre adesso premere il tasto destro su:

physical Hardware->Configuration_IPC->Simulation

Selezionando “settings” comparirà il seguente dialog:

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 12
 Questo dialog presenta numerose opzioni che consentono di scegliere
il dispositivo che riceverà il programma. Esso consente di stabilire su quale
porta è connesso il dispositivo oltre a tutti i parametri di comunicazione con il
dispositivo stesso. Tutte queste opzioni nel nostro caso risultano disabilitate
perché abbiamo costruito un progetto utilizzando un template per un PLC
virtuale, non fisicamente connesso al nostro computer.

Risulta possibile scegliere come target uno fra 2 PLC simulati.

Selezionare “simulatore1” per eseguire sul primo PLC virtuale.

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 13
 L’opzione “generate bootproject durino compile” consente di generare
il progetto per il bootstrap durante la fase di compilazione invece che
durante la fase di download.

All’interno del dialog ci sono altre opzioni inerenti le variabili. Ad ogni

variabile è possibile associare uno o entrambe gli attributi CSV e PDD.
Questi attributi sono inerenti alla comunicazione ed allo scambio delle
variabili fra il Multiprog wt ed altre applicazioni: il loro significato esula dalla
trattazione corrente e non ha alcuna rilevanza al fine della nostra
applicazione d’esempio. E’ sufficiente lasciare tutte le opzioni impostare hai
valori di default del dialog e tutto funzionerà correttamente.

2.1.3. Predisporre il workspace per la

conversione
Fino ad adesso abbiamo predisposto un workspace all’interno del
quale faremo girare il programma che realizzerà l’algoritmo di controllo.
Dobbiamo adesso predisporre un workspace all’interno del quale faremo
girare il semplicissimo programma per la conversione del “livello” da binario
ad intero. Riempiremo il workspace solo in seguito.

Premere il tasto destro su “Logical POUs” nel progetto, e scegliere

“insert”. Un dialog consentirà di specificare i parametri della nuova Program
Organizzation Unit: il nome, il tipo ed il linguaggio della POU. Specificare il
nome “conversione”, scegliere il tipo “program” ed il linguaggio LADDER.
Questa volta, infatti, il programma è molto semplice e non presenta step:
sarà costituito semplicemente da un blocco funzionale LADDER che
effettuerà la conversione binaria-intera.

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 14
 Occorre anche questa volta creare un’istanza del programma.
Quest’istanza sarà eseguita nel contesto dello stesso task ciclico
precedentemente creato. Occorre ripetere gli stessi passi illustrati
precedentemente per il task relativo al controllo, ma questa volta bisogna
stanziare il programma “conversione” invece del programma “controllo”.

2.1.4. Stato finale del progetto

Alla fine di tutto il processo di predisposizione vedremo un progetto
come il seguente: Dobbiamo adesso riempire i workspace con i programmi
per il controllo e per la conversione.

2.2. Nozioni Utili

2.2.1. Contatti, coil e blocchi funzionali
Per creare una rete contact-coil come basta premere sul display e
posizionare il cursore nel punto in cui si vuole aggiungere la rete.
Successivamente occorre premere sull’apposita icona:

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 15
 Per creare un blocco funzionale (come ad esempio il blocco ADD),
occorre innanzitutto premere sul pulsante con la bacchetta magica e fare
comparire la finestra wizard: da questa finestra è poi possibile selezionare
una categoria di blocchi funzionali, e scegliere un blocco specifico. Per
specificare le variabili associate ai contatti ed ai coil occorre premere il tasto
del mouse sul componente. Attraverso la finestra di dialog e possibile
scegliere una delle sottocategorie disponibili (ad esempio il coil di set, o di
reset ecc..) per il componente. Il nome della variabile va specificato
all’interno dell’apposita casella di testo, o selezionato fra quelle già
dichiarate: inutile dire che la variabile associata ad un contatto/coil deve
necessariamente essere di tipo booleano. Per ognuna delle variabili nel
nostro esempio occorre specificare che lo “scope” della variabile è “global”,
ovvero che la visibilità della variabile è globale. Occorre inoltre premere il
tasto “property” per settare alcune proprietà avanzate.

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 16
 Per ognuna delle variabili è possibile specificare un valore iniziale, ed
una locazione fisica sul rack del PLC, attraverso la casella AT.

Ad esempio una variabile booleana che corrisponde al terzo bit del

rack numero 2 del PLC viene dichiarata specificando dentro AT la seguente:
%IX3.2

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 17
Corso di Informatica Industriale
Prof. Ing.Salvatore Cavalieri Page 18
 Le opzioni CSV e PDD non hanno influenza nel contesto della nostra
applicazione in quanto concernono la comunicazione fra Multiprog wt ed
altre applicazioni: esse possono pertanto essere lasciate disabilitate.

Oltre a poter specificare le variabili, al momento del loro utilizzo nei

contact e nei coil, è possibile specificare le variabili utilizzando lo standard
IEC 1131.3: questa è la soluzione che noi adotteremo per definire in modo
globale le nostre variabili.

2.3. Definizione delle variabili

Premere su “global_variables” nell’albero del progetto. Digitare il
seguente codice:

La clausola “AT” è stata utilizzata per specificare la corrispondenza

con ingressi ed uscite sui rack..

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 19
 La variabile “level” non presenta corrispondenze sul rack: essa infatti
sarà impostata con il valore convertito della variabile rack0, la quale per
l’appunto rappresenta il contenuto del rack0, che è proprio la codifica del
livello nel miscelatore.

Le variabili così create andranno successivamente associate ai

corrispondenti contact/coil/blocchi come illustrato nel seguito.

2.4. Creazione dell’algoritmo “controllo”

2.4.1. Algoritmo principale in SFC
All’interno della POU “Controllo” occorre creare un insieme di step
SFC che rispecchiano i passi dell’algoritmo di controllo. Utilizzare l’apposito
tasto per creare 4 step.

Premere sugli step e specificarne i nomi come nella figura successiva

Notare come sia possibile specificare quando uno step è iniziale, finale, o
intermedio (in quest’ultimo caso basta non specificare niente):

Premere il tasto destro sulle azioni associate agli step e cambiarne i

nomi, in accordo alla figura successiva. Specificare un “Qualifier” di tipo “N”,
che indica che l’azione verrà eseguita per tutto il tempo in cui lo step
corrispondente è attivo.

Alla fine il programma SFC dovrà apparire simile a quello nella figura
soprastante. Durante il primo step1 apriremo la valvola del componente A.
La transizione T001 scatterà quando il sensore di livello segnalerà 63 litri.
Durante lo step2 immetteremo il componente B. La transizione T002
scatterà quando il sensore di livello segnalerà 127 litri. Durante lo step3 si
procederà all’accensione del motore per il mescolamento. La transizione

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 20
T003 scatterà in modo temporizzato dopo 10 secondi di mescolamento.
Durante lo step4 si procederà allo svuotamento del serbatoio. La transizione
T004 scatterà quando il sensore di livello segnala che il serbatoio è vuoto.

2.4.2. Definizione delle Azioni e delle transizioni

Occorre adesso premere su ogni step e su ogni transizione per inserire
il corrispondente codice. Occorre ancora una volta specificare il tipo di
linguaggio che si vuole adottare per descrivere l’azione o la transizione. In
particolare si è scelto di utilizzare il Ladder (LD).

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 21
3. Download ed esecuzione
Occorre a questo punto effettuare il download del codice che abbiamo
creato su di un PLC, che nel nostro caso è “virtuale”, ovvero non fisicamente
presente come hardware. A tale scopo occorre innanzitutto premere
sull’apposito pulsante:

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 22
Corso di Informatica Industriale
Prof. Ing.Salvatore Cavalieri Page 23
 Accanto al pulsante di download si trova anche il pulsante che attiva la
modalità debug, che può essere utilizzata dopo il download, per monitorare
l’algoritmo di controllo.

Premere il tasto Download. Comparirà un nuovo dialog con alcune

opzioni.

Le opzioni riguardano la comunicazione fra Multiprog wt ed altre

applicazioni: esse non hanno influenza per la nostra applicazione di esempio
e non saranno pertanto trattate in questo contesto.

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 24
 Premere nuovamente download. Nel dialog che segue specificare se
si vuole una partenza a freddo (cold) o a caldo (warm). La partenza a freddo
inizializza tutte le variabili. La partenza a caldo inizializza solo le variabili che
non sono state marcate come “retain”. La partenza hot non reinizializza
nessuna variabile.

L’immagine sottostante mostra un momento dell’esecuzione del

programma:

La luce “run” indica che il PLC sta eseguendo il programma. Per

ognuno dei rack in alto è indicato il numero ed in basso il tipo (IN/OUT). I
rack di ingresso usano luci verdi mentre quelli di uscita usano luci rosse.
Premendo sulle luci del rack 0 di ingresso è possibile settare il livello nel
miscelatore, e controllare pertanto l’algoritmo: l’immagine mostra che il rack0
è stato settato a 00111111, che convertito in intero corrisponde a 63. Poiché
il livello ha raggiunto il valore 63, la valvola B è aperta (bit 1 del rack 0 di
uscita) , mentre la valvola A (bit 0 ) e la valvola di uscita (bit 3) sono chiuse.
Il motore è spento (bit 2 del rack 0 di uscita).

Corso di Informatica Industriale

Prof. Ing.Salvatore Cavalieri Page 25