Rifilato: in alto: 61,5 mm in basso: 61,5 mm a sinistra: 43,5 mm a destra: 43,5 mm
Controller
Descrizione Istruzioni di programmazione CMXR FTL di base
Descrizione 560 319 it 0909a [748 989]
Festo GDCP-CMXR-SW-IT it 0909a 3
Edizione _____________________________________________________ 0909a
Definizione _________________________________________ GDCP-CMXR-SW-IT
Numero di ordinazione ________________________________________ 560 319
Festo AG & Co KG., D-73734 Esslingen, 2009
Internet: http://www.festo.com
E-Mail: [email protected]
È vietata la riproduzione, distribuzione e diffusione a terzi, nonché l'uso arbitrario, totale o parziale del contenuto della presente documentazione senza la preventiva autorizzazione scritta della Festo. Qualsiasi infrazione comporta il risarcimento di danni. Tutti i diritti riservati, ivi compreso il diritto di deposito brevetti, modelli registrati o di design.
4 Festo GDCP-CMXR-SW-IT it 0909a
Indice delle revisioni
Autore:
Titolo del manuale: GDCP-CMXR-SW-DE
Nome del file:
Luogo di memorizzazione del file:
N. prog. Descrizione Indice di revisione Data della modifica
001 Stesura 0805NH 25.06.2008
002 Adattamento alla versione 1.20 0909a 25.08.2009
INDICE
Festo GDCP-CMXR-SW-IT it 0909a 5
INDICE
1. Introduzione ........................................................................................................ 12
2. Avvertenze di sicurezza ....................................................................................... 13
2.1 Utilizzo della documentazione ........................................................................... 13
2.2 Impiego per gli usi consentiti ............................................................................. 13
2.3 Personale qualificato ......................................................................................... 14
2.4 Avvertenze di sicurezza per i prodotti ................................................................ 14
2.5 Avvertenze di sicurezza per questo manuale ...................................................... 14
2.6 Istruzioni di sicurezza per il prodotto descritto .................................................. 15
3. Elaborazione del programma .............................................................................. 16
3.1 Generalità .......................................................................................................... 16
3.2 Interprete .......................................................................................................... 16
3.3 Avvio del programma ......................................................................................... 16
3.4 Calcolo preliminare dei record ........................................................................... 16
3.5 Struttura dei programmi .................................................................................... 18
3.6 Progetti FTL ....................................................................................................... 18
3.6.1 Progetto FTL globale ........................................................................... 19
3.7 File di programma FTL “tip” ............................................................................... 19
3.7.1 Programmi globali del progetto .......................................................... 20
3.8 File di dati FTL “<Nome>.tid” ............................................................................... 20
3.8.1 Dati locali del programma .................................................................. 20
3.8.2 Dati globali del progetto ..................................................................... 21
3.8.3 Dati globali del sistema ...................................................................... 21
3.8.4 Istanziazione di variabili ..................................................................... 22
4. Struttura del linguaggio ...................................................................................... 24
4.1 Formattazione ................................................................................................... 24
4.2 Identificatori ...................................................................................................... 24
4.3 Parole chiave ..................................................................................................... 24
4.4 Costanti numeriche ............................................................................................ 25
4.5 Catene di caratteri ............................................................................................. 25
4.6 Operatori e separatori ....................................................................................... 26
4.6.1 Operatori aritmetici ............................................................................ 26
4.6.2 Operatori logici .................................................................................. 26
4.6.3 Operatori di comparazione ................................................................. 26
4.6.4 Altri operatori ..................................................................................... 27
4.6.5 Separatori .......................................................................................... 27
INDICE
6 Festo GDCP-CMXR-SW-IT it 0909a
5. Tipi di dati base ................................................................................................... 28
5.1 Tipo di dati booleano (BOOL) ............................................................................. 29
5.2 Tipi di numeri interi, tipo di dati REAL, tipi di schema di codifica a bit ................ 30
5.3 Parentesi ........................................................................................................... 30
5.4 Catene di caratteri (STRING) .............................................................................. 31
5.5 Tipi di dati strutturati ......................................................................................... 31
5.6 Array.................................................................................................................. 31
5.6.1 Inizializzazione degli array .................................................................. 34
5.6.2 Definizione dei limiti degli array con LOW e HIGH ............................... 34
5.7 Variabili di riferimento (mapping) ...................................................................... 36
5.7.1 Dichiarazione di variabili di riferimento, <MAPTO> ............................... 37
5.7.2 Collegamento di variabili di riferimento, <MAP> ................................... 37
5.7.3 Controllo delle variabili di riferimento, <IS_MAPPED> .......................... 37
5.8 Istruzione DO ..................................................................................................... 39
5.8.1 Comportamento nell'area di approssimazione .................................... 41
6. Dichiarazioni di variabili ..................................................................................... 42
6.1 Inizializzazione .................................................................................................. 42
7. Espressioni ......................................................................................................... 43
7.1 Sequenza di esecuzione nelle espressioni ......................................................... 43
8. Comando a programma ....................................................................................... 44
8.1 Istruzioni ........................................................................................................... 44
8.2 Assegnazione del valore <:=>............................................................................. 44
8.3 Condizioni ......................................................................................................... 44
8.4 Diramazione <IF…THEN> ..................................................................................... 45
8.5 Comandi di salto ................................................................................................ 46
8.5.1 Marcatura di salto <LABEL> ................................................................. 47
8.5.2 Salto condizionato <IF…GOTO> ............................................................ 47
8.5.3 Salto assoluto <GOTO> ........................................................................ 48
8.6 Cicli ................................................................................................................... 48
8.6.1 Istruzione WHILE <WHILE> ................................................................... 48
8.6.2 Istruzione LOOP <LOOP> ...................................................................... 49
8.7 Sottoprogrammi ................................................................................................ 50
8.7.1 Richiamo di un sottoprogramma <CALL> .............................................. 51
8.7.2 Ritorno al programma <RETURN> ......................................................... 52
8.8 Programmi paralleli ........................................................................................... 53
8.8.1 Avvio di un programma parallelo <RUN> .............................................. 54
8.8.2 Termine di un programma parallelo <KILL> .......................................... 54
8.9 Modifiche del calcolo preliminare dei record ...................................................... 54
INDICE
Festo GDCP-CMXR-SW-IT it 0909a 7
8.9.1 Istruzione WAIT con indicazione del tempo <WaitTime> ....................... 54
8.9.2 Istruzione WAIT con condizione <WAIT> ............................................... 56
8.9.3 Istruzione WaitOnPath con indicazione del tempo <WaitOnPath> ........ 58
8.9.4 Istruzione WaitOnPos con indicazione del tempo <WaitOnPos> ........... 60
8.10 Inserimento di commenti <//> ............................................................................. 61
8.11 Disattivazione di una riga di programma <##> .................................................... 61
9. Istruzioni di movimento ...................................................................................... 63
9.1 Descrizione della posizione ............................................................................... 63
9.1.1 Posizione dell'asse ............................................................................. 64
9.1.2 Posizione cartesiana .......................................................................... 66
9.2 Movimento point-to-point <Ptp> ......................................................................... 67
9.3 Movimento point-to-point relativo <PtpRel> ........................................................ 70
9.4 Movimento di un asse, <MoveAxisPtp>, <MoveAxisCart> ...................................... 72
9.5 Movimento lineare <Lin> ..................................................................................... 74
9.6 Movimento lineare relativo <LinRel> ................................................................... 76
9.7 Movimento circolare con punto di appoggio ...................................................... 78
9.7.1 Funzionamento .................................................................................. 78
9.7.2 Definizione del piano .......................................................................... 79
9.7.3 Istruzione circolare con punto di appoggio <CircIp> ............................. 81
9.7.4 Istruzione circolare con punto di appoggio, accostamento PTP <PtpToCircIp> ...................................................................................... 83
9.7.5 Istruzione circolare con punto di appoggio, accostamento Lin <LinToCircIp> ....................................................................................... 85
9.8 Arresto del movimento <StopMove> ................................................................... 86
9.9 Arresto del programma <StopProgram> .............................................................. 87
10. Istruzioni dinamiche ........................................................................................... 88
10.1 Limitazione autom. della dinamica, limitatore dinamico ..................................... 89
10.2 Velocità <Vel> ..................................................................................................... 90
10.3 Accelerazione <Acc> ............................................................................................ 91
10.4 Strappo <Jerk> .................................................................................................... 92
10.5 Override ............................................................................................................ 94
10.5.1 Override dall'unità di comando manuale <Ovr>.................................... 94
10.5.2 Override dinamico <DynOvr> ............................................................... 96
10.6 Rampe di accelerazione ..................................................................................... 97
10.6.1 Impostazione delle forme di rampa <Ramp> ........................................ 98
10.7 Attivazione della velocità di avanzamento costante <VconstOn> ........................ 99
10.8 Disattivazione della velocità di avanzamento costante <VconstOff> .................. 101
INDICE
8 Festo GDCP-CMXR-SW-IT it 0909a
11. Istruzioni di approssimazione ........................................................................... 102
11.1 Segmenti nulli ................................................................................................. 103
11.2 Campo limite ................................................................................................... 104
11.3 Approssimazione della velocità ....................................................................... 105
11.3.1 Con fattore percentuale <OvlVel> ....................................................... 105
11.4 Approssimazione geometrica ........................................................................... 107
11.4.1 Approssimazione degli assi X, Y e Z <OvlCart> ................................... 107
12. Sistemi di riferimento (spostamento del punto zero) ........................................ 109
12.1 Riferimento del sistema di riferimento ............................................................. 109
12.2 Dati del sistema di riferimento ......................................................................... 110
12.3 Sistema di riferimento con valori diretti <SetRefSys> ........................................ 111
12.4 Sistema di riferimento con 3 punti <SetRefSys3P> ............................................ 112
12.5 Sistema di riferimento globale <SetRefSysWorld> ............................................. 114
12.6 Esempio .......................................................................................................... 114
13. Definizione del riferimento di una cinematica ................................................... 116
13.1 Corsa di riferimento <RefAxis> .......................................................................... 116
13.2 Corsa di riferimento asincrona <RefAxisAsync> ................................................. 118
13.3 Attesa della fine della corsa di riferimento <WaitRefFinished> .......................... 120
13.4 Interrogazione dello stato di un asse <IsAxisReferenced> ................................. 121
14. Utensili ............................................................................................................. 122
14.1 Dati dell'utensile ............................................................................................. 122
14.1.1 Dati del vettore TCP .......................................................................... 122
14.2 Attivazione dei dati dell'utensile <Tool> ............................................................ 125
14.2.1 Effetti dei dati TCP ............................................................................ 125
15. Interfaccia PROFIBUS ........................................................................................ 130
15.1 Indicazioni per l'elaborazione dei segnali ........................................................ 131
15.2 Ingressi e uscite booleani ................................................................................ 131
15.3 Variabili intere a 32 bit..................................................................................... 132
15.4 Posizioni .......................................................................................................... 133
15.5 Sistemi di riferimento ...................................................................................... 134
15.6 Arresto programmato <ProgHold> ..................................................................... 135
16. Sistema di segnalazione ................................................................................... 137
16.1 Testi dei messaggi ........................................................................................... 137
16.2 Informazione <SetInfo> ..................................................................................... 139
16.3 Avvertenza <SetWarning> ................................................................................. 140
INDICE
Festo GDCP-CMXR-SW-IT it 0909a 9
16.4 Messaggio di errore <SetError> ......................................................................... 141
17. Funzioni ............................................................................................................ 142
17.1 Lettura della posizione corrente <ReadActualPos> ............................................ 142
17.2 Lettura della posizione di arrivo <ReadTargetPos> ............................................ 143
17.3 Salvataggio permanente di un valore di posizione <SavePosition> .................... 144
17.4 Lettura dell'ora del sistema <Time> ................................................................... 144
17.5 Conversione dell'ora in testo <TimeToStr> ........................................................ 145
17.6 Seno <SIN>, <ASIN> ........................................................................................... 146
17.7 Coseno <COS>, <ACOS> ..................................................................................... 147
17.8 Tangente <TAN>, <ATAN> ................................................................................... 149
17.9 Cotangente <COT>, <ACOT> ................................................................................ 150
17.10 Arcotangente2 <ATAN2> ................................................................................... 151
17.11 Logaritmo <LN> ................................................................................................. 151
17.12 Esponente <EXP> .............................................................................................. 151
17.13 Valore assoluto <ABS> ...................................................................................... 152
17.14 Radice quadrata <SQRT> ................................................................................... 152
17.15 Spostamento dei bit <SHR>, <SHL> .................................................................... 153
17.16 Rotazione dei bit <ROR>, <ROL> ......................................................................... 154
17.17 Conversione di un valore in una stringa <STR> .................................................. 155
17.18 Conversione di un valore ASCII in un carattere <CHR> ....................................... 155
17.19 Conversione di un carattere in un valore ASCII <ORD> ....................................... 155
18. Moduli ............................................................................................................... 156
18.1 Funzioni ........................................................................................................... 157
18.2 Variabili ........................................................................................................... 157
18.3 Comportamento in fase di esecuzione ............................................................. 158
18.3.1 Parametro ovlEnable ........................................................................ 158
18.4 Modulo di ingresso digitale DIN ....................................................................... 159
18.4.1 Istanziazione .................................................................................... 159
18.4.2 Metodi ............................................................................................. 161
18.4.3 Attesa dello stato, metodo Wait / WaitN ........................................... 162
18.4.4 Lettura dello stato, metodo Read ..................................................... 162
18.4.5 Fronte ascendente, metodo RisingEdge ............................................ 162
18.4.6 Reset del fronte, metodo ResetRisingEdge ....................................... 163
18.5 Modulo di uscita digitale DOUT ........................................................................ 163
18.5.1 Istanziazione .................................................................................... 163
18.5.2 Variabili ............................................................................................ 165
18.5.3 Metodi ............................................................................................. 166
INDICE
10 Festo GDCP-CMXR-SW-IT it 0909a
18.5.4 Attesa dello stato, metodo Wait / WaitN ........................................... 167
18.5.5 Lettura dello stato, metodo Read ..................................................... 167
18.5.6 Fronte ascendente, metodo RisingEdge ............................................ 167
18.5.7 Reset del fronte, ResetRisingEdge .................................................... 168
18.5.8 Attivazione e reset, metodo Set / Reset ............................................ 168
18.5.9 Attivazione dell'uscita, metodo Write ............................................... 169
18.5.10 Impostazione dell'uscita per un determinato periodo, metodo Pulse ................................................................................... 169
18.6 Modulo di ingresso analogico AIN .................................................................... 170
18.6.1 Istanziazione .................................................................................... 170
18.6.2 Variabili ............................................................................................ 172
18.6.3 Metodi ............................................................................................. 172
18.6.4 Attesa finché il valore non è inferiore/superiore, metodo WaitLss, WaitGrt .................................................................. 173
18.6.5 Attesa finché il valore non è dentro/fuori dall'intervallo, metodo WaitIns, WaitOuts ................................................................ 174
18.6.6 Lettura del valore, metodo Read ....................................................... 174
18.7 Modulo di uscita analogico AOUT .................................................................... 175
18.7.1 Istanziazione .................................................................................... 175
18.7.2 Variabili ............................................................................................ 176
18.7.3 Metodi ............................................................................................. 177
18.7.4 Scrittura del valore di uscita, metodo Write ...................................... 178
18.7.5 Attesa finché il valore non è superiore/inferiore, metodo WaitLss, WaitGrt ............................................................................... 178
18.7.6 Attesa finché il valore non è dentro/fuori dall'intervallo, metodo WaitIns, WaitOuts ................................................................... 179
18.7.7 Lettura del valore di uscita, metodo Read ......................................... 179
18.8 Modulo orologio CLOCK ................................................................................... 180
18.8.1 Istanziazione .................................................................................... 180
18.8.2 Metodi ............................................................................................. 181
18.8.3 Avvio dell'orologio, metodo Start ..................................................... 182
18.8.4 Arresto dell'orologio, metodo Stop ................................................... 182
18.8.5 Reset dell'orologio, metodo Reset .................................................... 182
18.8.6 Lettura dell'orologio, metodo Read .................................................. 182
18.8.7 Conversione del valore di tempo in una stringa ................................ 183
18.9 Modulo encoder ENCODER .............................................................................. 184
18.9.1 Istanziazione .................................................................................... 184
18.9.2 Variabili ............................................................................................ 185
18.9.3 Metodi ............................................................................................. 185
18.9.4 Impostazione dell'encoder, metodo Set ........................................... 186
18.9.5 Lettura dell'encoder, metodo Read ................................................... 187
18.10 Modulo CANopen COPDEVICE .......................................................................... 187
18.10.1 Istanziazione .................................................................................... 188
INDICE
Festo GDCP-CMXR-SW-IT it 0909a 11
18.10.2 Metodi ............................................................................................. 188
18.10.3 Scrittura di SDO, metodo WriteSDO .................................................. 189
18.10.4 Lettura di SDO, metodo ReadSDOSigned .......................................... 189
18.10.5 Lettura di SDO, metodo ReadSDOUnsigned ...................................... 191
19. Segnali delle periferiche ................................................................................... 192
19.1 Utilizzo di ingressi e uscite digitali ................................................................... 192
19.2 Utilizzo di ingressi e uscite analogici ................................................................ 192
20. Esempi .............................................................................................................. 194
20.1 Arresto di movimenti ....................................................................................... 194
20.2 Utilizzo dei moduli di ingresso e di uscita ........................................................ 197
20.3 Controllo del calcolo preliminare dei record ..................................................... 198
20.4 Utilizzo delle pinze ........................................................................................... 199
20.4.1 Ventose ............................................................................................ 200
20.4.2 Pinze parallele pneumatiche ............................................................ 203
20.4.3 Unità oscillante di presa pneumatica ................................................ 206
20.5 Utilizzo dell'interfaccia PLC .............................................................................. 210
20.5.1 Definizione del compito .................................................................... 210
20.5.2 Interfaccia PLC.................................................................................. 210
20.5.3 Programma sequenziale ................................................................... 211
21. Struttura a menu delle istruzioni FTL ................................................................ 213
1. Introduzione
12 Festo GDCP-CMXR-SW-IT it 0909a
1. Introduzione Nel presente documento viene descritto il set di istruzioni FTL (Festo Teach Language) del
controller multiassiale CMXR di Festo con versione del software 1.20 o superiore. La pro-grammazione del controller CMXR avviene con l'unità di comando manuale CDSA-D1-VX o tramite il PlugIn CMXR nel Festo Configuration Tool (FCT).
Fig. 1.1 Controller multiassiale CMXR-C1 Festo Unità di comando manuale CDSA-D1-VX Festo
FTL è un linguaggio di programmazione con un set di istruzioni concepito per la stesura di programmi utente da parte dell'utilizzatore della macchina. La struttura semplificata di questo linguaggio consente di creare cicli di funzionamento della macchina semplici senza
che siano necessarie conoscenze approfondite di programmazione.
Il presente manuale è valido a partire dalla versione software 1.20 del CMXR. Questa è compatibile con la Software-Release 1.
2. Avvertenze di sicurezza
Festo GDCP-CMXR-SW-IT it 0909a 13
2. Avvertenze di sicurezza
2.1 Utilizzo della documentazione
Il presente documento è concepito per gli operatori e i programmatori di robot che lavorano con il sistema CMXR della Festo. È disponibile un'introduzione all'uso e alla programmazione. Si presuppone un addestramento corrispondente del personale.
2.2 Impiego per gli usi consentiti
Avvertenza
Il sistema CMXR Festo non è previsto per compiti di automazione rilevanti per la sicurezza (ad es.: arresto in caso di emergenza o monitoraggio di velocità ridotte).
Ai sensi della normativa EN-13849-1, il sistema CMXR Festo è conforme solo alla categoria B e non è quindi sufficiente per la realizzazione di funzioni di sicurezza per la protezione delle persone. Per compiti di automazione rilevanti per la sicurezza o per la sicurezza delle persone è necessario adottare ulteriori misure di sicurezza esterne in grado di garantire uno stato di esercizio sicuro del sistema intero anche in caso di errore.
La Festo non assume alcuna responsabilità per danni imputabili alla non osservanza delle indicazioni di pericolo riportate nelle presenti istruzioni d'uso.
Nota
Prima della messa in funzione è necessario leggere completamente le avvertenze di sicurezza riportate al capitolo 2.3 ss.
Nel caso in cui la documentazione in questa lingua non sia perfettamente comprensibile, contattare il fornitore e informarlo al riguardo.
Il funzionamento sicuro e a regola d'arte del sistema di comando presuppone un corretto
trasporto, magazzinaggio, assemblaggio e installazione come pure un comando e una manutenzione accurati.
2. Avvertenze di sicurezza
14 Festo GDCP-CMXR-SW-IT it 0909a
2.3 Personale qualificato
Nota
Per gli interventi sugli impianti elettrici impiegare solo personale addestrato e qualificato.
2.4 Avvertenze di sicurezza per i prodotti
Avvertenza
PERICOLO !
Smaltire le batterie nel rispetto delle normative per i rifiuti speciali.
Sebbene le batterie abbiano una tensione bassa, in caso di corto-circuito possono rilasciare una corrente sufficiente per causare l'accensione di materiali infiammabili. Per tale motivo non devono essere smaltite insieme a materiali conduttivi (come ad es. trucioli metallici, lana di acciaio imbrattata con olio, ecc.).
ESD
Componenti sensibili alle correnti elettrostatiche: la manipolazione impropria di tali componenti ne può causare il danneggiamento.
Avvertenza
PERICOLO !
Movimenti pericolosi!
Pericolo di morte, gravi lesioni personali o danni materiali dovuti ai movimenti accidentali degli assi!
2.5 Avvertenze di sicurezza per questo manuale
Avvertenza
PERICOLO !
La non osservanza può comportare gravi danni alle cose e alle persone.
Attenzione
La non osservanza può comportare gravi danni materiali.
2. Avvertenze di sicurezza
Festo GDCP-CMXR-SW-IT it 0909a 15
2.6 Istruzioni di sicurezza per il prodotto descritto
Avvertenza
Pericolo!
Pericolo di morte a causa dei circuiti di arresto d'emergenza insufficienti!
I circuiti di arresto d'emergenza devono essere attivi e raggiungibili in tutti i modi operativi dell'impianto. Lo sblocco del circuito di arresto d'emergenza non deve provocare un riavvio incontrollato dell'impianto!
Controllare il circuito di emergenza prima dell'inserimento!
Avvertenza
PERICOLO !
Pericolo per le persone e le cose!
Testare ogni nuovo programma prima di mettere in funzione l'impianto!
Avvertenza
PERICOLO !
Eventuali trasformazioni e modifiche possono pregiudicare la sicurezza del sistema!
Ne possono conseguire gravi danni alle persone, alle cose o all'ambiente. Eventuali trasformazioni o modifiche dell'impianto con componenti di equipaggiamento di altri produttori devono pertanto essere approvate dalla Festo.
Avvertenza
PERICOLO !
Tensione elettrica pericolosa!
Salvo diversamente indicato, i lavori di manutenzione vanno ese-guiti esclusivamente ad impianto disattivato! L'impianto deve essere protetto contro una riaccensione non autorizzata o accidentale.
Gli interventi di misurazione o verifica sull'impianto eventualmente necessari devono essere eseguiti da elettricisti specializzati.
Attenzione
Utilizzare solo parti di ricambio approvate dalla Festo.
3. Elaborazione del programma
16 Festo GDCP-CMXR-SW-IT it 0909a
3. Elaborazione del programma
3.1 Generalità
FTL è l'acronimo di Festo Teach Language. FTL è un linguaggio di programmazione
orientato al movimento e serve per la programmazione dei controller CMXR.
Come linguaggio di programmazione per robotica e sistemi di manipolazione, FTL dispone di potenti funzionalità che sono tuttavia semplici da imparare e utilizzare. Ciò permette all'utilizzatore di eseguire una programmazione specifica per la propria applicazione. Le istruzioni sono basate sulla lingua inglese.
3.2 Interprete
I programmi FTL non vengono compilati, bensì elaborati da un interprete. L'interprete carica in memoria i programmi in maniera strutturata all'inizio del lavoro, per poterli poi elaborare in modo ottimale. Questa procedura richiede un breve tempo di reazione, che
varia in base alla lunghezza del programma. Per tale motivo è consigliabile caricare il programma prima dell'avvio in modo da velocizzare la fase di avvio del programma.
3.3 Avvio del programma
Per avviare un programma è necessario caricarlo nel progetto corrispondente. Il carica-mento può avvenire con l'unità di comando manuale o tramite un'unità di comando esterna attraverso un'interfaccia di controllo.
Nota
È possibile caricare solo un progetto dell'utente. Inoltre è sempre caricato il progetto di sistema globale.
L'esecuzione del programma ha inizio dopo il segnale di start, sempre nella posizione attuale del puntatore del programma.
Quando il puntatore raggiunge l'ultima riga del programma sequenziale, il programma viene terminato ma rimane caricato. Se durante la sequenza sono stati avviati programmi paralleli, il programma principale rimane attivo finché questi programmi non sono terminati.
3.4 Calcolo preliminare dei record
Per ottenere una rapida elaborazione del programma, l'interprete calcola anticipatamente un certo numero di istruzioni di movimento. Il calcolo preliminare avviene durante l'esercizio, simultaneamente all'esecuzione del programma, e viene gestito a livello del sistema. Le dimensioni del calcolo preliminare dei record, cioè il numero di istruzioni di movimento che vengono calcolate in anticipo, sono memorizzate nel sistema.
3. Elaborazione del programma
Festo GDCP-CMXR-SW-IT it 0909a 17
Nota
Il calcolo preliminare dei record fa riferimento alle istruzioni di movimento. Altre istruzioni che si trovano tra le istruzioni di movimento, come ad es. la modifica di valori dinamici o l'elaborazione di variabili, non vengono considerate.
In questo calcolo preliminare dei record, le istruzioni FTL vengono decodificate e messe a disposizione per l'ulteriore calcolazione. Inoltre, in questo calcolo preliminare dei record avviene anche la pianificazione della traiettoria del movimento, che viene calcolata in funzione dei valori dinamici impostati.
Con alcune istruzioni FTL è possibile influire sul calcolo preliminare dei record, che in determinate circostanze può essere ad esempio arrestato. Ciò può risultare utile ad es. nel caso di una diramazione del programma in cui occorre decidere quali segnali di ingresso di una periferica utilizzare. Se il calcolo preliminare dei record si arresta, l'intero set di istruzioni pre-calcolato viene elaborato e la cinematica arresta il movimento. Dopodiché viene ad es. calcolata la decisione adottata per la diramazione del programma e vengono eseguite le istruzioni di movimento seguenti.
Nota
L'interruzione del calcolo preliminare dei record mediante un'istruzione corrispondente può provocare arresti indesiderati sulla traiettoria. Per le istruzioni di questo tipo non è possibile un'approssimazione dei movimenti.
La figura mostra un estratto di un programma FTL. La freccia superiore indica l'istruzione corrente, eseguita in quel momento. La freccia inferiore indica l'istruzione attiva del calcolo preliminare dei record. La distanza tra le due frecce rappresenta il contenuto del calcolo preliminare dei record.
Ulteriori informazioni ed esempi sul calcolo preliminare dei record sono riportati nel capitolo 20.3 Controllo del calcolo preliminare dei record.
Lin(Pos1)
Lin(Pos2)
Lin(Pos3)
Lin(Pos4)
Lin(Pos5)
Lin(Pos6)
Lin(Pos7)
Lin(Pos8)
Lin(Pos9)
Elaborazione
principale dei record
Calcolo preliminare
dei record
3. Elaborazione del programma
18 Festo GDCP-CMXR-SW-IT it 0909a
3.5 Struttura dei programmi
Tutti i programmi FTL sono memorizzati sulla scheda di memoria (Compact Flash Card) del controller multiassiale CMXR nella directory “application\control\teachcontrol” (di seguito denominata 'directory di applicazione'). L'archiviazione dei programmi avviene in una struttura a cartelle. Un progetto contiene i programmi di movimenti ad esso assegnati. Il numero di progetti e programmi è limitato dalle dimensioni della scheda di memoria.
Schema della struttura dei programmi:
3.6 Progetti FTL
Un progetto FTL viene creato come sottodirectory nella directory di applicazione. Il nome della directory è il nome del progetto e ha l'estensione “tt”.
Esempio di nomi di progetti:
Progetto "_global"
Progetto "cube"
Progetto "PickPlace"
3. Elaborazione del programma
Festo GDCP-CMXR-SW-IT it 0909a 19
In un progetto vengono raggruppati i programmi FTL. Tutti i programmi sono quindi
elementi di un progetto. Nella directory di un progetto non sono ammesse ulteriori sottodirectory.
Nota
La struttura di un progetto viene automaticamente creata e gestita dal software grafico dell'unità di comando manuale e dall'editor der software FCT.
3.6.1 Progetto FTL globale
Oltre a tutti i progetti FTL esiste un progetto FTL globale, che prende il nome di “_global”. Questo nome è prestabilito e non può essere modificato. Il progetto è globale per tutti i
progetti. Tutti i dati e i programmi memorizzati al suo interno sono accessibili da tutti gli altri progetti. I dati o i programmi che devono essere utilizzati in più progetti vengono quindi memorizzati in questo progetto globale. In tal modo è garantita la consistenza dei dati.
Il progetto globale “_global” viene automaticamente caricato e attivato durante l'avviamento a regime del controller CMXR.
3.7 File di programma FTL “tip”
Tutti i programmi FTL appartenenti ad un progetto vengono memorizzati nella relativa directory progetti. Un programma è composto dal codice di programma e dai relativi dati.
Questi vengono memorizzati in file separati, che hanno lo stesso nome ma un'estensione (file extension) differente:
<Nome>.tip Estensione del file per il codice del programma
<Nome>.tid Estensione del file per i dati del programma
Esempio:
Per un programma con il nome “Load” viene creato il file “Load.tip”. Il file con i dati locali del programma si chiamerà “Load.tid”.
Se il programma viene creato con l'unità di comando manuale CDSA o tramite l'editor di programma Festo (nel Festo Configuration Tool), il file per i dati locali del programma viene generato automaticamente. In caso di generazione del programma mediante un software
differente, assicurarsi che per ogni programma venga creato il file di dati corrispondente.
Nota
Se il programma viene generato mediante un software di terze parti, assicurarsi che vengano rispettate le convenzioni per il nome dei file.
3. Elaborazione del programma
20 Festo GDCP-CMXR-SW-IT it 0909a
3.7.1 Programmi globali del progetto
Il progetto globale di sistema “_global” può contenere, oltre ai dati, anche dei programmi. Questi programmi possono essere utilizzati da tutti i programmi in tutti i progetti.
I programmi globali del sistema offrono una grande comodità d'uso. I programmi che dipendono dalla cinematica utilizzata possono essere definiti e memorizzati in modo autonomo rispetto ai progetti dell'applicazione. Se una cinematica include posizioni fisse, come ad es. una posizione di sicurezza, la sequenza di accostamento a questa posizione può essere memorizzata una sola volta nel progetto globale.
3.8 File di dati FTL “<Nome>.tid”
Nel sistema di comando CMXR i dati servono come variabile e per la comunicazione. La struttura del progetto offre la possibilità di memorizzare i dati in maniera chiara e di limitare l'accesso ai dati. Un file di dati viene contrassegnato con l'estensione "tid" e, così come il file di programma, è basato sul testo. Nel sistema sono possibili:
dati locali di programma all'interno dei singoli programmi,
dati globali di progetto per ogni progetto e
dati globali di sistema per tutti i progetti.
Questa suddivisione permette di scegliere chi può avere accesso ai dati. Anche la comunicazione tra programmi o progetti può essere gestita in questo modo. Con i dati globali di progetto si può comunicare tra i programmi, con i dati globali di sistema si può comunicare tra i progetti.
3.8.1 Dati locali del programma
I dati locali del programma sono noti solo all'interno del programma. Altri programmi o
progetti non hanno accesso a questi dati.
Nota
I dati locali del programma sono noti e validi solo all'interno del rispettivo programma. Altri programmi e progetti non hanno accesso a questi dati.
La figura seguente mostra i programmi “Fill” e “Sort”. Ognuno di questi programmi dispone di dati locali e dati di programma che sono memorizzati nei rispettivi file.
3. Elaborazione del programma
Festo GDCP-CMXR-SW-IT it 0909a 21
3.8.2 Dati globali del progetto
I dati globali del progetto servono per la comunicazione tra i singoli programmi all'interno di un progetto. I programmi esterni ad un progetto non hanno accesso ai suoi dati.
I dati globali del progetto vengono memorizzati in un apposito file dal nome “_globalvars.tid”. Se un progetto viene creato mediante l'unità di comando manuale CDSA o l'editor di programma FTL, questo file di dati globali del progetto viene generato automaticamente. In caso di creazione del progetto mediante un altro software, ad es. un software di programmazione del cliente, occorre accertarsi che questo file di dati venga creato.
Nota
Se un programma viene generato mediante un software di terze parti, assicurarsi che venga creato il file “_globalvars.tid” nella directory del progetto.
La figura seguente mostra i progetti “FillPalett” e “FeedParts”. Ognuno di questi progetti dispone di dati globali del progetto, che sono memorizzati nel file “_globalvars.tid” presente nella directory del progetto.
3.8.3 Dati globali del sistema
I dati globali del sistema sono noti a tutti i programmi di tutti i progetti a livello di sistema. Questi dati globali del sistema sono assegnati al progetto globale “_global” e memorizzati nel suo file di dati “_globalvars.tid”.
Nota
Poiché tutti i programmi hanno accesso ai dati globali del sistema, questi dati vanno utilizzati con particolare attenzione. L'accesso simultaneo di più programmi a questi dati deve essere monitorato ed eventualmente bloccato nell'applicazione mediante misure corrispondenti.
3. Elaborazione del programma
22 Festo GDCP-CMXR-SW-IT it 0909a
La figura seguente mostra il progetto globale “_global” in combinazione con dati globali
del progetto e dati locali. Nell'area globale del sistema sono inoltre visualizzati anche programmi globali del sistema.
3.8.4 Istanziazione di variabili
Le variabili vengono create nel file di dati “<Nome>.tid” nella forma seguente:
Sintassi
<nome della variabile> : <tipo di variabile> := <valore>
Il nome delle variabili è liberamente assegnabile. Per ogni riga si può creare una sola variabile.
Esempio:
cpos1 : CARTPOS := (100, 50, 100, 0, 0, 0)
cpos2 : CARTPOS := (600, 550, 100, 180, 0, 0)
index : DINT := 17
I possibili tipi di variabili sono descritti nei capitoli seguenti.
3. Elaborazione del programma
Festo GDCP-CMXR-SW-IT it 0909a 23
Attenzione
I valori delle variabili che vengono modificati nel programma in fase di esecuzione non vengono registrati nel file di dati sulla scheda di memoria. I valori così modificati rimangono validi fino a quando è caricato il progetto / programma. Con la chiusura del progetto / programma, o in caso di caduta della tensione di alimentazione, i dati modificati nel programma vanno persi.
Nota
Per memorizzare in modo permanente i valori di posizione sulla scheda di memoria, utilizzare la macro “SavePosition”.
4. Struttura del linguaggio
24 Festo GDCP-CMXR-SW-IT it 0909a
4. Struttura del linguaggio
4.1 Formattazione
I file FTL sono file di testo leggibili. Le istruzioni o le dichiarazioni vengono separate mediante interruzioni di riga. In generale si distingue tra lettere maiuscole e minuscole.
4.2 Identificatori
Gli identificatori servono per l'identificazione di progetti, programmi, moduli, variabili, costanti e tipi. Un identificatore consiste in una sequenza di lettere, cifre e del carattere di sottolineatura “_”.
Nota
Sono ammessi i caratteri a…z, A…Z, 0…9 e _ (carattere di sottolineatura). Tutti gli altri caratteri non sono ammessi.
Per gli identificatori si distingue tra lettere maiuscole e minuscole, per cui bisogna fare attenzione che ad es. una variabile venga scritta sempre con le stesse lettere maiuscole e minuscole.
Esempio:
Una variabile con l'identificatore “Indice” è diversa dalla variabile con l'identificatore
“INDICE”. Si tratta di 2 variabili differenti.
Nota
Diversamente dagli identificatori, per i nomi dei programmi e dei progetti non si distingue tra lettere maiuscole e minuscole.
4.3 Parole chiave
Le parole chiave fanno parte del linguaggio FTL. Tutte le parole chiave in FTL vengono scritte in maiuscolo e non devono essere utilizzate come nomi per programmi, variabili o tipi.
Lista di tutte le parole chiave:
CALL IF THEN END_IF ELSIF ELSE
GOTO LABEL WHILE DO END_WHILE LOOP
END_LOOP RETURN RUN KILL OR XOR
MOD AND NOT MAP MAPTO WAIT
BOOL DINT DWORD REAL STRING ARRAY
Allo stesso modo, tutti gli altri tipi di dati derivati sono parole chiave.
4. Struttura del linguaggio
Festo GDCP-CMXR-SW-IT it 0909a 25
Lista di tutte le funzioni:
SIN COS TAN COT LN ABS
SQRT EXP ASIN ACOS ATAN ATAN2
ACOT SHR SHL ROR ROL STR
CHR ORD LOW HIGH
Le limitazioni menzionate valgono inoltre per tutti i nomi di istruzioni come ad es. Lin, Vel, SetError ecc.
4.4 Costanti numeriche
Si distingue tra numeri interi e numeri reali. I numeri interi possono essere scritti in
rappresentazione decimale, duale o esadecimale.
Esempi di numeri interi validi:
Modo di scrittura decimale 100 -100
Modo di scrittura duale 2#1010 -2#1010
Modo di scrittura esadecimale 16#1ABF -16#1ABF
I numeri reali (valori a virgola mobile) possono essere rappresentati con punto decimale o nel modo di scrittura esponenziale. I valori con punto decimale devono avere almeno una
posizione dopo la virgola.
Esempi di numeri reali validi:
Modo di scrittura decimale: 1.01 178.473
Modo di scrittura esponenziale: 1.99E4 1.99e+8 1e-8
4.5 Catene di caratteri
Le catene di caratteri, le cosiddette stringhe, vengono iniziate e terminate con il carattere ". Possono contenere tutti i caratteri stampabili. La lunghezza di una catena di caratteri è limitata a 255 caratteri. Sono ammessi tutti i caratteri del set di caratteri ASCII.
Esempio di una catena di caratteri valida:
“Controller multiassiale CMXR-C1”
4. Struttura del linguaggio
26 Festo GDCP-CMXR-SW-IT it 0909a
4.6 Operatori e separatori
Gli operatori vengono utilizzati nelle espressioni e descrivono il modo in cui i valori delle variabili e le costanti numeriche vengono collegati tra loro. Gli operatori vengono rappresentati prevalentemente tramite caratteri speciali e parole chiave.
4.6.1 Operatori aritmetici
Operatore Significato
+ Addizione
- Sottrazione
* Moltiplicazione
/ Divisione
MOD Operatore modulo
Tabella 4.1 Operatori aritmetici
4.6.2 Operatori logici
Questi operatori possono essere utilizzati su valori logici e su numeri interi. Con i numeri interi funzionano a bit.
Operatore Significato
AND Funzione logica AND
OR Funzione logica OR
XOR Funzione logica OR esclusiva
NOT Negazione
Tabella 4.2 Operatori logici
4.6.3 Operatori di comparazione
Operatore Significato
< Inferiore
<= Inferiore o uguale
= Uguale
<> Non uguale
>= Maggiore o uguale
> Maggiore
Tabella 4.3 Operatori di comparazione
4. Struttura del linguaggio
Festo GDCP-CMXR-SW-IT it 0909a 27
4.6.4 Altri operatori
Operatore Significato
. Operatore per l'accesso agli elementi strutturali
[ ] Parentesi quadre per l'accesso agli array
( ) Parentesi, ad es. per liste di parametri
Tabella 4.4 Altri operatori
4.6.5 Separatori
Operatore Significato
:= Assegnazione del valore per una variabile
: Carattere separatore nell'istanziazione di variabili
, Carattere di enumerazione nelle liste di parametri per
il richiamo di funzioni o macro
Tabella 4.5 Separatori
5. Tipi di dati base
28 Festo GDCP-CMXR-SW-IT it 0909a
5. Tipi di dati base FTL supporta 5 tipi di dati:
Dati booleani Numeri interi Schema di codifica a bit Numeri a virgola mobile Catene di caratteri
Da questi 5 tipi di dati, in FTL vengono derivati tipi di dati elementari. In base al significato del tipo di dati avviene un'assegnazione a un determinato intervallo di valori e alle operazioni corrispondenti.
Tipo di dati
Interpretazione Capacità di memoria
Intervallo di valori
BOOL Bit 8 bit TRUE o FALSE
DINT Numero intero 32 bit -2.147.483.648 … +2.147.483.647
DWORD Schema di
codifica a bit
32 bit 32 bit
REAL Numero a virgola
mobile
32 bit sec. IEEE
STRING Catena di
caratteri
max. 255 byte max. 255 caratteri
Tabella 5.1 Tipi di dati base
A seconda del tipo di dati sono possibili diverse operazioni.
Tipo di dati Operazioni
BOOL Operazioni logiche AND, OR, XOR, NOT
DINT Operazioni aritmetiche, operazioni di comparazione
DWORD Operazioni a bit AND, OR, XOR, NOT, SHL, SHR, ROL, ROR, =, <>
REAL Operazioni aritmetiche, operazioni di comparazione
STRING Operazioni di comparazione, +
Tabella 5.2 Operazioni possibili
5. Tipi di dati base
Festo GDCP-CMXR-SW-IT it 0909a 29
In linea di principio, un valore può essere assegnato solo a tipi di dati dello stesso tipo.
Tuttavia FTL supporta in parte anche l'assegnazione a tipi di dati diversi. In tal caso viene eseguita una conversione automatica del tipo. Per l'assegnazione a determinati tipi di dati è necessario utilizzare le funzioni integrate STR, CHR e ORD.
Da \ a BOOL Numeri interi Schema di codifica a bit
REAL STRING
BOOL sì --- --- --- STR
Numeri interi --- sì sì sì STR, CHR
Schema di
codifica a bit
--- sì sì --- STR, CHR
REAL --- sì --- sì STR
STRING --- ORD ORD --- sì
Tabella 5.3 Assegnazioni possibili
A seconda del tipo di dati sono possibili le seguenti assegnazioni:
Funzione Operazione
STR Converte un tipo di dati qualsiasi in una stringa.
CHR Converte un valore ASCII in un singolo carattere.
ORD Converte un singolo carattere nel valore ASCII.
Tabella 5.4 Funzioni integrate
5.1 Tipo di dati booleano (BOOL)
Il tipo di dati booleano può assumere i valori TRUE (vero) o FALSE (falso). Viene utilizzato soprattutto per operazioni logiche, anche in combinazione con segnali di periferiche come ad es. ingressi di sensori e uscite di attuatori.
Esempio:
Variabili:
pos1 : BOOL
pos2 : BOOL
pos3 : BOOL
min1PosValid : BOOL
allPosValid : BOOL
Codice del programma:
allPosValid := NOT pos1 AND NOT pos2 AND NOT pos3
min1PosValid := pos1 XOR pos2 XOR pos3
5. Tipi di dati base
30 Festo GDCP-CMXR-SW-IT it 0909a
5.2 Tipi di numeri interi, tipo di dati REAL, tipi di schema di codifica a bit
Il linguaggio di programmazione FTL supporta tipi di dati interi (denominati anche tipi Integer), a virgola mobile e a schema di codifica a bit. A seconda dei casi, questi tipi di dati possono essere assegnati l'uno all'altro (vedi capitolo 5 Tipi di dati base a pagina 28). Per queste assegnazioni il sistema esegue automaticamente la conversione interna del tipo.
A seconda della conversione del tipo utilizzata possono verificarsi perdite di precisione. Ad es. durante una conversione da REAL a DINT il sistema elimina le posizioni dopo la virgola.
Esempi di conversioni del tipo:
Variabili:
pressure : REAL
index : DINT
Codice del programma:
pressure := 1.53
index := pressure // Conversione REAL->DINT
Dopo la conversione, la variabile “index” contiene il valore “1”.
Nota
La funzione di conversione del tipo deve essere utilizzata solo se si conoscono tutte le possibili conseguenze (vedi esempio sopra).
5.3 Parentesi
Con le parentesi vengono raggruppate le calcolazioni in base alla sequenza di elaborazione. L'elaborazione delle parentesi avviene dall'interno all'esterno.
Esempio:
:
IF (Index < 10) AND (Index > 5) THEN
:
END_IF
:
Distance := (xRow + 10) * Index
:
5. Tipi di dati base
Festo GDCP-CMXR-SW-IT it 0909a 31
5.4 Catene di caratteri (STRING)
Le catene di caratteri vengono descritte con il tipo di dati STRING. La lunghezza di una catena di caratteri è limitata a 255 caratteri. Le catene di caratteri, denominate anche stringhe, possono essere assegnate l'una all'altra e anche unite tra di loro utilizzando semplicemente l'operatore +.
Esempio:
Variabile:
message : STRING
part : STRING
Codice del programma:
message := “cylinder ”
part := “DNC ”
message := message + part + “is extended”
5.5 Tipi di dati strutturati
Con il termine “tipi di dati strutturati” si intende una disposizione fissa di tipi di dati base su un nuovo tipi di dati.
I tipi di dati strutturati non possono essere creati a livello utente. Essi vengono utilizzati (solo) come tipi di dati nelle istruzioni FTL. Una loro applicazione è ad es. la rappresen-tazione di posizioni. Con il tipo di dati “AXISPOS” viene descritta una posizione dell'asse composta da 6 variabili del tipo di dati base REAL in una determinata sequenza. Vedi capitolo 9.1 Descrizione della posizione a pagina 63.
5.6 Array
Gli array vengono utilizzati per raggruppare tipi di dati uguali in un'unità ordinata. L'accesso ai singoli elementi dell'array avviene per mezzo di un indice. I limiti dell'array vengono controllati. Ciò significa che se un'operazione da eseguire supera le dimensioni dell'array, viene emesso un messaggio corrispondente.
Dichiarazione degli array:
Sintassi
VAR
<nome> : ARRAY [ <dimensioni array> ] OF <tipo di dati> :=
( <inizializzazione>)
END_VAR
5. Tipi di dati base
32 Festo GDCP-CMXR-SW-IT it 0909a
Con il parametro 'dimensioni array' vengono indicati:
le dimensioni dell'array,
l'indice del campo dell'array,
il tipo di dimensionamento dell'array.
Dimensioni dell'array
Le dimensioni dell'array vengono indicate mediante una costante (numero intero). L'indicazione delle dimensioni dell'array con una variabile non è possibile.
// Array con 10 elementi
Matrix1 : ARRAY [10] OF DINT
// Array con 12 elementi
Matrix2 : ARRAY [12] OF CARTPOS
5. Tipi di dati base
Festo GDCP-CMXR-SW-IT it 0909a 33
Indice del campo
L'indice del campo dell'array inizia di regola con 0 e si estende fino alle dimensioni definite dell'array meno 1. Se ad es. viene definito un array con 10 elementi, l'indice dell'array è compreso tra 0 e 9. Con l'indice dell'array viene eseguito l'accesso ai singoli elementi dell'array.
Qualora sia necessario un indice di array particolare, questo può essere indicato nella dichiarazione dell'array.
Sintassi
VAR
<nome> : ARRAY [<start index> ... <end index> ] OF
<tipo di dati> := (<inizializzazione>)
END_VAR
L'esempio seguente mostra un array con 10 elementi il cui indice va da 3 a 12:
Matrix3 : ARRAY [3...12] OF DINT
Dimensioni
Un array è come minimo monodimensionale, ma può anche essere multidimensionale. Gli array multidimensionali vengono indicati specificando le dimensioni, separate da una virgola, all'interno delle parentesi quadre.
Sintassi
VAR
<nome> : ARRAY [<size 1> , <size 2>, <size 3>, ... ] OF
<tipo di dati> := (<inizializzazione>)
END_VAR
Gli esempi seguenti mostrano la dichiarazione di array multidimensionali:
// Array con 2 dimensioni, ciascuna con 3 elementi = 9 elementi
Matrix1 : ARRAY [3, 3] OF DINT
// Array con 3 dimensioni, ciascuna con 3 elementi o 2 elementi
= 18 elementi
Matrix2 : ARRAY [3, 3, 2] OF DINT
5. Tipi di dati base
34 Festo GDCP-CMXR-SW-IT it 0909a
Se necessario è possibile indicare un indice del campo anche negli array multidimen-
sionali. L'esempio seguente mostra un array con 3 x 3 elementi e indice del campo rispettivamente diverso:
Matrix3 : ARRAY [1..3, 5..7, 0..2] OF DINT
5.6.1 Inizializzazione degli array
Il sistema inizializza gli array con il valore 0. Se si desidera un'inizializzazione con un valore diverso è possibile indicarla dopo il tipo di array all'interno delle parentesi tonde.
Esempio:
Matrix1 : ARRAY [7] OF DINT := (0, 1, 2, 3, , , )
Matrix2 : ARRAY [3, 3] OF DINT := ((1, , 9), (3, , 7), (, , 6))
Ogni campo dell'array viene introdotto da una virgola. I campi da non inizializzare non vanno indicati. La virgola è però indispensabile affinché gli altri elementi vengano inizializzati correttamente.
5.6.2 Definizione dei limiti degli array con LOW e HIGH
Con la parola chiave LOW viene definito l'indice del campo inferiore, con HIGH l'indice del
campo superiore di un array.
Sintassi
<variabile : DINT> := LOW( <variabile array> )
<variabile : DINT> := HIGH( <variabile array> )
Alle funzioni LOW ed HIGH viene trasferita una variabile dell'array. Per definire i limiti di un array monodimensionale viene trasferito solo il nome dell'array. Per gli array multidimensionali bisogna sempre specificare la dimensione a cui devono riferirsi i limiti.
Matrix : ARRAY [5, 19, 10..34] OF REAL
I limiti del campo dell'array sono:
Prima dimensione da 0 a 4
o Il richiamo di LOW fornisce 0
o Il richiamo di HIGH fornisce 4
Seconda dimensione da 0 a 18
o Il richiamo di LOW fornisce 0
o Il richiamo di HIGH fornisce 18
5. Tipi di dati base
Festo GDCP-CMXR-SW-IT it 0909a 35
Terza dimensione da 10 a 34
o Il richiamo di LOW fornisce 10
o Il richiamo di HIGH fornisce 34
Nota
Se a LOW o ad HIGH viene trasferita una variabile che non è un array, viene emesso un messaggio d'errore.
Esempi:
Matrix1 : ARRAY [1..4] OF DINT
Matrix2 : ARRAY [3,8] OF DINT
Index : DINT
// Indice ha il valore 1
Index := LOW(Matrix1)
// Indice ha il valore 4
Index := HIGH(Matrix1)
// Indice ha il valore 0
Index := LOW(Matrix2)
// Indice ha il valore 2
Index := HIGH(Matrix2)
// Indice ha il valore 0
Index := LOW(Matrix2[0])
// Indice ha il valore 7
Index := HIGH(Matrix2[0])
5. Tipi di dati base
36 Festo GDCP-CMXR-SW-IT it 0909a
5.7 Variabili di riferimento (mapping)
Il meccanismo di mapping consente di definire variabili come riferimenti di un determinato tipo, per collegarle poi con oggetti di questo tipo.
In tal caso si parla di una variabile di riferimento mappata sull'oggetto, oppure di un oggetto assegnato alla variabile di riferimento. Un utilizzo diretto della variabile di riferimento implica quindi l'uso dell'oggetto assegnato, al quale la variabile di riferimento è collegata tramite il meccanismo di mapping.
Se una variabile di riferimento viene utilizzata direttamente, senza che sia stato assegnato un oggetto, il sistema emette un errore.
Le variabili di riferimento richiedono solo lo spazio di memoria necessario per salvare il
rimando all'oggetto assegnato. Questo fabbisogno di memoria è indipendente dal tipo di oggetto assegnato.
La grafica seguente mostra il meccanismo di mapping:
Se nel programma viene utilizzata la variabile di riferimento Indice_Rif, questa lavorerà con l'area di memoria e il contenuto della variabile Indice_C.
Esempio: l'istruzione Indice_Rif := 10 descrive la variabile Indice_C con il valore 10.
Nota
Durante la lettura di una variabile mappata viene letta la variabile assegnata, e per la scrittura su una variabile mappata viene scritto sulla variabile assegnata.
Variabile di riferimento Indice_A
Indice_B
Indice_C
Indice_Rif
Mappatura di Indice_Rif su Indice_C
Variabile del programma
5. Tipi di dati base
Festo GDCP-CMXR-SW-IT it 0909a 37
5.7.1 Dichiarazione di variabili di riferimento, <MAPTO>
La dichiarazione di una variabile di riferimento può avvenire con qualsiasi tipo di dati, come ad es. DINT o REAL. Per eseguire la dichiarazione è necessario anteporre la parola chiave MAPTO al tipo di dati desiderato. Un'inizializzazione della variabile di riferimento non è possibile.
Sintassi
<variabile> : MAPTO <tipo di dati>
Esempio:
Index : MAPTO DINT
Level : MAPTO REAL
Home : MAPTO CARTPOS
In questo esempio sono dichiarate 3 variabili di riferimento, assegnate a tipi di dati differenti.
5.7.2 Collegamento di variabili di riferimento, <MAP>
Le variabili di riferimento vengono collegate con la parola chiave MAP. Tener presente che si possono collegare solo le variabili che hanno lo stesso tipo di dati delle variabili di riferimento.
Sintassi
<variabile> : MAP( <variabile> )
5.7.3 Controllo delle variabili di riferimento, <IS_MAPPED>
Con la funzione IS_MAPPED si può controllare se una variabile di riferimento è collegata ad una variabile. Se nel programma viene utilizzata una variabile di riferimento non collegata, viene emesso un errore.
5. Tipi di dati base
38 Festo GDCP-CMXR-SW-IT it 0909a
Sintassi
IS_MAPPED (<variabile di riferimento>) : BOOL
Valori di ritorno:
TRUE La variabile di riferimento è collegata
FALSE La variabile di riferimento non è collegata
Questa funzione può essere usata ad es. quando si utilizzano delle variabili di riferimento in un sottoprogramma, dove il collegamento delle variabili avviene all'esterno del sottoprogramma.
Esempio:
IF IS_MAPPED(Level) THEN
:
:
ELSIF
SetError(“Not mapped”)
END_IF
5. Tipi di dati base
Festo GDCP-CMXR-SW-IT it 0909a 39
5.8 Istruzione DO
Con l'istruzione DO è possibile eseguire delle istruzioni durante l'elaborazione principale del programma. L'istruzione presenta la seguente sintassi:
Sintassi
<FTL Macro> DO < Macro o istruzione >
L'istruzione specificata dopo DO viene eseguita durante l'elaborazione principale del programma. Il calcolo preliminare del programma non viene influenzato dall'istruzione DO.
Dopo un'istruzione DO può essere indicata una macro o un'istruzione. Non sono ammesse macro o istruzioni riferite ad una cinematica, come ad es. un'indicazione di dinamicità o
una traslazione in posizione. Istruzioni di questo tipo sono ammesse solo prima dell'istru-zione DO, dato che la pianificazione della traiettoria non può gestire le istruzioni che vengono dopo l'istruzione DO.
Nota
L'istruzione DO viene eseguita dopo che è stata eseguita l'istruzione precedente nell'elaborazione principale. L'esecuzione avviene incondizionatamente.
Con l'istruzione DO è possibile ad es. descrivere variabili o settare delle uscite durante
l'elaborazione principale del programma FTL. L'istruzione DO può essere utilizzata in combinazione con tutte le istruzioni di movimento, ad es. Ptp o Lin.
Esempio di attivazione di un'uscita:
Al raggiungimento di pos2 viene attivata l'uscita del modulo Vuoto.
:
Lin(pos1)
Lin(pos2) DO Vacuum.Set()
Lin(pos3)
:
5. Tipi di dati base
40 Festo GDCP-CMXR-SW-IT it 0909a
Esempio di descrizione di variabili al PLC:
:
Lin(pos1)
Lin(pos2) DO plc_Dint[3] := 5
Lin(pos3)
:
Con l'istruzione DO si possono impostare procedimenti di commutazione semplici, che vengono poi eseguiti durante l'elaborazione principale del programma FTL. In tal caso non è possibile una compensazione dei tempi di commutazione. Non si ha nessun accoppia-
mento con la velocità di avanzamento lungo la traiettoria. Ciò significa che il comporta-mento di commutazione riferito alla traiettoria può cambiare in caso di modifica della dinamica della traiettoria.
Esempio
Sul contorno seguente si vuole attivare un'uscita digitale sui percorsi diritti e disattivarla negli archi di cerchio.
:
Lin(Pos1) DO Applicator.Set()
Lin(Pos2) DO Applicator.Reset()
CircIp(Ipos1,Pos3) DO Applicator.Set()
Lin(Pos4) DO Applicator.Reset()
CircIp(Ipos2,Pos1)
:
Pos2 Pos1
Pos3 Pos4
Ipos1
Ipos2
5. Tipi di dati base
Festo GDCP-CMXR-SW-IT it 0909a 41
1
1 P1
1
1 P1´
1
1 P2
1
1 P0
L'istruzione Do viene eseguita qui.
5.8.1 Comportamento nell'area di approssimazione
Con la funzione di approssimazione attivata, l'istruzione DO non può essere eseguita al raggiungimento del punto programmato poiché questo non viene raggiunto a causa dell'approssimazione. In questo caso viene proiettato ed eseguito il punto di commu-tazione sulla traiettoria dell'area di approssimazione.
Nota
Se i segmenti di movimento convergono tangenzialmente, l'appros-simazione non ha alcun effetto sull'esecuzione dell'istruzione DO.
6. Dichiarazioni di variabili
42 Festo GDCP-CMXR-SW-IT it 0909a
6. Dichiarazioni di variabili Le dichiarazioni di variabili avvengono nei rispettivi file con l'estensione “tid”, dove vengono definiti il nome della variabile e il tipo di dati. Il nome e il tipo di dati vengono separati tra loro mediante due punti.
Sintassi
<nome> : <tipo>
Esempi di dichiarazioni di variabili valide:
offset : REAL
flag : BOOL
index : DINT
name : STRING
6.1 Inizializzazione
Tutte le variabili FTL vengono inizializzate automaticamente. Le variabili Integer e Real vengono inizializzate con 0, le catene di caratteri (stringhe) con una catena di caratteri vuota (“ ”) e le variabili booleane con FALSE.
Oltre a questa inizializzazione automatica vi è anche la possibilità di inizializzare le
variabili con un determinato valore. In tal caso si parla di inizializzazione esplicita. Il valore iniziale viene specificato dopo l'indicazione del tipo, sotto forma di assegnazione nel file di dati. Le variabili reali possono essere inizializzate anche con valori interi.
Esempi di inizializzazioni valide:
index : DINT := 1
pi : REAL := 3.1415
radius : REAL := 10
flag : BOOL := TRUE
message : STRING := “Hello"
7. Espressioni
Festo GDCP-CMXR-SW-IT it 0909a 43
7. Espressioni Un'espressione descrive un valore assegnato a un determinato tipo di dati. Un'espres-sione può contenere variabili e funzioni. I componenti di un'espressione vengono collegati mediante operatori.
valore := SQRT(a) – 2*a*b + SQRT(b)
7.1 Sequenza di esecuzione nelle espressioni
Gli operatori in un'espressione vengono elaborati in una determinata sequenza:
1. ( ) (parentesi)
2. [] (indice array)
3. NOT (negazione)
4. * / MOD AND (moltiplicazione, divisione, modulo, logico AND)
5. + - OR XOR (addizione, sottrazione, logico OR /EXOR)
6. < <= = <> >= > (operazioni di comparazione)
8. Comando a programma
44 Festo GDCP-CMXR-SW-IT it 0909a
8. Comando a programma
8.1 Istruzioni
I programmi FTL sono composti da una successione di istruzioni separate da interruzioni di riga. FTL conosce le istruzioni seguenti:
1. Assegnazione del valore
2. Diramazioni: IF, IF .. GOTO, GOTO .. LABEL, RETURN
3. Cicli di istruzioni: WHILE, LOOP
4. Elaborazione di routine: CALL, richiamo di macro, RUN, KILL
5. Istruzione di sincronizzazione: WAIT
8.2 Assegnazione del valore <:=>
Un'assegnazione del valore è costituita da una definizione di variabile sul lato sinistro, dall'operatore di assegnazione := e da un'espressione sul lato destro. Il tipo di dati
dell'espressione deve poter essere assegnato al tipo di dati della variabile.
Sintassi
<variabile > := <espressione>
Esempi:
i := 1
x := a + b * 2
8.3 Condizioni
All'interno di istruzioni, diramazioni o cicli è possibile formulare delle condizioni. Le con-dizioni possono contenere operandi booleani (ad es. AND, OR) oppure un operando di confronto (ad es. >, <=,=). Il collegamento di più confronti viene strutturato mediante livelli
di parentesi corrispondenti.
Per i seguenti esempi vengono utilizzate le variabili seguenti:
Marker : BOOL
Flag1 : BOOL
Flag2 : BOOL
Flag3 : BOOL
Index : DINT
8. Comando a programma
Festo GDCP-CMXR-SW-IT it 0909a 45
Esempi di condizioni:
Marker := Index < 10
Marker := Flag1 AND Flag2 OR Flag3
IF Index < 10 THEN
:
END_IF
WHILE Index < 5 DO
:
END_WHILE
WHILE NOT Flag1 AND Flag3 OR Flag2 DO
:
END_WHILE
Esempi di condizioni con parentesi:
Marker := (Index < 10) AND (Index < 0)
Marker := Flag1 AND (Index < 7)
IF (Index < 10) AND (Index > 5) THEN
:
END_IF
8.4 Diramazione <IF…THEN>
L'istruzione IF consente di impostare diramazioni dipendenti da una condizione nell'ese-cuzione del programma. La condizione deve essere del tipo di dati BOOL e può essere composta da più operandi. Con l'istruzione ELSIF si possono formulare più condizioni. Con
l'istruzione ELSE si possono definire istruzioni che verranno saltate nel caso in cui nessuna delle condizioni venga soddisfatta. L'istruzione IF viene terminata con l'istruzione END_IF.
8. Comando a programma
46 Festo GDCP-CMXR-SW-IT it 0909a
Sintassi
IF <condizione> THEN
<istruzioni>
ELSIF <condizione> THEN
<istruzioni>
ELSE
<istruzioni>
END_IF
L'istruzione ELSEIF può comparire più volte.
Esempio:
Un impianto di misurazione invia 2 segnali che consentono una valutazione qualitativa.
partOk Segnale per un pezzo corretto
partBad Segnale per un pezzo da scartare
Nell'esempio seguente, nel caso di un pezzo corretto e di un pezzo da scartare ha luogo una diramazione in FTL. Se i segnali sono indefiniti, cioè se entrambi i segnali hanno lo stato TRUE o FALSE, si ritorna alla posizione PosStart.
IF partOk AND NOT partBad THEN // pezzo corretto Lin(pos12) Lin(pos13) ELSIF NOT partOk AND partBad THEN // pezzo da scartare Lin(pos3) Lin(pos4) ELSE Lin(posStart) // segnali non definiti END_IF
8.5 Comandi di salto
Spesso nei programmi FTL devono essere eseguiti dei salti. Questi salti possono essere basati su una decisione o venire eseguiti in modo assoluto. Per eseguire un salto è necessario un punto di partenza e una destinazione di salto.
8. Comando a programma
Festo GDCP-CMXR-SW-IT it 0909a 47
Nota
La destinazione di salto deve trovarsi all'interno del programma attivo. Un salto in un blocco di istruzioni con IF..THEN, WHILE o LOOP non è consentito. Tuttavia è consentito eseguire un salto verso l'esterno da uno di questi blocchi di istruzioni.
8.5.1 Marcatura di salto <LABEL>
Una marcatura di salto deve essere dichiarata come destinazione di un salto. La marcatura
di salto è composta da un nome liberamente assegnabile. La marcatura di salto è univoca e può essere presente una sola volta in un programma. Per essere riconosciuta dal sistema, una marcatura di salto deve essere preceduta dalla parola chiave LABEL.
Sintassi
LABEL <marcatura di salto>
La marcatura di salto può essere programmata con i comandi di salto descritti di seguito.
Nota
In caso di programmazione con l'unità CDSA occorre innanzitutto definire la destinazione di salto (LABEL). Dopodiché si può programmare l'istruzione GOTO.
8.5.2 Salto condizionato <IF…GOTO>
Con l'istruzione IF…GOTO vengono eseguiti salti condizionati. Analogamente alla dirama-zione del programma IF…THEN, questa istruzione necessita di una condizione che fornisca un risultato del tipo di dati BOOL.
:
Lin(pos15)
Lin(pos16)
Lin(pos5)
Lin(pos6)
:
IF teilOk GOTO lblHome
LABEL lblHome
Decisione di salto
Destinazione di salto
8. Comando a programma
48 Festo GDCP-CMXR-SW-IT it 0909a
Sintassi
IF <condizione> GOTO <marcatura di salto>
Se la condizione è soddisfatta, cioè il risultato è TRUE (vero), il salto viene eseguito. Se la condizione non è soddisfatta, cioè il risultato è FALSE (falso), i comandi vengono eseguiti nelle righe di programma successive.
8.5.3 Salto assoluto <GOTO>
Diversamente dall'istruzione di salto condizionato IF…GOTO, l'istruzione GOTO è assoluta. Ciò significa che non c'è nessuna istruzione condizionale.
Sintassi
GOTO <marcatura di salto>
L'istruzione GOTO consente di saltare parti di programma con grande facilità. È anche indicata per uscire da cicli di istruzioni del programma.
Nota
In caso di programmazione con l'unità CDSA occorre innanzitutto definire la destinazione di salto (LABEL). Dopodiché si può programmare l'istruzione GOTO.
8.6 Cicli
I cicli sono istruzioni di programma che ripetono un sottoprogramma definito in maniera condizionata o assoluta. In questo modo, a seconda della funzione, è possibile realizzare programmi molto concisi, ad es. per il prelievo di pezzi da un pallet le cui posizioni sono calcolabili grazie alla disposizione nota.
Attenzione
La programmazione di cicli di istruzioni infiniti può pregiudicare il comportamento in fase di esecuzione del controller CMXR. All'interno dei cicli di istruzioni infiniti devono esserci delle istruzioni quali Wait o WaitTime, in modo che il controller CMXR non venga bloccato da un ciclo di istruzioni infinito.
8.6.1 Istruzione WHILE <WHILE>
L'istruzione WHILE serve per ripetere una sequenza di istruzioni finché viene soddisfatta una condizione. Il risultato della condizione deve essere del tipo di dati BOOL. Il ciclo può contenere un numero a piacere di istruzioni. L'istruzione WHILE viene terminata con la parola chiave END_WHILE.
8. Comando a programma
Festo GDCP-CMXR-SW-IT it 0909a 49
Nota
Un ciclo di istruzioni che viene eseguito molto spesso e non contiene alcuna istruzione WAIT può pregiudicare l'esecuzione di altri programmi FTL. In genere il sistema di comando viene configurato in modo tale che, in un caso simile, venga emessa un'avvertenza e il programma in questione venga interrotto entro breve tempo.
Sintassi
WHILE <condizione> DO
<istruzioni>
END_WHILE
Esempio:
WHILE index < 5 DO
Lin(pos1)
Lin(pos2)
Lin(pos3)
index := index + 1
END_WHILE
8.6.2 Istruzione LOOP <LOOP>
L'istruzione LOOP serve per ripetere una sequenza di istruzioni. Si può specificare diret-tamente quante volte dovranno essere ripetute le istruzioni. Per ogni istruzione LOOP viene automaticamente generata una variabile di ciclo interna, che all'avvio del ciclo viene inizializzata su 1. Il ciclo di istruzioni viene eseguito fino a quando il valore della variabile di ciclo interna supera il valore finale. Se il valore finale è inferiore a 1, il ciclo di istruzioni non viene eseguito ma direttamente saltato. Dopo ogni esecuzione, il valore della variabile di ciclo viene aumentato di uno e il valore finale viene ricalcolato.
Il ciclo può contenere un numero a piacere di istruzioni.
Sintassi
LOOP <numero> DO
<istruzioni>
END_LOOP
Esempi:
LOOP 10 DO // 10 ripetizioni
index := index + 13
8. Comando a programma
50 Festo GDCP-CMXR-SW-IT it 0909a
END_LOOP
j := 0
...
LOOP j DO // viene saltato poiché j = 0
index := index + 13
END_LOOP
:
8.7 Sottoprogrammi
In un programma si possono richiamare altri programmi, che devono trovarsi nello stesso
progetto del programma attivo o nel progetto globale (_global, vedi capitolo 3.6.1 Progetto FTL globale a pagina 19). Questi programmi richiamati vengono definiti sottoprogrammi.
Nota
Un sottoprogramma non necessita di un identificativo particolare. Esso viene creato esattamente come ogni altro programma e memorizzato in un progetto. Un programma viene classificato come sottoprogramma solamente quando viene richiamato da un programma e non direttamente dal progetto.
Elaborazione:
Mentre il sottoprogramma viene eseguito, il programma dal quale è stato richiamato attende che esso venga terminato. Una volta terminato il sottoprogramma si ritorna automaticamente al programma principale, che viene proseguito.
8. Comando a programma
Festo GDCP-CMXR-SW-IT it 0909a 51
Schema sequenziale:
In questo esempio il programma “feed” richiama un sottoprogramma “movehome”. Quando il programma “movehome” termina l'elaborazione, il programma “feed” viene proseguito.
Vantaggi:
L'utilizzo dei sottoprogrammi consente una programmazione chiara ed efficiente. Il codice
di programma per funzioni parziali viene memorizzato separatamente e può essere utilizzato da più programmi. In questo modo aumenta la semplicità di manutenzione e la consistenza dei programmi.
8.7.1 Richiamo di un sottoprogramma <CALL>
Il richiamo di un sottoprogramma viene eseguito con l'istruzione CALL. Un trasferimento di parametri al sottoprogramma non viene supportato. Qualora sia necessario trasferire dei dati, occorre utilizzare le variabili globali. Queste variabili vengono alimentate con i valori corrispondenti prima del richiamo e quindi elaborate all'interno del sottoprogramma.
I richiami ricorsivi dei programmi non sono ammessi. Pertanto un programma non può
richiamare se stesso. Inoltre non è possibile richiamare il programma che ha eseguito il richiamo.
Sintassi
CALL <nome programma> ( )
Programma principale
Sprungziel
Sottopro-
gramma
8. Comando a programma
52 Festo GDCP-CMXR-SW-IT it 0909a
Esempio:
:
variant := 17 // variabile per il programma
Incollatura
directionRight := TRUE // variabile per il programma
Incollatura
directionLeft := FALSE // variabile per il programma
Incollatura
CALL Glueing() // sottoprogramma Incollatura
CALL MoveStart() // sottoprogramma di traslazione alla
posizione di partenza
:
8.7.2 Ritorno al programma <RETURN> In linea di principio un sottoprogramma viene terminato con l'ultima istruzione. Per terminare un sottoprogramma prima dell'ultima istruzione viene utilizzata l'istruzione RETURN. Il sottoprogramma viene terminato anticipatamente e si ritorna al programma principale, che viene proseguito.
Sintassi
RETURN
Una restituzione dei valori al programma principale tramite l'istruzione RETURN non è
possibile. In caso di necessità, per questo trasferimento di informazioni si possono utilizzare le variabili corrispondenti.
Nota
Se l'istruzione RETURN viene eseguita nel programma principale, questo viene arrestato e terminato.
Richiamando l'istruzione RETURN in un programma parallelo o in un sottoprogramma, esso verrà terminato. Il programma principale viene proseguito.
Esempio:
:
CALL CheckPart() // richiamo del sottoprogramma CheckPart
IF NOT partOk THEN
partStatus := 10 // variabile globale per il valore di
ritorno
RETURN // fine anticipata del programma
END_IF
Lin(pos3)
:
8. Comando a programma
Festo GDCP-CMXR-SW-IT it 0909a 53
8.8 Programmi paralleli
Un programma del progetto attivo o del progetto globale può anche essere avviato come processo parallelo. Il sistema operativo del CMXR assicura l'elaborazione parallela di questi programmi. Ciò viene garantito dal sistema multitasking interno.
Nota
Le istruzioni di traslazione ad una cinematica da un programma parallelo sono possibili solo se, in precedenza, non è stata im-partita alcuna istruzione di traslazione dal programma principale. Se viene impartita un'istruzione di traslazione dal programma principale e da un programma parallelo, il sistema emette un errore.
Utilizzo:
I programmi paralleli consentono di creare processi che operano in modo asincrono o solo parzialmente sincronizzato con il programma principale. Un esempio al riguardo è l'azio-namento di un'unità di alimentazione o espulsione che viene comandata con ingressi e uscite. In questo caso l'elaborazione può essere descritta con istruzioni logiche e con l'elaborazione degli ingressi/uscite. A seconda delle esigenze si può eseguire una sincronizzazione con il programma principale mediante le variabili globali.
Schema sequenziale:
In questo esempio il programma “feed” richiama un programma parallelo “calculate”. Il programma richiamato “calculate” attende prima un segnale e incrementa un contatore. Nel frattempo il programma principale “feed” continua a lavorare.
Programma parallelo
Programma principale
Sprungziel
8. Comando a programma
54 Festo GDCP-CMXR-SW-IT it 0909a
Nota
Se in un programma parallelo viene programmato un ciclo di istruzioni infinito, assicurarsi che tale ciclo non blocchi l'esecuzione degli altri programmi. Con un'istruzione Wait o WaitTime si ha la garanzia che la capacità di calcolo venga ripartita tra gli altri programmi.
8.8.1 Avvio di un programma parallelo <RUN>
Un programma parallelo viene avviato con l'istruzione RUN. Un trasferimento dei parametri al programma da avviare non è possibile. Per trasferire i dati si possono utilizzare le variabili globali.
Sintassi
RUN <nome programma>
Un programma già in esecuzione non può essere contemporaneamente avviato come programma parallelo.
8.8.2 Termine di un programma parallelo <KILL>
Un programma parallelo attivo può essere terminato con l'istruzione “KILL” dal programma principale. Prima vengono arrestati il programma e la cinematica, quindi viene
terminato il programma.
Sintassi
KILL <nome programma>
Anche l'istruzione RETURN provoca il termine di un programma parallelo attivo.
8.9 Modifiche del calcolo preliminare dei record
8.9.1 Istruzione WAIT con indicazione del tempo <WaitTime>
L'istruzione WAIT con indicazione del tempo consente di programmare un tempo di attesa. Questo tempo di attesa influisce sul comportamento di movimento. Provoca un arresto del calcolo preliminare dei record, con il conseguente arresto del movimento. Il tempo di attesa inizia a decorrere dopo che è stata eseguita l'istruzione precedente. Al termine di questo tempo il programma viene proseguito.
8. Comando a programma
Festo GDCP-CMXR-SW-IT it 0909a 55
Sintassi
WaitTime (<timeMS >: DINT)
Il tempo viene indicato in millisecondi e può essere specificato mediante un valore o una variabile.
Nota
Per sincronizzare il calcolo preliminare dei record con l'elabora-zione effettiva dei record si può utilizzare l'istruzione WaitTime 0.
Esempio:
Un sistema di manipolazione equipaggiato con una pinza preleva i pezzi da un pallet. Per
garantire una presa sicura dei pezzi è necessario un certo tempo di attesa.
Estratto dal programma di movimenti:
:
Lin(pos1) // traslazione sopra posizione di
presa
Lin(pos2) // traslazione verso posizione pinza
Gripper.Set() // chiusura pinza
WaitTime(70) // attesa del tempo di presa di
70 msec
Lin(pos1) // traslazione sopra posizione
di presa
:
8. Comando a programma
56 Festo GDCP-CMXR-SW-IT it 0909a
Sequenza di movimento:
8.9.2 Istruzione WAIT con condizione <WAIT>
L'istruzione WAIT con condizione permette l'interrogazione di stati binari. Questi stati possono consistere in una singola variabile booleana, in una combinazione di più variabili o in un'interrogazione.
L'istruzione WAIT viene elaborata nel calcolo preliminare dei record, cioè nella fase di calcolo preliminare del controller CMXR. Se la condizione non è soddisfatta, il calcolo preliminare dei record viene arrestato finché non viene soddisfatta la condizione dell'istruzione WAIT.
Se il ritardo temporale è talmente elevato che persino l'esecuzione principale del programma di movimenti raggiunge l'istruzione WAIT, anch'essa viene arrestata, provocando un arresto del movimento. L'esecuzione del programma e il calcolo preliminare vengono proseguiti solamente dopo che la condizione dell'istruzione WAIT è stata soddisfatta.
Tempo di attesa
di 70 msec
Tempo
Velocità di avanzamento
pos1
pos1
pos2
Lin(pos1)
Lin(pos2)
Lin(pos3)
Lin(pos4)
Lin(pos5)
Wait sensor
Lin(pos6)
Lin(pos7)
Lin(pos8)
Lin(pos9)
Elaborazione
principale dei
record
Calcolo
preliminare dei
record
Lin(pos1)
Lin(pos2)
Lin(pos3)
Lin(pos4)
Lin(pos5)
Wait sensor
Lin(pos6)
Lin(pos7)
Lin(pos8)
Lin(pos9)
Elaborazione
principale dei
record
Calcolo
preliminare dei
record
Condizione per WAIT soddisfatta, il calcolo
preliminare dei record viene proseguito.
Condizione per WAIT non soddisfatta, il
calcolo preliminare dei record si arresta
finché la condizione non viene soddisfatta.
8. Comando a programma
Festo GDCP-CMXR-SW-IT it 0909a 57
Nota
Poiché l'interrogazione della condizione avviene durante il calcolo preliminare dei record, un'eventuale modifica eseguita dopo il calcolo preliminare non viene più registrata. Se lo si desidera, anteponendo l'istruzione WaitTime (vedi capitolo 8.9.1 Istruzione WAIT con indicazione del tempo a pagina 54) è possibile forzare una sincronizzazione con l'elaborazione effettiva dei record.
Nella condizione dell'istruzione WAIT si possono utilizzare i tipi di dati base BOOL, REAL e DINT con operatori logici e operatori di comparazione. Non è consentito utilizzare opera-tori aritmetici e operatori di bit.
Sintassi
WAIT <condizione>
Esempio:
Mediante un piano inclinato i pezzi vengono alimentati in un sistema di manipolazione. Un pezzo presente viene rilevato da un sensore digitale e può quindi essere prelevato dal sistema di manipolazione.
Il sensore rileva se un pezzo si trova sul vassoio. Se il pezzo è presente, viene prelevato dal sistema di manipolazione.
Estratto dal programma di movimenti:
:
Sensore
X
Z
Ventosa
Pezzo
Vassoio
Pos2
Pos1
Pos3
Pos4
8. Comando a programma
58 Festo GDCP-CMXR-SW-IT it 0909a
Lin(pos2) // traslazione sopra il pezzo
Vacuum.Set() // vuoto inserito
WAIT sensor // attesa del pezzo
Lin(pos1) // traslazione verso il pezzo
Lin(pos2) // traslazione sopra il pezzo
Lin(pos3) // traslazione sopra vassoio
Lin(pos4) // deposizione del pezzo
WaitTime(0) // attesa dell'elaborazione principale
dei record
Vacuum.Reset() // vuoto disinserito
Lin(pos3) // traslazione sopra vassoio
:
Se nel vassoio non c'è nessun pezzo, il sistema di manipolazione rimane in attesa sopra il pezzo, il movimento è arrestato. Appena il sensore segnala “Pezzo presente”, il programma viene proseguito. Se all'avviamento è già presente un pezzo, il sistema di manipolazione si porta subito sull'oggetto senza che il movimento venga interrotto.
8.9.3 Istruzione WaitOnPath con indicazione del tempo <WaitOnPath>
La macro WaitOnPath genera un tempo di attesa che influisce solo sul movimento. Questo tempo di attesa viene registrato direttamente nella pianificazione della traiettoria e gli assi vengono rallentati con la dinamica programmata. Al termine del tempo di attesa viene proseguita la traiettoria successiva. Il calcolo preliminare dei record del programma FTL non viene fermato.
Nota
La macro WaitOnPath non è indicata per sincronizzare istruzioni quali ad es. la commutazione di un'uscita o la descrizione di una variabile con l'esecuzione principale del programma.
Sintassi
WaitOnPath ( <timeMS> : DINT )
Parametro Significato Unità
time Tempo di attesa msec
Tabella 8.1 Parametri dell'istruzione WaitOnPath
8. Comando a programma
Festo GDCP-CMXR-SW-IT it 0909a 59
Esempio:
Con un punzone viene impressa una marcatura su un pezzo. Al raggiungimento della posizione di stampa è necessario osservare un tempo di attesa di 150 msec per la trasmissione del colore. Il calcolo preliminare dei record non deve tuttavia fermarsi.
:
Lin(pos1) // corsa su posizione di sicurezza
Lin(printPos) // corsa su posizione di stampa
WaitOnPath(150) // attesa di 150 msec
Lin(pos1) // corsa su posizione di sicurezza
:
Tempo di attesa
di 150 msec
Tempo
Velocità di avanzamento
pos1
pos1
printPos
8. Comando a programma
60 Festo GDCP-CMXR-SW-IT it 0909a
8.9.4 Istruzione WaitOnPos con indicazione del tempo <WaitOnPos>
La macro WaitOnPos arresta il calcolo preliminare dei record finché il segmento attuale non viene elaborato per il valore percentuale indicato. Dopodiché il programma viene proseguito.
Sintassi
WaitOnPos ( OPT <pos> : REAL )
Parametro Significato Unità
Pos Valore percentuale per la lunghezza del
segmento di traiettoria
percentuale
Tabella 8.2 Parametri dell'istruzione WaitOnPos
Se è attivata la funzione di approssimazione e la distanza dal punto di destinazione per
l'approssimazione è sufficientemente grande, l'approssimazione viene eseguita. Il parametro del valore percentuale è opzionale. Se non viene indicato, corrisponde al valore 100 %. La conseguenza è un arresto sulla traiettoria.
Nell'esempio seguente viene accostata una posizione e il calcolo preliminare dei record
viene arrestato finché non viene percorso l'80 % del segmento di traiettoria. Dopodiché la variabile Index nell'esempio viene impostata su 10.
Lin(Pos1)
Lin(Pos2)
WaitOnPos(80)
Index := 10
Pos2
Pos1
80 %
8. Comando a programma
Festo GDCP-CMXR-SW-IT it 0909a 61
8.10 Inserimento di commenti <//>
Un commento viene iniziato con la sequenza di caratteri “//”. Può trovarsi da solo all'inizio di una riga o dopo un'istruzione FTL e termina alla fine della riga.
Sintassi
// <testo a piacere>
Un'istruzione FTL può essere “commentata” con caratteri di commento. Questa istruzione non avrà poi alcun effetto sull'elaborazione del programma.
La figura seguente mostra la maschera di programma dell'unità di comando manuale con un commento e un'istruzione di programma commentata:
8.11 Disattivazione di una riga di programma <##>
Con la sequenza di caratteri “##” vengono disattivate righe di programma per l'elaborazione del programma, ma il controllo della sintassi rimane attivo.
Nota
## <istruzione di programma>
In altre parole:
Un'istruzione FTL disattivata non viene elaborata nel programma, cioè i suoi contenuti non hanno alcun effetto.
I contenuti dell'istruzione di programma vengono sottoposti al controllo della sintassi dal compilatore. Se ad es. viene cancellata una variabile utilizzata, all'avvio del programma viene emesso un errore.
8. Comando a programma
62 Festo GDCP-CMXR-SW-IT it 0909a
Nota
Per le istruzioni di programma composte da più righe, come ad es. IF..THEN…ELSE, occorre disattivare tutte le relative righe di programma.
La figura seguente mostra la maschera di programma dell'unità di comando manuale con istruzioni di programma disattivate nelle righe 8 ... 10:
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it 0909a 63
9. Istruzioni di movimento I movimenti di una cinematica vengono attivati con le istruzioni di movimento, che descrivono il movimento dalla posizione attuale al punto di destinazione specificato. Per il movimento vengono considerati i valori impostati in precedenza, come ad es. velocità, accelerazione o orientamento.
I movimenti possono essere di vario tipo. Esistono movimenti con interpolazione degli assi (movimenti point-to-point) e movimenti in uno spazio cartesiano. I movimenti cartesiani fanno riferimento ad una trasformazione interna della cinematica.
9.1 Descrizione della posizione
Tutte le posizioni vengono memorizzate nelle cosiddette variabili di posizione. Queste
variabili di posizione sono necessarie per l'indicazione della posizione nelle istruzioni di movimento. Un'indicazione diretta con le costanti non è possibili. Tutte le variabili di posizione vengono memorizzate nel file di dati corrispondente (vedi capitolo 3.8 File di dati FTL a pagina 20).
Una posizione può essere specificata nel sistema di coordinate degli assi o in un sistema di coordinate cartesiano. Poiché queste indicazioni di posizione hanno un'origine diversa, esistono 2 tipi di dati corrispondenti:
1. AXISPOS per l'indicazione nel sistema di coordinate degli assi,
2. CARTPOS per l'indicazione nel sistema di coordinate cartesiano
Il numero di assi nel CMXR è limitato a 6. Questi assi possono essere suddivisi in assi
cinematici e assi ausiliari. Le posizioni di tutti gli assi vengono memorizzate in una variabile di posizione.
In questo modo il tipo di dati AXISPOS include 9 valori di coordinate. A causa del numero massimo di 6 gradi di libertà, anche il tipo di dati CARTPOS include 9 valori di coordinate, che tuttavia si dividono in 3 indicazioni di posizione, 3 indicazioni di orientamento e 3 assi ausiliari.
Nell'ambiente di programmazione del PlugIn FCT, il numero dei valori di coordinate è limitato al numero degli assi configurati, il resto è bloccato.
Nota
Entrambi i tipi di dati AXISPOS e CARTPOS possono essere utilizzati per istruzioni di movimento. Il controller CMXR esegue automati-camente le conversioni (trasformazioni delle coordinate) in caso di necessità. Informazioni al riguardo sono riportate nella descrizione dell'istruzione.
I tipi di dati AXISPOS e CARTPOS sono del tipo strutturato (vedi capitolo 5.5 Tipi di dati strutturati a pagina 31).
9. Istruzioni di movimento
64 Festo GDCP-CMXR-SW-IT it 0909a
9.1.1 Posizione dell'asse
Una posizione dell'asse viene descritta con il tipo di dati strutturato AXISPOS (vedi capitolo 5.5 Tipi di dati strutturati a pagina 31). Esso comprende 9 posizioni di 9 assi singoli, il cui valore di posizione viene indicato con il tipo di dati REAL. A seconda del modello cinematico selezionato può trattarsi di una selezione o una combinazione di assi lineari o rotativi. L'unità di una posizione viene quindi espressa ad es. in mm o gradi.
Struttura:
A causa del numero massimo di 9 assi di una cinematica, il tipo di dati comprende 9 posizioni di assi. Questi singoli valori di posizione sono memorizzati in 9 singole variabili REAL.
Tipo di dati AXISPOS:
a1 : REAL Posizione asse cinematica 1
a2 : REAL Posizione asse cinematica 2
a3 : REAL Posizione asse cinematica 3
a4 : REAL Posizione asse cinematica 4
a5 : REAL Posizione asse cinematica 5
a6 : REAL Posizione asse cinematica 6
a7 : REAL Posizione asse ausiliario 1
a8 : REAL Posizione asse ausiliario 2
a9 : REAL Posizione asse ausiliario 3
Il tipo di dati AXISPOS descrive la configurazione massima possibile di una posizione dell'asse. Se alcuni assi non sono presenti, l'indicazione della posizione per questi assi è irrilevante. Di norma per questi assi viene indicato il valore di posizione 0. Nell'editor FCT i campi di questi assi sono bloccati.
Ogni singolo valore di un valore di posizione del tipo AXISPOS è accessibile mediante il nome della singola posizione.
Esempio:
Variabile:
startPos : AXISPOS := (100, 50, 30, 0, 0, 0, 0, 0, 0)
posA1 : REAL
posA2 : REAL
Programma:
:
Lin(startPos) // corsa su startPos
posA1 := startPos.a1 // ripristino del valore asse 1
posA2 := startPos.a2 // ripristino del valore asse 2
:
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it 0909a 65
L'assegnazione di singoli assi alla struttura di dati della posizione AXISPOS avviene
tramite una numerazione. Questa numerazione è già stata eseguita durante la configura-zione degli assi della cinematica. Analogamente a questa numerazione avviene anche l'assegnazione ai singoli assi durante l'indicazione di posizione del tipo di dati AXISPOS.
Esempio:
Portale tridimensionale cartesiano con 3 assi lineari e un asse di rotazione (rotazione della
pinza). Nella configurazione viene definito quanto segue:
Asse 1 = Asse X
Asse 2 = Asse Y
Asse 3 = Asse Z
Asse 4 = Asse di rotazione pinza
Gli assi 5 e 6 non sono presenti, nessun asse ausiliario.
Analogamente a questa numerazione viene eseguita l'assegnazione nel tipo di dati Axispos:
a1 : REAL Posizione Asse 1 = Asse X
a2 : REAL Posizione Asse 2 = Asse Y
a3 : REAL Posizione Asse 3 = Asse Z
a4 : REAL Posizione Asse 4 = Asse di rotazione pinza
a5 : REAL Posizione Asse 5, non presente
a6 : REAL Posizione Asse 6, non presente
a7 : REAL Posizione Asse ausiliario 1, non presente
a8 : REAL Posizione Asse ausiliario 2, non presente
a9 : REAL Posizione Asse ausiliario 3, non presente
9. Istruzioni di movimento
66 Festo GDCP-CMXR-SW-IT it 0909a
9.1.2 Posizione cartesiana
A differenza della posizione dell'asse del tipo di dati AXISPOS, il tipo di posizione cartesiano CARTPOS descrive una posizione in un sistema di coordinate cartesiano.
Un corpo possiede al massimo 6 gradi di libertà. Mediante questi valori è possibile determinare la posizione e l'orientamento del corpo nello spazio. Questi 6 gradi di libertà vengono descritti con 6 indicazioni nel tipo di dati CARTPOS. Inoltre viene indicata la posizione dei 3 assi ausiliari. Questa indicazione avviene però in una posizione dell'asse, in quanto con gli assi ausiliari non si possono eseguire movimenti cartesiani. Vengono interpolati sulla posizione di arrivo insieme agli assi della cinematica, tuttavia gli assi ausiliari eseguono un'interpolazione point-to-point (Ptp).
Struttura:
Tipo di dati CARTPOS
x : REAL Scostamento lungo l'asse X
y : REAL Scostamento lungo l'asse Y
z : REAL Scostamento lungo l'asse Z
a : REAL Indicazione di orientamento, rotazione intorno all'asse Z
b : REAL Indicazione di orientamento, rotazione intorno all'asse Y ruotato
c : REAL Indicazione di orientamento, rotazione intorno all'asse Z ruotato
aux1 : REAL Posizione asse ausiliario 1
aux2 : REAL Posizione asse ausiliario 2
aux3 : REAL Posizione asse ausiliario 3
A seconda della cinematica selezionata e del relativo grado di libertà, alcune indicazioni non sono possibili in una posizione cartesiana. Le singole indicazioni di posizione nel tipo di dati CARTPOS non sono correlate agli assi fisici della cinematica, bensì al loro grado di libertà.
La posizione cartesiana comprende le indicazioni per un massimo di 6 gradi di libertà. X, Y e Z sono le posizioni traslatorie, mentre A, B e C descrivono gli orientamenti della posizione. L'orientamento, come nell'intero sistema, viene indicato secondo la convenzione di Eulero ZYZ.
Il tipo di dati CARTPOS è strutturato come il tipo di dati AXISPOS (vedi capitolo 5.5 Tipi di dati strutturati a pagina 31). L'accesso a singoli valori di posizione avviene mediante il
nome dei singoli valori del tipo di dati.
Esempio:
Variabile:
startPos : CARTPOS := (1050, 130, 30, 0, 0, 0, 0, 0, 0)
newPos : CARTPOS := (0, 0, 0, 0, 0, 0, 0, 0, 0)
posX : REAL
posY : REAL
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it 0909a 67
Programma:
:
Lin(startPos) // corsa su StartPos
newPos := startPos // copia di StartPos
newPos.x := newPos.x + 10 // calcolazione di X
newPos.y := newPos.y + 35.7 // calcolazione di Y
Lin(newPos) // corsa sulla posizione
calcolata
:
L'effetto delle singole indicazioni di posizione e di orientamento cartesiane dipende dai gradi di libertà della cinematica.
Esempio:
È data una cinematica parallela (tripode) con 3 assi principali, senza polsi. Con i 3 assi principali presenti vengono coperti i 3 gradi di libertà traslatori X, Y e Z. Poiché non è presente alcun polso, non è possibile eseguire l'orientamento dell'utensile. Una programmazione delle variabili a, b, c, aux1, aux2 o aux3 nell'indicazione di posizione del tipo di dati CARTPOS non ha alcun effetto.
9.2 Movimento point-to-point <Ptp>
Il movimento point-to-point (PTP) è la possibilità più rapida per traslare la punta
dell'utensile (TCP) nella posizione desiderata. Il movimento PTP è un'istruzione di traslazione punto a punto sincrona con posizione di arrivo. Con questa istruzione tutti gli assi vengono avviati contemporaneamente e raggiungono contemporaneamente la posizione di arrivo programmata. Per il movimento vengono utilizzati i valori dinamici attivi in quel momento, ad es. velocità e accelerazione. La dinamica effettiva risulta dalla combinazione delle dinamiche di tutti gli assi interessati al movimento. L'asse più lento determina la dinamica. Il movimento della punta (TCP) risulta in questo caso dalla combinazione del movimento dei singoli assi. Il movimento sulla TCP è indefinito.
9. Istruzioni di movimento
68 Festo GDCP-CMXR-SW-IT it 0909a
Attenzione
Poiché durante un movimento PTP non viene mantenuta una traiettoria, bensì gli assi vengono solo interpolati sulla posi-zione di arrivo, possono verificarsi accelerazioni e velocità imprevedibili sull'utensile (TCP). Controllare quindi che i movimenti non provochino la perdita o il danneggiamento del pezzo e/o dell'utensile.
A causa dell'interpolazione degli assi, durante un movimento PTP non è possibile tenere in considerazione i dati utensile. Quindi prestare sempre attenzione agli utensili utilizzati e proteggerli da possibili danneggiamenti.
Per ridurre al minimo il pericolo di collisioni è opportuno testare tutti i movimenti PTP a una velocità ridotta, utilizzando ad es. l'override.
Sintassi
Ptp ( <Pos> : AXISPOS o CARTPOS)
Parametro Significato Unità
Pos Posizione di arrivo AXISPOS o CARTPOS
Tabella 9.1 Parametri dell'istruzione PTP
L'indicazione della posizione può avvenire nel sistema cartesiano o nel sistema di coordinate degli assi (riferita ad ogni singolo asse). Il controller multiassiale CMXR trasforma poi le posizioni in maniera corrispondente.
Esempio:
Si deve posizionare un portale cartesiano con 3 assi X, Y, Z e un asse rotativo con pinza.
1 Asse Y
2 Asse Z
3 Asse rotativo
con pinza
4 Asse X
2
1
4
3
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it 0909a 69
Variabile:
pos1 : CARTPOS := (100, 50, 100, 0, 0, 0, 0, 0, 0)
pos2 : CARTPOS := (600, 550, 100, 180, 0, 0, 0, 0, 0)
Programma:
:
Ptp(pos1)
Ptp(pos2)
:
Nell'esempio è visibile l'andamento della traiettoria dell'asse Z e della punta dell'utensile (TCP). A causa della disposizione verticale della cinematica cartesiana, l'andamento della traiettoria sull'asse Z è diritto. Poiché l'utensile presenta uno spostamento verso l'asse Z, nell'andamento della sua traiettoria si verifica un comportamento imprevedibile dato che, per effetto dell'interpolazione sincrona, tutti gli assi si portano insieme sul proprio punto di arrivo senza tener conto della traiettoria percorsa.
X
Y
Asse rotativo
a 0 gradi
Asse rotativo a 90 gradi
Andamento approssimativo della traiettoria su TCP
Andamento della traiettoria sull'asse Z
Asse rotativo a 180 gradi
9. Istruzioni di movimento
70 Festo GDCP-CMXR-SW-IT it 0909a
9.3 Movimento point-to-point relativo <PtpRel>
L'istruzione PTP relativo funziona in modo analogo alla funzione PTP, con la differenza che la posizione viene indicata in relazione alla posizione di partenza. L'indicazione della posizione viene sommata alla posizione di partenza.
Una possibile applicazione sarebbe ad es. un posizionamento relativo all'interno di una griglia, come nel caso di un pallet.
Sintassi
PtpRel (<Dist> : AXISDIST o CARTDIST)
Parametro Significato Unità
Dist Distanza relativa da percorrere AXISDIST o CARTDIST
Tabella 9.2 Parametri dell'istruzione PtpRel
L'indicazione della distanza può avvenire nel sistema cartesiano o nel sistema di coordinate degli assi. Il controller CMXR trasforma poi le posizioni in maniera corrispondente.
Esempio:
In un'applicazione di manipolazione un pezzo viene accostato ad un'unità di misurazione in 4 posizioni.
pos2
X-Achse
Asse Z
300
850
207
100
pos3
pos1
150
110
225
1
2
3
4
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it 0909a 71
Variabile:
:
pos1 : CARTPOS := (100, 0, 300, 0, 0, 0, 0, 0, 0)
pos2 : CARTPOS := (207, 0, 225, 0, 0, 0, 0, 0, 0)
pos3 : CARTPOS := (850, 0, 300, 0, 0, 0, 0, 0, 0)
distX : CARTDIST := (110, 0, 0, 0, 0, 0, 0, 0, 0)
distZpos : CARTDIST := (0, 0, 150, 0, 0, 0, 0, 0, 0)
distZneg : CARTDIST := (0, 0, -150, 0, 0, 0, 0, 0, 0)
:
Programma:
:
Ptp(pos1)
Ptp(pos2)
LOOP 3 DO
PtpRel(distZneg)
CALL Check() // richiamo ciclo di prova
PtpRel(distZpos)
PtpRel(distX)
END_LOOP
PtpRel(distZneg)
CALL Check() // richiamo ciclo di prova
PtpRel(distZpos)
PtpRel(distX)
Ptp(pos3)
:
Il ciclo di misura per il pezzo e l'analisi vengono elaborati nel sottoprogramma “Verifica”. A scopo di semplificazione, il contenuto del sottoprogramma non è visualizzato.
9. Istruzioni di movimento
72 Festo GDCP-CMXR-SW-IT it 0909a
9.4 Movimento di un asse, <MoveAxisPtp>, <MoveAxisCart>
Con le istruzioni MoveAxisPtp e MoveAxisCart è possibile posizionare un asse della
cinematica con un movimento PTP o un movimento cartesiano. La posizione di arrivo dell'asse viene indicata come assoluta.
Sintassi
MoveAxisPtp (<Axis> : ENUM, <Pos> : REAL)
MoveAxisCart (<CartComp> : ENUM, <Pos> : REAL)
Parametro Significato Unità
Axis Asse fisico selezionato per la
traslazione.
Enumerazione con i valori da A1
a A9 per gli assi da 1 a 9
Pos Posizione di arrivo assoluta Unità dell'asse definito
Tabella 9.3 Parametri dell'istruzione MoveAxisPtp
Parametro Significato Unità
CartComp Asse cartesiano selezionato per
la traslazione.
Enumerazione con i valori X Y Z ;
A B C
Pos Posizione di arrivo cartesiana
assoluta
Unità dell'asse definito
Tabella 9.4 Parametri dell'istruzione MoveAxisCart
Poiché in questo caso si tratta di un singolo asse, il movimento viene eseguito tenendo in considerazione eventuali limitazioni (ad es. override) con la dinamica completa dell'asse.
Esempio:
Una struttura cinematica cartesiana è composta da 4 assi: Asse 1 = Asse X Asse 2 = Asse Y
Asse 3 = Asse Z Asse 4 = Asse rotativo dell'utensile
Nell'esempio, un pezzo deve essere prelevato da una posizione e deposto in un'altra posizione. A tale scopo l'asse rotativo deve essere posizionato in maniera corrispondente.
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it 0909a 73
Variabile:
:
pos1 : CARTPOS := (300, 0, 250, 0, 0, 0, 0, 0, 0)
takeAbove : CARTPOS := (350, 0, 145, 0, 0, 0, 0, 0, 0)
pos2 : CARTPOS := (575, 0, 250, 0, 0, 0, 0, 0, 0)
takePos : REAL := 96.5
:
Programma con movimenti PTP:
:
Ptp(pos1) // accostamento
Ptp(takeAbove) // prelievo in alto
MoveAxisPtp(A4, takePos) // rotazione pinza
MoveAxisPtp(A3, 50) // verso il basso
Gripper.Set() // chiusura pinza
MoveAxisPtp(A3, 145) // verso l'alto
MoveAxisPtp(A1, 450) // deposizione in alto
MoveAxisPtp(A4, 180) // rotazione su vassoio
MoveAxisPtp(A3, 50) // deposizione in basso
Gripper.Reset() // apertura pinza
MoveAxisPtp(A3, 145) // deposizione in alto
Ptp(pos2) // allontanamento
:
pos2
X-Achse
Asse Z
50
575
450
145
pos1
prelievo in alto
prelievo in basso
deposizione in alto
deposizione in basso
250
350
300
9. Istruzioni di movimento
74 Festo GDCP-CMXR-SW-IT it 0909a
9.5 Movimento lineare <Lin>
Per un movimento lineare il controller multiassiale CMXR calcola una linea retta che si estende dalla posizione corrente (posizione di partenza) alla posizione programmata (posizione di arrivo). Questo movimento viene calcolato ed eseguito tenendo in considerazione i valori impostati per la traiettoria, come ad es. accelerazione lungo la traiettoria, velocità di avanzamento, orientamenti e dati dell'utensile. Se nell'indicazione della posizione di arrivo viene specificata una modifica dell'orientamento, la traslazione su questa traiettoria avverrà in modo continuo dall'orientamento iniziale sul punto di partenza fino all'orientamento finale.
Il movimento lineare è un movimento cartesiano, ossia il movimento viene calcolato per la cinematica corrente con l'ausilio della trasformazione delle coordinate eseguita internamente. Viene sempre programmata la posizione sulla punta dell'utensile (TCP).
Anche tutti i valori dinamici, quali accelerazione e velocità di avanzamento lungo la traiettoria, vengono ottenuti direttamente sul TCP. Ciò presenta il vantaggio che i valori dinamici per l'utensile sono limitati e noti. Sull'unità pinza agiscono quindi delle forze riproducibili.
Sintassi
Lin (<Pos> : AXISPOS o CARTPOS)
Parametro Significato Unità
Pos Posizione di arrivo
assoluta
AXISPOS o CARTPOS
Tabella 9.5 Parametri dell'istruzione Lin
L'indicazione della posizione può avvenire nel sistema cartesiano o nel sistema di coordinate degli assi. Il controller multiassiale CMXR trasforma poi le posizioni in maniera corrispondente.
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it 0909a 75
Esempio:
Si deve posizionare un portale cartesiano con 3 assi X, Y, Z e un asse rotativo sulla pinza. La punta dell'utensile (TCP) è definita con un vettore sul punto centrale della pinza (vedi capitolo 14 Utensili a pagina 122).
Variabile:
:
pos1 : CARTPOS := (100, 50, 100, 0, 0, 0, 0, 0, 0)
pos2 : CARTPOS := (600, 550, 100, 180, 0, 0, 0, 0, 0)
gripper : TCPTOOL := (-100, 0, 97, 0, 0, 0,)
:
Programma:
:
Tool(gripper)
Lin(pos1)
Lin(pos2)
:
Asse X
Asse Y
Asse Z
Asse rotativo con pinza
Vettore su TCP
9. Istruzioni di movimento
76 Festo GDCP-CMXR-SW-IT it 0909a
Come raffigurato, con un movimento lineare il TCP (punta dell'utensile) viene condotto lungo la traiettoria. Tutte le indicazioni di velocità si riferiscono sempre al TCP, e in questo modo viene definito l'andamento della traiettoria. Non è invece prevedibile l'andamento della traiettoria della flangia dell'utensile nel piano X-Y. L'andamento di questa traiettoria risulta dalla costellazione della cinematica e del vettore rispetto al TCP e viene calcolato mediante la trasformazione interna delle coordinate.
9.6 Movimento lineare relativo <LinRel>
L'istruzione Lin relativo funziona in modo analogo alla funzione Lin. In questo caso l'indicazione della posizione viene sommata alla posizione di partenza.
Una possibile applicazione sarebbe ad es. un posizionamento relativo all'interno di una griglia, come nel caso di un pallet.
Sintassi
LinRel (<Dist> : AXISDIST o CARTDIST)
Parametro Significato Unità
Dist Posizione di arrivo relativa AXISDIST o CARTDIST
Tabella 9.6 Parametri dell'istruzione LinRel
La distanza può essere specificata nel sistema cartesiano o nel sistema di coordinate degli assi. Il controller multiassiale CMXR trasforma poi le posizioni in maniera corrispondente.
X
Y
Asse rotativo
a 0 gradi
Asse rotativo a 90 gradi
Asse rotativo a 180 gradi
Andamento
della traiettoria
su TCP Andamento approssimativo
della traiettoria sull'asse Z
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it 0909a 77
Esempio:
Un contorno contiene tratti di traiettoria che si ripetono. Questi tratti possono essere descritti in modo relativo. Mediante una programmazione a cicli è possibile risolvere facilmente una simile applicazione.
Variabile:
:
pos1 : CARTPOS := (98.5, 100, 0, 0, 0, 0, 0, 0, 0)
pos2 : CARTPOS := (387, 100, 0, 0, 0, 0, 0, 0, 0)
distX : CARTDIST := (57, 0, 0, 0, 0, 0, 0, 0, 0)
distYpos : CARTDIST := (0, 112, 0, 0, 0, 0, 0, 0, 0)
distYneg : CARTDIST := (0, -112, 0, 0, 0, 0, 0, 0, 0)
pos3 : CARTPOS := (1050, 45, 0, 0, 0, 0, 0, 0, 0)
direction : BOOL
:
pos2
X-Achse
Y-Achse
100
1050
387
98.5
45
pos3
pos1
57
112
9. Istruzioni di movimento
78 Festo GDCP-CMXR-SW-IT it 0909a
Programma:
:
Lin(pos1)
Lin(pos2)
direction := TRUE
LOOP 5 DO
IF direction = TRUE THEN
LinRel(distYpos)
ELSE
LinRel(distYneg)
END_IF
LinRel(distX)
direction := NOT direction
END_LOOP
LinRel(distYneg)
Lin(pos3)
:
Con la variabile “direction” viene definita la direzione del movimento relativo dell'asse Y. In questo modo è possibile programmare il movimento con un ciclo di istruzioni.
9.7 Movimento circolare con punto di appoggio
L'interpolazione circolare si differenzia dall'interpolazione lineare non solo per la forma geometrica ma anche per il fatto che, oltre al punto di partenza e al punto finale, occorre indicare anche un punto di appoggio per poter definire il cerchio in modo univoco.
9.7.1 Funzionamento
La definizione del cerchio si effettua con un punto di appoggio, che si deve trovare
sull'orbita circolare, e il punto finale dell'orbita stessa. In caso d'orbita circolare viene accostato prima il punto di appoggio e poi il punto finale. Il raggio dell'orbita circolare risulta da un calcolo interno comprendente punto di partenza, punto di appoggio e punto finale dell'orbita stessa.
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it 0909a 79
La figura seguente mostra un movimento circolare con l'uso di un punto di appoggio:
Il cerchio viene sempre percorso in modo tale che il TCP si sposti dal punto di partenza al
punto finale passando per il punto di appoggio. Il punto di appoggio si trova sempre, per definizione, tra il punto di partenza e il punto finale.
Limitazioni:
Viene emesso un messaggio d'errore se almeno due delle posizioni che definiscono il cerchio occupano la stessa posizione o se tutti i punti si trovano su una linea retta. In questi casi non è possibile calcolare matematicamente l'orbita circolare.
Con questo metodo non può essere descritto un cerchio completo (360°). Perciò un cerchio completo deve essere suddiviso in 2 semicerchi.
L'orientamento del punto di appoggio non viene considerato ai fini dell'interpolazione dell'arco di cerchio. L'interpolazione viene eseguita esclusivamente tra il punto di partenza e il punto finale. Se occorre modificare gli orientamenti all'interno di un arco di cerchio, è possibile scomporre un arco di cerchio in più parti e poi impostare gli orientamenti desiderati sul punto di partenza e sul punto finale.
9.7.2 Definizione del piano
L'orbita circolare viene percorsa su un piano definito sulla scorta dei 3 punti, punto
iniziale, punto di appoggio e punto finale. Il piano sul quale viene percorsa l'orbita circolare si estende nello spazio in base a questa definizione.
Punto di appoggio
Punto iniziale
Punto finale
Punto di appoggio
Punto iniziale
Punto finale
9. Istruzioni di movimento
80 Festo GDCP-CMXR-SW-IT it 0909a
La figura mostra un'orbita circolare con i suoi 3 punti di appoggio che definiscono, nello spazio, il piano su cui si trova l'orbita stessa.
Nota
L'orbita circolare si trova sempre su un piano, non è possibile un'interpolazione a vite che richiede un'interpolazione supplementare perpendicolare al piano.
Punto di appoggio
Punto iniziale
Punto finale
Piano definito da 3 punti
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it 0909a 81
9.7.3 Istruzione circolare con punto di appoggio <CircIp>
L'istruzione circolare con punto di appoggio ha la seguente sintassi di programma:
Sintassi
CircIp (<IpPos> : AXISPOS o CARTPOS,
<Pos> : AXISPOS o CARTPOS)
Parametro Significato Unità
IpPos Punto di appoggio sul cerchio AXISPOS o CARTPOS
Pos Posizione terminale dell'arco di
cerchio
AXISPOS o CARTPOS
Tabella 9.7 Parametri dell'istruzione CircIp
L'indicazione delle posizioni può avvenire nel sistema cartesiano o nel sistema di coordinate degli assi. Il controller multiassiale CMXR trasforma poi le posizioni in maniera corrispondente.
Avvertenza
L'istruzione circolare richiede l'indicazione del punto di appoggio e del punto finale. Il punto di partenza viene formato dal punto finale del movimento precedente. Se tale punto viene spostato, si ha una variazione dell'orbita circolare. Questa variazione potrebbe essere indesiderata e provocare una collisione. La variazione del punto di partenza non deve provocare messaggi di errore perché il risultato è matematicamente corretto.
9. Istruzioni di movimento
82 Festo GDCP-CMXR-SW-IT it 0909a
Esempio:
Con una cinematica si deve percorrere il contorno seguente:
L'asse Z rimane sulla coordinata 0. Il punto di partenza dell'arco di cerchio viene accostato mediante un'istruzione di traslazione separata, ad es. Ptp o Lin.
Variabili:
:
pos1 : CARTPOS := (950, 500, 0, 0, 0, 0, 0, 0, 0)
pos2 : CARTPOS := (455, 300, 0, 0, 0, 0, 0, 0, 0)
IpPos : CARTPOS := (1050, 400, 0, 0, 0, 0, 0, 0, 0)
EndPos : CARTPOS := (950, 300, 0, 0, 0, 0, 0, 0, 0)
:
Programma:
:
Lin(pos1) // accostamento punto di partenza
CircIp(IpPos, EndPos) // movimento circolare su punto
finale
Lin(pos2) // allontanamento
:
Posizione pos1
Punto di appoggio IpPos
Punto finale EndPos
Posizione pos2
Asse X
Asse Y
300
400
500
1050
950
455
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it 0909a 83
9.7.4 Istruzione circolare con punto di appoggio, accostamento PTP <PtpToCircIp>
Rispetto all'istruzione circolare CircIp, questa istruzione ha il punto di partenza dell'arco di
cerchio nella lista di parametri. Ciò presenta il vantaggio che l'arco di cerchio viene descritto in modo coerente. Il punto di partenza dell'arco di cerchio viene accostato con un'istruzione PTP. Per il resto il comportamento è uguale a quello dell'istruzione CircIp.
Poiché per l'accostamento del punto di partenza viene utilizzato un movimento PTP e per l'interpolazione circolare un movimento cartesiano, non è possibile né l'approssimazione geometrica né una velocità di avanzamento costante. L'approssimazione viene eseguita in base alle possibilità di un movimento PTP.
Sintassi
PtpToCircIp (<StartPos> : AXISPOS o CARTPOS,
<IpPos> : AXISPOS o CARTPOS,
<Pos> : AXISPOS o CARTPOS)
Parametro Significato Unità
StartPos Punto di partenza dell'arco di cerchio AXISPOS o CARTPOS
IpPos Punto di appoggio dell'arco di cerchio AXISPOS o CARTPOS
Pos Punto finale dell'arco di cerchio AXISPOS o CARTPOS
Tabella 9.8 Parametri dell'istruzione PtpToCircIp
L'indicazione delle posizioni può avvenire nel sistema cartesiano o nel sistema di coor-dinate degli assi. Il controller multiassiale CMXR trasforma poi le posizioni in maniera corrispondente.
9. Istruzioni di movimento
84 Festo GDCP-CMXR-SW-IT it 0909a
Esempio:
Con una cinematica si deve percorrere il contorno seguente:
Il piano per l'asse Z è pari a 0. Il punto di partenza dell'arco di cerchio viene accostato con un movimento PTP (Point-To-Point). Il punto di partenza viene trasferito all'istruzione PtpToCircIp.
Variabili:
:
StartPos : CARTPOS := (950, 500, 0, 0, 0, 0, 0, 0, 0)
IpPos : CARTPOS := (1050, 400, 0, 0, 0, 0, 0, 0, 0)
EndPos : CARTPOS := (950, 300, 0, 0, 0, 0, 0, 0, 0)
Pos1 : CARTPOS := (455, 300, 0, 0, 0, 0, 0, 0, 0)
:
Programma:
:
// accostamento PTP, movimento circolare cartesiano
PtpToCircIp(StartPos, IpPos, EndPos)
Lin(Pos1) // allontanamento
:
Posizione di partenza StartPos
Punto di appoggio IpPos
Punto finale EndPos Posizione Pos1
Asse X
Asse Y
300
400
500
1050 950 455
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it 0909a 85
9.7.5 Istruzione circolare con punto di appoggio, accostamento Lin <LinToCircIp>
Come l'istruzione PtpToCircIp, anche l'istruzione LinToCircIp comprende il punto di par-
tenza dell'orbita. L'avvicinamento all'orbita circolare avviene ora in modo cartesiano. Ciò significa che il movimento sul punto di partenza e l'orbita circolare in caso di approssi-mazione possono realizzarsi geometricamente. È possibile anche una velocità di avanzamento costante lungo la traiettoria.
Sintassi
LinToCircIp (<StartPos> : AXISPOS o CARTPOS,
<IpPos> : AXISPOS o CARTPOS,
<Pos> : AXISPOS o CARTPOS)
Parametro Significato Unità
StartPos Punto di partenza dell'arco di cerchio AXISPOS o CARTPOS
IpPos Punto di appoggio dell'arco di cerchio AXISPOS o CARTPOS
Pos Punto finale dell'arco di cerchio AXISPOS o CARTPOS
Tabella 9.9 Parametri dell'istruzione LinToCircIP
L'indicazione delle posizioni può avvenire nel sistema cartesiano o nel sistema di coordinate degli assi. Il controller multiassiale CMXR trasforma poi le posizioni in maniera corrispondente.
Esempio:
Con una cinematica si deve percorrere il contorno seguente:
Il piano per l'asse Z è pari a 0. Il punto di partenza dell'arco di cerchio viene accostato con un movimento lineare. Il punto di partenza viene trasferito all'istruzione LinToCirc.
Posizione di partenza StartPos
Punto di appoggio IpPos
Punto finale EndPos Posizione Pos1
Asse X
Asse Y
300
400
500
1050 950 455
9. Istruzioni di movimento
86 Festo GDCP-CMXR-SW-IT it 0909a
Variabili:
:
StartPos : CARTPOS := (950, 500, 0, 0, 0, 0, 0, 0, 0)
IpPos : CARTPOS := (1050, 400, 0, 0, 0, 0, 0, 0, 0)
EndPos : CARTPOS := (950, 300, 0, 0, 0, 0, 0, 0, 0)
Pos1 : CARTPOS := (455, 300, 0, 0, 0, 0, 0, 0, 0)
:
Programma:
:
// accostamento Lin, movimento circolare cartesiano
LinToCircIp(StartPos, IpPos, EndPos)
Lin(Pos1) // allontanamento
:
9.8 Arresto del movimento <StopMove>
Con l'istruzione StopMove viene arrestata la cinematica e tutti i dati calcolati per la
traiettoria vengono annullati. L'istruzione ha effetto sul calcolo preliminare dei record.
L'arresto della cinematica viene eseguito con la rampa di decelerazione massima definita
per questa evenienza. Eventuali riduzioni della dinamica mediante un comando di override non hanno alcun effetto in caso di arresto.
Sintassi
StopMove()
Una possibile applicazione per questo arresto è ad es. la corsa contro un ostacolo rilevata da un sensore. Una volta rilevato questo stato, il movimento viene arrestato con l'istruzione StopMove. Nel capitolo 20.1 Arresto di movimenti a pagina 194 è descritto un esempio di utilizzo dell'istruzione StopMove.
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it 0909a 87
9.9 Arresto del programma <StopProgram>
L'istruzione StopProgram arresta il programma, che passa così allo stato “arrestato”. L'istruzione corrisponde al tasto di arresto sull'unità di comando manuale. Una continuazione del programma è possibile solo tramite un riavvio, ad es. tramite l'unità di comando manuale o dall'esterno mediante un'unità di comando PLC.
L'istruzione è attiva durante l'elaborazione principale del programma e non viene eseguita dal calcolo preliminare dei record. L'esecuzione delle istruzioni precedenti, calcolate dal calcolo preliminare dei record, è comunque garantita.
L'arresto della cinematica viene eseguito con la rampa di decelerazione massima definita per questa evenienza. Eventuali riduzioni della dinamica mediante un comando di
override non hanno alcun effetto in caso di arresto.
Sintassi
StopProgram()
Esempio:
:
Vel(dynCart, 1000)
Lin(pos1)
Lin(pos2)
SetInfo(“insert workpiece and press start”)
StopProgram()
Lin(pos3)
CALL Conture1
:
10. Istruzioni dinamiche
88 Festo GDCP-CMXR-SW-IT it 0909a
10. Istruzioni dinamiche Con le istruzioni dinamiche è possibile programmare la velocità, l'accelerazione e lo strappo per i movimenti della cinematica. È inoltre possibile impostare separatamente la dinamica dei movimenti point-to-point (PTP) e dei movimenti cartesiani.
Una modifica dei valori dinamici può avvenire in qualsiasi riga di programma desiderata.
Nota
Nella configurazione (Festo Configuration Tool) vengono specificati valori iniziali per la dinamica. Questi valori sono attivi come valori iniziali all'avvio del programma. Se nel programma non viene programmata nessuna dinamica, verranno utilizzati questi valori iniziali. Con le seguenti istruzioni dinamiche è possibile sovrascri-vere questi valori all'interno del programma in qualsiasi momento.
Grafica con l'impostazione dei valori dinamici nel Festo Configuration Tool:
10. Istruzioni dinamiche
Festo GDCP-CMXR-SW-IT it 0909a 89
10.1 Limitazione autom. della dinamica, limitatore dinamico
Per garantire la fedeltà alla traiettoria è necessario confrontare i valori dinamici nominali con i possibili valori dinamici fisici, in modo da escludere un superamento dei valori mas-simi possibili dei singoli assi. I valori in questione riguardano la velocità, l'accelerazione e lo strappo. Questi valori massimi sono memorizzati nella configurazione dei singoli assi.
Il controller CMXR dispone di un limitatore dei valori dinamici, denominato limitatore dinamico. Il limitatore opera nel calcolo preliminare del programma FTL e confronta costantemente i valori dinamici di traslazione con i valori dinamici massimi possibili dei singoli assi.
Nota
Il limitatore dinamico è costantemente attivo e non deve essere attivato.
Un intervento del limitatore dinamico dipende da:
dimensioni della dinamica programmata
costellazione della traiettoria del movimento, dalla quale risultano i valori dinamici per i singoli assi.
Se a causa della dinamica programmata o in seguito alla modifica della traiettoria del movimento viene superato il valore massimo di almeno un asse, la dinamica della traiettoria viene ridotta in modo tale che l'asse venga traslato entro i suoi limiti. La traiet-toria non viene abbandonata. Quando la cinematica esce da una traiettoria di movimento critica ed è possibile un valore dinamico più alto, ciò viene riconosciuto dal sistema che provoca un'accelerazione fino al valore programmato.
Nell'esempio seguente viene raggiunto il limite di un asse, per cui la velocità di avanza-mento viene automaticamente ridotta per garantire la fedeltà alla traiettoria. Appena l'asse abbandona l'area critica, il movimento viene nuovamente accelerato fino al valore programmato.
Velocità di
avanzamento
Limite dell'asse
Riduzione della velocità di
avanzamento
Limite del singolo asse
raggiunto
10. Istruzioni dinamiche
90 Festo GDCP-CMXR-SW-IT it 0909a
10.2 Velocità <Vel>
Con l'istruzione Vel è possibile indicare la velocità per un movimento cartesiano e un
movimento PTP. L'unità di comando riduce i valori indicati, adattandoli alle velocità massime possibili dei singoli assi interessati al movimento. Se si verifica una limitazione a causa delle velocità massima possibili degli assi, viene emesso un messaggio corrispondente.
Sintassi
Vel (<Mode> : ENUM, <Value> : REAL)
Parametro Significato Unità
Mode Tipo di velocità Enumerazione: dynPtp, dynCart
Value Valore di velocità Indicazione della velocità
Tabella 10.1 Parametri dell'istruzione Vel
Enumerazione parametro Mode
Tipo di movimento Unità
dynPtp Point-To-Point %
dynCart cartesiano mm/sec
Tabella 10.2 Unità del parametro Value
Esempio:
Variabile:
:
axis0 : AXISPOS := (-60, -60, 0, 0, 0, 0, 0, 0, 0)
axis1 : AXISPOS := (60, 60, 0, 0, 0, 0, 0, 0, 0)
axis2 : AXISPOS := (100, 60, 0, 0, 0, 0, 0, 0, 0)
:
Programma:
:
Vel(dynPtp, 30) // velocità per PTP al 30 %
Ptp(axis0)
Vel(dynCart, 500) // velocità di avanzamento a
500 mm/sec
Lin(axis1)
speed := 85
Vel(dynPtp, speed) // velocità per PTP all'85 %
Ptp(axis3)
:
10. Istruzioni dinamiche
Festo GDCP-CMXR-SW-IT it 0909a 91
10.3 Accelerazione <Acc>
Impostazione di accelerazione e decelerazione per i movimenti PTP e cartesiani dei polsi. Le istruzioni seguenti vengono ridotte fino al valore specificato. L'unità di comando riduce automaticamente l'accelerazione o la decelerazione in caso di superamento dei valori limite degli assi.
Sintassi
Acc (<Mode> : ENUM, <ValueAcc> : REAL, OPT <ValueDec> : REAL)
Parametro Significato Unità
Mode Tipo di accelerazione Enumerazione: dynPtp, dynCart
ValueAcc Valore per l'accelerazione mm/sec² o gradi/sec²
ValueDec Valore per la decelerazione
(indicazione opzionale)
mm/sec² o gradi/sec²
Tabella 10.3 Parametri dell'istruzione Acc
Enumerazione parametro Mode
Tipo di movimento Unità
dynPtp Point-To-Point %
dynCart cartesiano mm/sec²
Tabella 10.4 Unità dei parametri ValueAcc, ValueDec
Nota
Se il parametro opzionale ValueDec (per la rampa di decelerazione) non viene specificato, per la rampa di decelerazione verrà utilizzato il valore del parametro ValueAcc (per l'accelerazione). Il profilo sarà quindi simmetrico.
Esempio:
Variabile:
:
pos0 : AXISPOS := (-60, -60, 0, 0, 0, 0, 0, 0, 0)
pos1 : AXISPOS := (60, 60, 0, 0, 0, 0, 0, 0, 0)
pos2 : AXISPOS := (100, 60, 0, 0, 0, 0, 0, 0, 0)
:
Programma:
:
Ptp(pos0)
Acc(dynPtp, 30, 30) // accelerazione per PTP al 30 %
10. Istruzioni dinamiche
92 Festo GDCP-CMXR-SW-IT it 0909a
Ptp(pos1)
Acc(dynCart, 100) // accelerazione lungo la traiettoria
a 100 mm/sec²
Lin(pos2)
:
10.4 Strappo <Jerk>
Impostazione dello strappo per i movimenti PTP e cartesiani. Le istruzioni seguenti vengono ridotte fino al valore specificato. L'unità di comando riduce automaticamente lo strappo in caso di superamento dei valori limite degli assi.
Sintassi
Jerk (<Mode> : ENUM, <Value> : REAL)
Parametro Significato Unità
Mode Tipo di movimento Enumerazione: dynPtp, dynCart
Value Valore dello strappo
Tabella 10.5 Parametri dell'istruzione Jerk
Enumerazione parametro Mode
Tipo di movimento Unità
dynPtp Point-To-Point %
dynCart cartesiano mm/sec³
Tabella 10.6 Unità del parametro Value
Esempio:
Variabile:
:
pos0 : AXISPOS := (-60, -60, 0, 0, 0, 0, 0, 0, 0)
pos1 : AXISPOS := (60, 60, 0, 0, 0, 0, 0, 0, 0)
pos2 : AXISPOS := (100, 60, 0, 0, 0, 0, 0, 0, 0)
:
10. Istruzioni dinamiche
Festo GDCP-CMXR-SW-IT it 0909a 93
Programma:
:
Ptp(pos0)
Jerk(dynPtp, 50) // strappo per PTP al 50 %
Ptp(pos1)
Jerk(dynCart, 5000) // strappo sulla traiettoria a
5000 mm/sec³
Lin(pos2)
:
10. Istruzioni dinamiche
94 Festo GDCP-CMXR-SW-IT it 0909a
10.5 Override
Un override consente di impostare i valori dinamici in percentuale. Con questa imposta-zione è possibile variare con semplicità i valori di accelerazione, velocità e strappo. La traiettoria programmata non viene influenzata.
Nota
Se si desidera ridurre solo la velocità è consigliabile modificare direttamente il valore della velocità. Una riduzione mediante l'override influisce anche sull'accelerazione e sullo strappo. La dinamica degli assi non viene così completamente sfruttata e il movimento finale risulta più lento.
Esistono 2 tipi di override: override dinamico, che influisce sui valori impostati per velocità, accelerazione e
strappo override dall'unità di comando manuale
Funzionamento dell'override
Dinamica = dinamica programmata * override dinamico
10.5.1 Override dall'unità di comando manuale <Ovr>
L'override corrisponde all'impostazione sull'unità di comando manuale CDSA-D1-VX tramite i tasti V+ e V-. L'override viene specificato nell'unità percentuale, dove 100 % corrisponde al valore dinamico massimo programmato. Una diminuzione dell'override provoca un rallentamento della dinamica, senza però che la traiettoria venga modificata.
La figura mostra i tasti V- e V+ per l'impostazione dell'override sull'unità di comando manuale CDSA-D1-VX.
L'override è particolarmente utile durante la messa in servizio. Nell'esercizio automatico deve però trovarsi al 100 % per consentire un pieno utilizzo della capacità dinamica. I relativi adattamenti dei valori dinamici vanno eseguiti direttamente con le istruzioni per la velocità e l'accelerazione.
Con l'istruzione Ovr si può impostare un valore di override direttamente nel programma.
Ciò ha lo stesso effetto di una modifica tramite i tasti dell'unità di comando manuale.
10. Istruzioni dinamiche
Festo GDCP-CMXR-SW-IT it 0909a 95
Sintassi
Ovr (<Value> : REAL)
Parametro Significato Unità
Value Valore di override Percentuale
Tabella 10.7 Parametri dell'istruzione Ovr
Nota
Per sfruttare la piena capacità dinamica della cinematica, l'override dovrebbe sempre trovarsi al 100 % nel funzionamento automatico. Eventuali adattamenti dei valori dinamici vanno eseguiti con le istruzioni corrispondenti.
Funzionamento:
Se modificato tramite l'unità di comando manuale, l'override ha un effetto immediato sul movimento. A causa del calcolo preliminare del programma non è invece possibile una modifica immediata dell'override mediante la macro Ovr. L'utilizzo di Ovr provoca un arresto del calcolo preliminare, con un conseguente arresto sulla traiettoria.
Un'approssimazione verso il segmento di traiettoria successivo non è possibile.
Esempio:
// impostazione dell'override al 100%
Ovr(100)
Lin(pos1)
Lin(pos2)
// impostazione dell'override al 60%
Ovr(60)
Lin(pos3)
Lin(pos4)
10. Istruzioni dinamiche
96 Festo GDCP-CMXR-SW-IT it 0909a
10.5.2 Override dinamico <DynOvr>
Con l'istruzione DynOvr vengono influenzati i valori dinamici impostati o programmati.
L'istruzione dipende dall'override impostato sull'unità di comando manuale.
Sintassi
DynOvr (<Value> : REAL)
Parametro Significato Unità
Value Valore dell'override dinamico Percentuale
Tabella 10.8 Parametri dell'istruzione DynOvr
Nota
La traiettoria percorsa non viene modificata dall'override. Il valore programmato non ha alcun effetto sul calcolo preliminare del programma.
Una modifica dell'override con Ovr arresta il movimento.
Tempo
Velocità di avanzamento
pos4
pos3
pos2
pos1
60 %
100 %
10. Istruzioni dinamiche
Festo GDCP-CMXR-SW-IT it 0909a 97
10.6 Rampe di accelerazione
Con l'istruzione Ramp è possibile impostare una forma di rampa per l'accelerazione o la
decelerazione. Sono disponibili quattro forme di rampa. Dopo l'avvio è attivata la rampa sinusoidale.
Illustrazione delle 4 forme di rampa:
Rampa trapezoidale
La rampa trapezoidale provoca un andamento trapezoidale dell'accelerazione. Lo strappo assume quindi un andamento di forma rettangolare. Con la rampa trapezoidale si possono realizzare i tempi di esecuzione più rapidi della traiettoria.
Con un parametro opzionale è possibile modificare la forma della rampa. Questo parametro può assumere valori > 0 e <= 0,5. Con un valore pari a 0,5 si ottiene un triangolo di accelerazione, con un valore ad es. di 0,1 la forma della rampa si avvicina a quella di un profilo rettangolare.
Se il parametro opzionale non viene specificato, il sistema imposta automaticamente il fattore 0,5. Ne risulta il triangolo di accelerazione.
Rampa di forma trapezoidale con un fattore di ca. 0,1
Rampa di forma trapezoidale con un fattore 0,5
Tempo
Accelerazione
0
0,2
0,4
0,6
0,8
1
1,2
0,000 0,333 0,667 1,000
Besch
leu
nig
un
g
Zeit
TrapezTrapezoid Sine
JMin. jerk Sine square
Acc
eler
atio
n
Acc
eler
atio
n
Acc
eler
atio
n
Acc
eler
atio
n
10. Istruzioni dinamiche
98 Festo GDCP-CMXR-SW-IT it 0909a
Rampa sinusoidale
La rampa sinusoidale presenta il vantaggio che non solo l'accelerazione ma anche lo strappo assume un andamento sinusoidale. Ciò provoca un andamento dell'accelerazione più morbido rispetto a quello della rampa trapezoidale. Tuttavia, il tempo d'esecuzione per il raggiungimento della velocità è leggermente più lungo.
Rampa quadra sinusoidale
La rampa quadra sinusoidale ha l'andamento della traiettoria più morbido, ma richiede anche il tempo d'esecuzione più lungo per percorrere la traiettoria.
Rampa MinimumJerk
La rampa Minimumjerk è una forma di rampa speciale, che rappresenta un compromesso
tra tempo d'esecuzione e morbidezza del movimento. L'andamento dell'accelerazione è simile a quello di un profilo sinusoidale, mentre l'andamento dello strappo non è sinusoidale ma a dente di sega. Si ottiene quindi un movimento morbido con un tempo d'esecuzione più veloce.
Nota
Il tipo di rampa da utilizzare dipende dalla cinematica utilizzata e dall'applicazione. Una volta selezionata la forma della rampa è necessario testarla nel movimento.
10.6.1 Impostazione delle forme di rampa <Ramp>
Con l'istruzione Ramp si può selezionare una forma di rampa, che verrà utilizzata con tutte
le istruzioni di movimento successive.
Sintassi
Ramp( <Ramptype> : ENUM, OPT <Param> : REAL)
Parametro Significato Unità
Ramptype Tipo di rampa, seleziona la forma della
rampa.
Enumerazione:
TRAPEZOID
SINE
SINESQUARE
MINJERK
Param Parametro per le rampe trapezoidali -----
Tabella 10.9 Parametri dell'istruzione Ramp
10. Istruzioni dinamiche
Festo GDCP-CMXR-SW-IT it 0909a 99
Esempio:
:
Ramp(TRAPEZOID) // selezione della rampa trapezoidale
Lin(pos1)
Lin(pos2)
WaitTime(1000)
Ramp(SINE) // selezione della rampa sinusoidale
Lin(pos3)
Lin(pos4)
:
10.7 Attivazione della velocità di avanzamento costante <VconstOn>
Con questa istruzione viene attivato il controllo della velocità di avanzamento costante lungo la traiettoria. Il controllo ha effetto solo sulle istruzioni cartesiane, ad es. LIN e CIRC.
Questa istruzione non ha alcun effetto sui movimenti PTP.
Sintassi
VconstOn (<Tolerance> : REAL, <StopOnViolation> : BOOL)
Parametro Significato Unità
Tolerance Valore percentuale per la caduta di velocità ammissibile Valore percentuale da 0 % a
100 %
StopOnViolation Con TRUE attivazione di un errore per superamento
della tolleranza.
Interruttore: TRUE o FALSE
Tabella 10.10 Parametri dell'istruzione VconstOn
Nota
Qualora sia necessaria una velocità di avanzamento costante, assicurarsi che per l'area di approssimazione sia impostata un'approssimazione geometrica (vedi capitolo 11.4 Approssimazione geometrica a pagina 107). Un'approssimazione basata sulla velocità percentuale provoca una modifica della velocità di avanzamento nell'area di approssimazione.
Il controller multiassiale calcola la velocità di avanzamento possibile in base alla traiettoria e ai valori dinamici massimi dei componenti meccanici. Il limite della velocità di avanza-mento possibile viene determinato dalla dinamica dei componenti meccanici. Se vengono programmati segmenti di traiettoria che non possono essere percorsi con una velocità
10. Istruzioni dinamiche
100 Festo GDCP-CMXR-SW-IT it 0909a
costante a causa dei limiti dinamici, in questi punti si verificheranno cadute della velocità
di avanzamento.
Con il parametro Tolerance è possibile specificare un valore percentuale per la caduta di
velocità ammissibile. Indicando un valore di tolleranza del 100 %, il controllo viene disattivato.
Nota
Il controllo della velocità di avanzamento non tiene in considera-zione il valore di override eventualmente impostato sull'unità di comando manuale. Ciò significa che, se la cinematica non rag-giunge la piena velocità a causa di un override che la limita, il controllo si attiva e viene generato un errore.
Esempio:
Programma:
:
Lin(pos1)
VconstOn(25, TRUE)
Lin(pos2)
Lin(pos3)
VconstOff()
:
10. Istruzioni dinamiche
Festo GDCP-CMXR-SW-IT it 0909a 101
10.8 Disattivazione della velocità di avanzamento costante <VconstOff>
Con questa istruzione viene disattivata una velocità di avanzamento costante lungo la traiettoria.
Sintassi
VconstOff ( )
Nota
Un'interruzione del programma utente non provoca automatica-mente la disattivazione del controllo della velocità di avanzamento. Al riavvio del programma utente è sempre necessario disattivare prima il controllo.
11. Istruzioni di approssimazione
102 Festo GDCP-CMXR-SW-IT it 0909a
11. Istruzioni di approssimazione Con il termine 'approssimazione' si intende l'accelerazione degli assi per avvicinarsi alla posizione successiva, sebbene la posizione precedente non sia ancora stata raggiunta. Spesso è necessario non tanto che una posizione venga raggiunta in modo preciso, quanto che il movimento avvenga in modo veloce e delicato, cioè con la sollecitazione minima possibile dei componenti meccanici. In questi casi la funzione di approssimazione offre la possibilità di modulare la precisione di raggiungimento di un punto e la durezza del movimento.
La figura seguente mostra il funzionamento della funzione di approssimazione.
Il programma di movimenti contiene un posizionamento sulla posizione 1 e poi sulla posizione 2. Mediante la funzione di approssimazione, impostata tramite un'istruzione di
programma, le singole posizioni non vengono accostate con precisione. I profili dinamici per l'accostamento delle singole posizioni vengono sovrapposti nelle aree di approssi-mazione, con un conseguente aumento della dinamicità.
Nota
Dopo il caricamento di un programma non è attiva alcuna funzione di approssimazione, cioè le posizioni vengono accostate con precisione. Per utilizzare la funzione di approssimazione è neces-sario attivarla con le funzioni corrispondenti.
L'approssimazione può essere di due tipi:
1. Approssimazione della velocità in base alla velocità
2. Approssimazione della posizione in base a una distanza prestabilita
Questi due tipi di approssimazione vengono descritti nelle pagine seguenti.
Aree di approssimazione,
curve polinomiali
Posizione 1 Posizione 2
Traiettoria della cinematica
11. Istruzioni di approssimazione
Festo GDCP-CMXR-SW-IT it 0909a 103
Nota
La traiettoria nell'area di approssimazione viene determinata mediante una curva polinomiale calcolata matematicamente. Questa provoca un aumento costante della dinamicità e quindi una minore sollecitazione dei componenti meccanici. Con un arroton-damento mediante un raggio, questo non sarebbe possibile. Per tale motivo un arrotondamento dei segmenti di traiettoria con l'approssimazione non è realizzabile.
11.1 Segmenti nulli
Programmando un segmento nullo, cioè il riposizionamento sulla posizione già accostata, non è possibile utilizzare la funzione di approssimazione. Ciò provoca una decelerazione con successiva accelerazione lungo la traiettoria.
Esempio:
Lin(pos1)
Lin(pos2)
// riposizionamento su pos2 = approssimazione non possibile
Lin(pos2)
Lin(pos3)
Poiché la posizione pos2 è stata riprogrammata, in questo punto del programma si verifica un arresto sulla traiettoria.
11. Istruzioni di approssimazione
104 Festo GDCP-CMXR-SW-IT it 0909a
11.2 Campo limite
Se la distanza tra 2 punti non è sufficientemente grande per percorrere la traiettoria di approssimazione parametrizzata, l'unità di comando riduce automaticamente l'area di approssimazione tra i punti fino ad ottenere il valore di approssimazione migliore possibile per la traslazione.
Nella figura i cerchi tratteggiati rappresentano l'area di approssimazione risultante dalla
parametrizzazione. I cerchi si sovrappongono in quanto la distanza tra le posizioni A e B non è sufficiente per percorrere questo profilo. L'unità di comando calcola quindi automaticamente l'area di approssimazione massima possibile, rappresentata dai cerchi pieni di colore grigio.
Nota
L'approssimazione è limitata al 50 % della lunghezza del segmento della traiettoria. Se l'area di approssimazione è maggiore del valore massimo possibile, il controller multiassiale CMXR la accorcia automaticamente al 50 % della lunghezza del segmento della traiettoria.
Nota
Lunghezze dei segmenti di traiettoria troppo piccole possono portare a cali indesiderati della dinamicità in caso di riduzione dell'area di approssimazione definita. Per ovviare a tale incon-veniente è necessario adattare la traiettoria o l'area di approssi-mazione.
Campo di raccordo programmato Campo di raccordo sovrapposto
Campo di raccordo generato dal sistema di comando
Traiettoria percorsa
11. Istruzioni di approssimazione
Festo GDCP-CMXR-SW-IT it 0909a 105
11.3 Approssimazione della velocità
Con l'approssimazione della velocità vengono sovrapposti i profili dinamici della traiettoria. Ne risulta un movimento alla posizione successiva nell'area di approssi-mazione.
11.3.1 Con fattore percentuale <OvlVel>
Nell'approssimazione della velocità viene preimpostato un grado di approssimazione con un valore percentuale. L'intervallo di valori è compreso tra 0 % e 200 %.
Sintassi
OvlVel (<Value> : REAL)
Parametro Significato Unità
Value Valore di
approssimazione
Percentuale
Tabella 11.1 Parametri dell'istruzione OvlVel
Parametri:
Percentuale Parametri di approssimazione in %
0 % Senza approssimazione
100 % Utilizzo ottimale delle accelerazioni degli assi
100..200 % Senza perdita di tempo, movimento più morbido con area di approssimazione più grande
I valori inferiori al 100 % forniscono tolleranze di posizionamento più ridotte, ma allungano la durata del movimento in quanto la velocità deve essere ridotta. Con un valore del 100 % vengono utilizzate tutte le riserve di accelerazione degli assi con una tolleranza di posizionamento possibilmente bassa. Con valori compresi tra 100 % e 200 % vengono aumentate le tolleranze di posizionamento (errori di posizionamento), mentre le accelerazioni degli assi vengono ridotte rispetto ad un'impostazione al 100 %.
La figura seguente mostra i profili di velocità per una corsa sulla posizione 1 e la posizione 2. Per l'area di approssimazione sono definiti valori differenti.
11. Istruzioni di approssimazione
106 Festo GDCP-CMXR-SW-IT it 0909a
La grafica 1 mostra un profilo di velocità nel quale non si è verificata nessuna sovrappo-sizione. Gli assi rallentano sulla traiettoria e, in questo modo, le posizioni 1 e 2 vengono
raggiunte con precisione. Nella grafica centrale è raffigurata una sovrapposizione parziale, nella grafica in basso una sovrapposizione completa (100 %) dei profili di velocità.
Nota
Nell'area di approssimazione viene sfruttata la dinamica completa degli assi. Ciò significa che il tratto di traiettoria nell'area di approssimazione non è un raggio bensì una curva polinomiale derivata dagli attuali valori dinamici degli assi.
Esempio:
:
OvlVel(100) // approssimazione al 100 %
Lin(pos1)
Lin(pos2)
OvlVel(75) // approssimazione al 75 %
Lin(pos3)
:
0 %
50 %
100 %
1) Senza sovrapposizione
2) Sovrapposizione parziale
3) Sovrapposizione completa
Tempo ciclo
Tempo ciclo
Tempo ciclo
Direzione Y
Campo del raccordo
Direzione X
11. Istruzioni di approssimazione
Festo GDCP-CMXR-SW-IT it 0909a 107
11.4 Approssimazione geometrica
Con l'approssimazione geometrica vengono definite le tolleranze dalla posizione terminale programmata. Rispetto all'approssimazione della velocità, lo spostamento viene indicato geometricamente, cioè in unità di lunghezza o angolari.
Nell'approssimazione geometrica si distingue tra un'approssimazione degli assi cartesiani X, Y e Z e degli assi di orientamento.
Nota
L'approssimazione geometrica può essere utilizzata solo per i movimenti cartesiani. I movimenti PTP non sono possibili con questo tipo di approssimazione.
Non è indicata per l'arrotondamento degli angoli, in quanto la forma geometrica nell'area di approssimazione non è un raggio bensì una curva polinomiale. Un raggio non è indicato per l'approssimazione in quanto provoca un brusco aumento dell'accelerazione.
11.4.1 Approssimazione degli assi X, Y e Z <OvlCart>
L'approssimazione di movimenti cartesiani con una definizione geometrica viene ottenuta indicando una distanza del TCP sulla traiettoria fino al punto di destinazione.
Il movimento di approssimazione viene iniziato all'ingresso nella sfera e terminato nel punto in cui la sfera interseca il segmento di traiettoria successivo. Questa curva si snoda in modo tangenziale rispetto ai 2 segmenti di traiettoria interessati. Il limite dell'area di approssimazione è formato dalla metà del più breve dei segmenti di traiettoria interessati.
La traiettoria nell'area di approssimazione non è un raggio ma un polinomio di quinto
ordine. Questo polinomio genera l'andamento più morbido possibile della traiettoria, che non sarebbe possibile con un arco di cerchio.
Sintassi
OvlCart (<Distance> : REAL)
Sfera con area di
approssimazione
11. Istruzioni di approssimazione
108 Festo GDCP-CMXR-SW-IT it 0909a
Parametro Significato Unità
Distance Area di approssimazione, distanza dal punto
finale
Unità di lunghezza impostata
Tabella 11.2 Parametri dell'istruzione OvlCart
Nota
Un'approssimazione geometrica è molto spesso necessaria in combinazione con una velocità di avanzamento costante. Questa viene impostata con l'istruzione VconstOn (vedi capitolo 10.7 Attivazione della velocità di avanzamento costante a pagina 99).
Esempio:
Un contorno deve essere percorso con velocità di avanzamento costante e con un'area di approssimazione di 5 mm.
Vel(dynCart, 300) // velocità di avanzamento a 300 mm/sec
VconstOn(25, TRUE) // attivazione velocità avanzamento
costante
OvlCart(5) // impostazione area di approssimazione
Lin(p1)
Lin(p2)
Lin(p3)
Lin(p4)
Lin(p5)
Lin(p6)
p6
p1 p2
p3 p4
p5
Area di approssimazione
12. Sistemi di riferimento (spostamento del punto zero)
Festo GDCP-CMXR-SW-IT it 0909a 109
12. Sistemi di riferimento (spostamento del punto zero)
I sistemi di riferimento sono sistemi di coordinate cartesiane con 3 gradi di libertà traslatori e 3 rotatori. La definizione dell'orientamento è basata sulla convenzione di Eulero ZYZ.
Nota
Essendo di tipo cartesiano, i sistemi di riferimento non hanno alcun effetto sullo zero di singoli assi nel sistema di coordinate degli assi. Essi hanno effetto solamente sul sistema di coordinate cartesiane.
All'avvio di un programma è attivo il sistema di coordinate globali.
12.1 Riferimento del sistema di riferimento
Un sistema di riferimento è riferito allo zero cartesiano di un sistema di coordinate già definito. I valori definiti del nuovo sistema di riferimento provocano uno scostamento nei 6 gradi di libertà.
Come visibile nella figura è possibile definire più sistemi di riferimento sullo zero cartesiano di un altro sistema di riferimento, mentre può essere attivo un solo riferimento.
Nota
Una nidificazione dei sistemi di riferimento va utilizzata con molta attenzione. Questo meccanismo può favorire una programmazione più efficiente in determinati casi, ma rende meno trasparente la lettura del programma. Inoltre una nidificazione non ottimale può provocare eventuali collisioni.
X
Y
Z X
Y
Z
X
Y
Z
Zero del sistema di
coordinate globali
Scostamento 1
Scostamento 2
X
Y
Z
Scostamento additivo
sullo scostamento 2
12. Sistemi di riferimento (spostamento del punto zero)
110 Festo GDCP-CMXR-SW-IT it 0909a
Nota
Lo scostamento del sistema di riferimento è composto da una traslazione e una rotazione (orientamento). Durante l'esecuzione viene eseguito prima lo scostamento e poi la rotazione.
12.2 Dati del sistema di riferimento
I dati di un sistema di riferimento sono composti da una traslazione tridimensionale e da una indicazione di orientamento tridimensionale. La definizione dell'orientamento avviene in base al metodo di Eulero ZYZ.
Questi dati vengono creati in una variabile che è formata da un tipo di dati strutturato. Il nome del sistema di riferimento è liberamente selezionabile. Il numero dei sistemi di
riferimento è limitato dalle dimensioni della memoria.
Esistono le seguenti possibilità per definire i dati di un sistema di riferimento:
1. indicazione diretta dei valori
2. indicazione mediante 3 punti cartesiani
Oltre ai valori del sistema di riferimento è possibile creare un riferimento ad un altro sistema di riferimento. In ognuno dei tipi di dati strutturati è inoltre possibile, mediante il parametro RefSys, generare un riferimento ad un altro sistema di riferimento. Con il parametro RefSys si possono specificare i tipi di dati per tutte le possibilità.
Qui di seguito vengono descritte le istruzioni per l'impostazione di un sistema di
riferimento.
12. Sistemi di riferimento (spostamento del punto zero)
Festo GDCP-CMXR-SW-IT it 0909a 111
12.3 Sistema di riferimento con valori diretti <SetRefSys>
L'istruzione SetRefSys attiva un sistema di riferimento i cui dati sono registrati in modo
assoluto nella struttura di dati della variabile trasferita.
Sintassi
SetRefSys(<refSys> : REFSYSDATA)
Parametro Significato Unità
refSys Sistema di riferimento definito tramite i valori di
scostamento.
Lunghezze e unità angolari
Tabella 12.1 Parametri dell'istruzione SetRefSys
Mediante l'indicazione diretta dei valori, i valori vengono resi noti direttamente con la variabile trasferita. Una modifica dei dati già trasferiti è possibile solo richiamando di nuovo la variabile.
Struttura del tipo di dati REFSYSDATA:
baseRs : REFSYS Riferimento ad un altro sistema di riferimento
x : REAL Scostamento lungo l'asse X
y : REAL Scostamento lungo l'asse Y
z : REAL Scostamento lungo l'asse Z
a : REAL Orientamento secondo Eulero, rotazione intorno all'asse Z
b : REAL Orientamento secondo Eulero, rotazione intorno all'asse Y ruotato
c : REAL Orientamento secondo Eulero, rotazione intorno all'asse Z ruotato
Con il parametro baseRs si può indicare un altro riferimento sul quale il sistema di riferi-mento agisce in modo additivo. Per creare un rimando al sistema di coordinate globali della cinematica occorre definire il riferimento sulla variabile di sistema _system.world.
Esempio:
Dati:
refsysdata0 : REFSYSDATA := (MAPX("_system.world”),
100, 150, 0, 0, 0, 0)
Programma:
SetRefSys(refsysdata0)
12. Sistemi di riferimento (spostamento del punto zero)
112 Festo GDCP-CMXR-SW-IT it 0909a
12.4 Sistema di riferimento con 3 punti <SetRefSys3P>
Con l'istruzione SetRefSys3P viene impostato un sistema di riferimento i cui dati vengono
definiti mediante 3 posizioni nello spazio.
Sintassi
SetRefSys3P(<refSys> : REFSYS3P)
Parametro Significato Unità
refSys Sistema di riferimento definito tramite 3 posizioni Lunghezze e unità angolari
Tabella 12.2 Parametri dell'istruzione SetRefSys3P
Utilizzo:
Questo tipo di descrizione di un sistema di riferimento offre la possibilità di eseguire la programmazione mediante “teach-in” utilizzando 3 posizioni. Queste 3 posizioni sono di tipo cartesiano con 6 gradi di libertà.
Significato delle posizioni:
La prima posizione definisce l'origine del sistema di riferimento.
La seconda posizione definisce un punto attraverso il quale passa l'asse X cartesiano positivo del sistema di riferimento.
La terza posizione definisce un punto sul piano XY.
Nota
Gli orientamenti delle posizioni non sono importanti. Per le calcolazioni sono necessarie solo le posizioni cartesiane.
Struttura del tipo di dati REFSYS3P:
baseRs : REFSYS Riferimento ad un altro sistema di riferimento
p0 : CARTPOS Origine del sistema di riferimento da definire
px : CARTPOS Posizione lungo l'asse X
pxy : CARTPOS Posizione sul piano X-Y
Con il parametro baseRs si può indicare un altro riferimento sul quale il sistema di
riferimento agisce in modo additivo. Per creare un rimando al sistema di coordinate globali della cinematica occorre definire il riferimento sulla variabile di sistema _system.world.
12. Sistemi di riferimento (spostamento del punto zero)
Festo GDCP-CMXR-SW-IT it 0909a 113
Procedura per la programmazione mediante “teach-in”:
Attenzione
Il terzo punto determina il piano XY positivo. A seconda della posizione del terzo punto può verificarsi una rotazione del sistema di coordinate, ad es. una rotazione di 180 gradi dell'asse Z.
Esempio:
Dati:
refsys3p0 : REFSYS3P := (MAPX(“_system.world”),
(100, 100, 0, 0, 0, 0, 0, 0, 0),
(200, 100, 0, 0, 0, 0, 0, 0, 0),
(200, 200, 0, 0, 0, 0, 0, 0, 0))
Programma:
SetRefSys3P(refsys3p0)
Secondo punto = asse X positivo
Primo punto = origine
Terzo punto = piano XY positivo
Terzo punto = piano XY positivo
12. Sistemi di riferimento (spostamento del punto zero)
114 Festo GDCP-CMXR-SW-IT it 0909a
12.5 Sistema di riferimento globale <SetRefSysWorld>
Con questa istruzione viene attivato il sistema di riferimento globale, la cui origine è memorizzata nella configurazione della cinematica.
Sintassi
SetRefSysWorld()
Se è stato impostato (attivato) un sistema di riferimento con l'istruzione SetRefSys o SetRefsys3P e si desidera disattivare questo sistema di riferimento in un determinato punto del programma, utilizzare l'istruzione SetRefSysWorld.
12.6 Esempio
Nell'esempio seguente si devono svuotare 2 pallet e poi alimentare i pezzi in una macchina.
Entrambi i pallet hanno lo stesso contenuto e le stesse dimensioni. Per minimizzare il lavoro di programmazione viene impostato un sistema di riferimento specifico per ogni
pallet e il programma del pallet viene creato come sottoprogramma.
Per il sistema di riferimento del pallet 1 viene utilizzata la variabile RefPal1, per il pallet 2 la variabile RefPal2.
Dati:
:
refPal1 : REFSYSDATA := (MAPX(“_system.world”),
0, 0, 0, 0, 0, 0)
Alimentazione macchina
X
Y
Pallet 1 Pallet 2
Sensore per rilevare se
la posizione è libera
300
300 1500
12. Sistemi di riferimento (spostamento del punto zero)
Festo GDCP-CMXR-SW-IT it 0909a 115
refPal2 : REFSYSDATA := (MAPX(“_system.world”),
0, 0, 0, 0, 0, 0)
pos1 : CARTPOS := (100, 80, 70, 0, 0, 0, 0, 0, 0)
:
Programma:
:
refPal1.x := 300 // scostamento pallet 1 in X
refPal1.y := 300 // scostamento pallet 1 in Y
refPal2.x := 1500 // scostamento pallet 2 in X
refPal2.y := 300 // scostamento pallet 2 in Y
Lin(pos1) // corsa su pos. sicurezza nel sistema
globale
SetRefSys(refPal1) // attivazione scostamento pallet 1
CALL Feed() // richiamo sottoprogramma per
alimentazione pezzi
SetRefSys(refPal2) // attivazione scostamento pallet 2
CALL Feed() // richiamo sottoprogramma per
alimentazione pezzi
SetRefSysWorld() // attivazione sistema globale
Lin(pos1)
:
13. Definizione del riferimento di una cinematica
116 Festo GDCP-CMXR-SW-IT it 0909a
13. Definizione del riferimento di una cinematica
13.1 Corsa di riferimento <RefAxis>
L'istruzione RefAxis consente di definire i riferimenti degli assi. La corsa di riferimento
viene sempre eseguita con un solo asse.
Sintassi
RefAxis(<axis>:AXIS, OPT <refData>:REFDATA, OPT <timeout>:REAL)
Parametro Significato Unità
Axis Asse selezionato per la definizione del riferimento. Enumerazione A1, A2, fino
ad A9
refData Record di dati della corsa di riferimento, ad es. su come viene
eseguita la definizione del riferimento.
nessuna
timeout Tempo per lo svolgimento dell'operazione (dopodiché viene
emesso un messaggio d'errore, la definizione del riferimento
viene interrotta).
Secondi
Tabella 13.1 Parametri dell'istruzione RefAxis
Durante l'esecuzione della corsa di riferimento assicurarsi che gli assi interessati non vengano ostacolati nei loro movimenti. Il movimento viene eseguito come movimento degli
assi. In base al tipo di cinematica possono verificarsi movimenti sconosciuti sull'utensile a causa della disposizione degli assi.
Nota
I parametri refData e timeout sono opzionali. Se non vengono specificati, il sistema utilizza l'attuale posizione effettiva come posizione di riferimento (DS 402 – metodo 35).
Attenzione
Assicurarsi che gli assi interessati possano traslare liberamente durante la corsa di riferimento. Per garantire una corretta esecuzione della corsa di riferimento occorre inoltre selezionare valori dinamici adeguati per questi movimenti. In questo caso non sono consigliabili valori dinamici elevati.
13. Definizione del riferimento di una cinematica
Festo GDCP-CMXR-SW-IT it 0909a 117
La definizione del riferimento necessita di alcuni dati per poter essere eseguita. Questi
dati vengono specificati in un record di dati di riferimento del tipo REFDATA.
Parametro Tipo Significato
method DINT Metodo di riferimento secondo CANOpen DS 402
offset REAL Offset della posizione di riferimento [mm]
velSwitch REAL Velocità di definizione del riferimento (accostamento
dell'interruttore)
velZero REAL Velocità lentissima (ricerca del fronte)
acc REAL Accelerazione corsa di riferimento
Tabella 13.2 Struttura del tipo di dati REFDATA
Nota
Specificando il metodo della corsa di riferimento 99 vengono utilizzati i parametri della corsa di riferimento programmati con il Festo Configuration Tool (FCT) nell'attuatore. La corsa di riferi-mento viene quindi eseguita come alla messa in servizio del singolo asse. Tutti gli altri parametri quali offset, velSwitch, zeroSwitch e acc sono irrilevanti in questo caso.
Metodo della corsa di riferimento
Il metodo della corsa di riferimento può avvenire in vari modi, ad es. finecorsa negativo con analisi dell'impulso zero, finecorsa positivo con analisi dell'impulso zero o corsa di riferimento verso un interruttore di finecorsa. Questi metodi sono tutti memorizzati nella documentazione CANopen del rispettivo regolatore dell'attuatore.
La tabella seguente mostra i metodi di definizione del riferimento per unità CANopen secondo DS 402.
Valore Direzione Destinazione Punto di riferimento per zero
-18 positiva Arresto meccanico Arresto meccanico
-17 negativa Arresto meccanico Arresto meccanico
-2 positiva Arresto meccanico Impulso zero
-1 negativa Arresto meccanico Impulso zero
1 negativa Finecorsa Impulso zero
2 positiva Finecorsa Impulso zero
7 positiva Interruttore di
riferimento Impulso zero
11 negativa Interruttore di
riferimento Impulso zero
17 negativa Finecorsa Finecorsa
13. Definizione del riferimento di una cinematica
118 Festo GDCP-CMXR-SW-IT it 0909a
Valore Direzione Destinazione Punto di riferimento per zero
18 positiva Finecorsa Finecorsa
23 positiva Interruttore di
riferimento Interruttore di riferimento
27 negativa Interruttore di
riferimento Interruttore di riferimento
33 negativa Impulso zero Impulso zero
34 positiva Impulso zero Impulso zero
35 - nessuna corsa Posizione effettiva corrente
99 - - Sequenza come definita nel progetto
FCT dell'asse
Tabella 13.3 Metodi della corsa di riferimento
Scostamento della posizione di riferimento
Mediante il parametro offset si può definire uno scostamento dello zero rispetto alla posizione di riferimento. Una volta definito il riferimento, questo valore di offset viene sommato al punto zero di riferimento. L'indicazione del valore effettivo dell'asse interes-sato viene aggiornata in maniera corrispondente.
Velocità di definizione del riferimento, velocità lentissima, accelerazione
Con la velocità di definizione del riferimento e l'accelerazione viene definita la dinamica dell'asse durante la definizione del riferimento, che sarà attiva dall'avvio della corsa di
riferimento fino al raggiungimento del fronte dell'interruttore corrispondente. Una volta rilevato il fronte, il sistema commuta sulla velocità lentissima e la corsa di riferimento viene conclusa secondo il metodo selezionato.
13.2 Corsa di riferimento asincrona <RefAxisAsync>
Con questa istruzione è possibile definire parallelamente il riferimento di più assi di robot. L'istruzione non attende che la corsa di riferimento sia conclusa, bensì lo svolgimento del programma viene proseguito una volta trasmesso il comando di definizione del riferimento. Per verificare se la definizione del riferimento è stata conclusa o per interrogare lo stato in cui si trova la definizione del riferimento sono disponibili le istruzioni WaitRefFinished e IsAxisReferenced.
Sintassi
RefAxisAsync(<axis>:AXIS, OPT <refData>:REFDATA, OPT <timeout>:REAL)
13. Definizione del riferimento di una cinematica
Festo GDCP-CMXR-SW-IT it 0909a 119
Parametro Significato Unità
Axis Asse selezionato per la definizione del riferimento. Enumerazione A1, A2, fino
ad A9
refData Record di dati della corsa di riferimento, ad es. su come viene
eseguita la definizione del riferimento.
nessuna
timeout Tempo per lo svolgimento dell'operazione (dopodiché viene
emesso un messaggio d'errore, la definizione del riferimento
viene interrotta).
Secondi
Tabella 13.4 Parametri dell'istruzione RefAxisAsync
Durante l'esecuzione della corsa di riferimento assicurarsi che gli assi interessati possano traslare liberamente. Il movimento viene eseguito come movimento degli assi. In base al tipo di cinematica possono verificarsi movimenti sconosciuti sull'utensile a causa della
disposizione degli assi.
Nota
I parametri refData e timeout sono opzionali. Se non vengono specificati, il sistema utilizza l'attuale posizione effettiva come posizione di riferimento (DS 402 – metodo 35).
Attenzione
Assicurarsi che tutti gli assi possano traslare liberamente durante la corsa di riferimento. Per garantire una corretta esecuzione della corsa di riferimento occorre inoltre selezionare valori dinamici adeguati per questi movimenti. In questo caso non sono consigliabili valori dinamici elevati.
I parametri e il restante funzionamento sono uguali a quelli dell'istruzione RefAxis.
Nota
Specificando il metodo della corsa di riferimento 99 vengono utilizzati i parametri della corsa di riferimento programmati con il Festo Configuration Tool (FCT) nell'attuatore. La corsa di riferi-mento viene quindi eseguita come alla messa in servizio del singolo asse. Tutti gli altri parametri quali offset, velSwitch, zeroSwitch e acc sono irrilevanti in questo caso.
13. Definizione del riferimento di una cinematica
120 Festo GDCP-CMXR-SW-IT it 0909a
13.3 Attesa della fine della corsa di riferimento <WaitRefFinished>
Attendere fino a quando tutte le corse di riferimento avviate in modo asincrono sono concluse.
Sintassi
WaitRefFinished( ) : BOOL
L'istruzione attende fino a quando le corse di riferimento asincrone sono concluse (l'attesa avviene durante l'elaborazione principale del programma) o fino a quando si verifica un
errore durante una corsa di riferimento.
Se non si verifica nessun errore durante la corsa di riferimento viene restituito TRUE, altrimenti FALSE.
Programma:
: RefAxisAsync(A1, refdata0)
RefAxisAsync(A2, refdata0)
RefAxisAsync(A3, refdata0)
RefAxisAsync(A4)
boolReference := WaitRefFinished()
IF NOT boolReference THEN
SetError(“Error homing”)
END_IF
Attenzione
Durante l'esecuzione della macro RefAxisAsync è assolutamente necessario utilizzare la macro WaitRefFinished in modo da garan-tire l'ulteriore elaborazione del programma. Se non si attende la fine della corsa di riferimento, determinate istruzioni potrebbero generare errori correlati al calcolo preliminare del programma.
13. Definizione del riferimento di una cinematica
Festo GDCP-CMXR-SW-IT it 0909a 121
13.4 Interrogazione dello stato di un asse <IsAxisReferenced>
Interrogazione per sapere se il riferimento di un determinato asse è stato definito.
Sintassi
IsAxisReferenced(axis : AXIS ) : BOOL
Parametro Significato Unità
Axis Asse selezionato da interrogare. Enumerazione A1,
A2, fino ad A9
Tabella 13.5 Parametri dell'istruzione IsAxisReferenced
Se il riferimento dell'asse specificato è definito viene restituito TRUE, altrimenti FALSE.
14. Utensili
122 Festo GDCP-CMXR-SW-IT it 0909a
14. Utensili Il controller multiassiale offre la possibilità di definire i dati di lunghezza di un utensile. Questi dati vengono descritti sotto forma di un vettore a 6 dimensioni. In tal modo è possibile assegnare all'utensile anche un orientamento, oltre alle dimensioni. Questo orientamento avviene in base alla convenzione di Eulero ZYZ. L'origine del vettore è lo zero nella flangia dell'utensile, mentre la fine è data dal punto finale dell'utensile, denominato TCP (Tool Center Point). Con i dati dell'utensile viene definito il sistema di coordinate
dell'utensile.
14.1 Dati dell'utensile
14.1.1 Dati del vettore TCP
I dati dell'utensile sono memorizzati nel tipo di dati strutturato TCPTOOL, che contiene i dati dei 6 gradi di libertà.
Struttura:
Tipo di dati TCPTOOL
x : REAL Scostamento lungo l'asse X
y : REAL Scostamento lungo l'asse Y
z : REAL Scostamento lungo l'asse Z
a : REAL Indicazione di orientamento, rotazione intorno all'asse Z
b : REAL Indicazione di orientamento, rotazione intorno all'asse Y ruotato
c : REAL Indicazione di orientamento, rotazione intorno all'asse Z ruotato
Z
X Y
Flangia dell'utensile Sistema di coordinate del
vettore a 6 dimensioni con
origine sulla flangia
14. Utensili
Festo GDCP-CMXR-SW-IT it 0909a 123
I 3 valori traslatori X, Y e Z definiscono il TCP nello spazio quando tutti gli assi si trovano
nella posizione di partenza. In questo modo il sistema di coordinate dell'utensile viene spostato nel TCP. Inoltre, mediante un'indicazione di orientamento (parametri A, B e C), il sistema può essere ruotato nel suo orientamento nello spazio.
Esempio di dati TCP:
In una struttura a portale cartesiano, all'estremità dell'asse Z si trova un asse oscillante pneumatico con una ventosa. L'utensile è montato in direzione dell'asse Z. L'orientamento del TCP è invariato rispetto al sistema di coordinate originario dell'utensile.
Risultano i seguenti dati TCP:
X = 0
Y = 0
Z = Lunghezza utensile
A = 0
B = 0
C = 0
Ora l'utensile, che è provvisto di un asse oscillante pneumatico, è inclinato di 30 gradi nello spazio. Il TCP viene calcolato mediante l'angolo del movimento oscillante.
Ne risultano i seguenti dati:
X = Lunghezza utensile x sin (30°)
Y = 0
Z= Lunghezza utensile x cos (30°)
A = 0
B = 0
C = 0
L'orientamento del sistema di coordinate dell'utensile è invariato. Se necessario, deve essere impostato mediante i parametri A, B e C.
Lunghezza
utensile
Z
X
Y
Asse Z
Asse X
Spostamento
in Z
Z
X
Y
Asse Z
Asse X
Spostamento
in X
Angolo 30°
14. Utensili
124 Festo GDCP-CMXR-SW-IT it 0909a
Inoltre l'orientamento del sistema di coordinate dell'utensile deve essere rivolto in dire-
zione dell'utensile ruotato. Per la rotazione viene utilizzata la convenzione di Eulero ZYZ.
Ne risultano i seguenti dati:
X = Lunghezza utensile x sin (30°)
Y = 0
Z= Lunghezza utensile x cos (30°)
A = 0
B = 30
C = 0
Queste descrizioni dell'utensile vengono memorizzate in variabili. Per un utensile è possi-bile definire un numero a piacere di variabili TCP, ma un solo record di dati può essere attivo. Le varie descrizioni vengono poi utilizzate quando un utensile ha diversi punti di riferimento e, durante l'esercizio, occorre cambiarli a seconda del rispettivo compito.
Poiché i dati utensile sono archiviati come variabile nella memoria, il loro numero è limitato dalle dimensioni della memoria.
La corretta attribuzione dei dati TCP all'utensile è compito del programmatore. Il controller multiassiale non conosce il riferimento esistente tra i dati dell'utensile e l'utensile fisico.
Attenzione
In caso di dati TCP inappropriati o errati sussiste il pericolo di collisione.
Spostamento
in Z
Z
X
Y
Asse Z
Asse X
Spostamento in X
Angelo
14. Utensili
Festo GDCP-CMXR-SW-IT it 0909a 125
14.2 Attivazione dei dati dell'utensile <Tool>
Con l'istruzione seguente è possibile impostare i dati di un Tool Center Point (TCP) all'interno di un programma FTL. L'istruzione Tool imposta nuovi dati TCP per la cinematica. In questo modo viene modificato il punto di lavoro della cinematica.
Sintassi
Tool (<ToolData> : TCPTOOL)
I dati per il TCP sono contenuti nella variabile da trasferire. Questi dati vengono letti du-rante il calcolo preliminare dei record dell'interprete FTL e da lì vengono inclusi nell'ul-teriore pianificazione della traiettoria del movimento. Per tutte le istruzioni seguenti
vengono ora considerati questi dati TCP.
Parametro Significato Unità
ToolData Dati dell'utensile TCPTOOL
Tabella 14.1 Parametri dell'istruzione Tool
Il richiamo dell'istruzione Tool non provoca alcun movimento di traslazione, ma solo una
segnalazione che i dati TCP sono ora attivi. Nell'istruzione di traslazione cartesiana successiva, questi dati verranno elaborati e tenuti in considerazione per l'esecuzione del movimento.
Se nel programma FTL viene saltata un'istruzione Tool, o se sull'unità di comando manuale
il puntatore di frase per l'esecuzione del programma è posizionato in modo tale da impedire l'esecuzione di un'istruzione Tool, possono verificarsi pericoli per le persone e per la macchina. Il successivo orientamento dell'utensile potrebbe essere inappropriato rispetto al movimento, con un conseguente pericolo di collisione.
Avvertenza
In caso di modifica dell'istruzione Tool si verifica un salto nella traiettoria cartesiana del TCP. Se sull'unità di comando manuale il puntatore di programma viene impostato in modo tale da eludere un'istruzione Tool, possono verificarsi reazioni non desiderate nei movimenti cartesiani!
14.2.1 Effetti dei dati TCP
I dati TCP vengono attivati nel programma FTL mediante un'istruzione e letti nel calcolo preliminare dei record dell'interprete. Questi dati TCP ora attuali vengono poi elaborati nella pianificazione della traiettoria delle istruzioni di movimento successive. Nell'esempio seguente viene descritto il comportamento dei dati utensile in combinazione con l'utilizzo di un asse oscillante pneumatico.
14. Utensili
126 Festo GDCP-CMXR-SW-IT it 0909a
Esempio:
Un sistema di manipolazione è equipaggiato con un asse oscillante pneumatico sulla flangia dell'utensile. Mediante questo asse è possibile ruotare l'utensile in una posizione fissa. Tramite questo movimento oscillante viene modificato l'orientamento dell'utensile. Per consentire al controller multiassiale CMXR di calcolare un movimento cartesiano nello spazio tenendo in considerazione la posizione del TCP, è necessario comunicargli il nuovo orientamento dell'utensile dopo il movimento oscillante.
A causa dei due orientamenti possibili dell'utensile, esistono 2 TCP e quindi 2 record di dati (tool1 e tool2).
Orientamento 1, utensile verticale:
La lunghezza dell'utensile verticale scorre lungo l'asse Z del sistema di coordinate dell'utensile. In tal modo TCP ha solo una traslazione in direzione dell'asse Z, le indicazioni dell'orientamento sono 0.
Dati utensile per tool1:
X = 0 Scostamento lungo l'asse X
Y = 0 Scostamento lungo l'asse Y
Z = Lunghezza utensile Scostamento lungo l'asse Z
A = 0 Orientamento secondo Eulero, rotazione intorno all'asse Z
B = 0 Orientamento secondo Eulero, rotazione intorno all'asse Y ruotato
C = 0 Orientamento secondo Eulero, rotazione intorno all'asse Z ruotato
X
Z
Ventosa
Y
Asse rotativo
Lunghezza utensile
TCP
14. Utensili
Festo GDCP-CMXR-SW-IT it 0909a 127
Orientamento 2, utensile ruotato:
Per effetto del movimento oscillante il TCP si sposta di lato e l'utensile ha ora un orienta-mento modificato.
La cinematica raffigurata è un sistema cartesiano nel quale la posizione del sistema di coordinate cartesiane degli assi di base X, Y e Z coincide con quella del sistema di coordinate cartesiane dell'utensile. Se ora si applica la regola della mano destra per determinare l'orientamento, ne risulta una rotazione dell'utensile intorno all'asse Y in direzione positiva.
Dati utensile per tool2:
X = Lunghezza x sin (30°) Scostamento lungo l'asse X
Y = 0 Scostamento lungo l'asse Y
Z = Lunghezza x cos (30°) Scostamento lungo l'asse Z
A = 0 Orientamento secondo Eulero, rotazione intorno all'asse Z
B = 30 Orientamento secondo Eulero, rotazione intorno all'asse Y ruotato
C = 0 Orientamento secondo Eulero, rotazione intorno all'asse Z ruotato
Esempio di programma:
La nostra cinematica cartesiana deve ora traslare con l'utensile verticale da una posizione 1 a una posizione 2. L'utensile viene poi ruotato mediante l'asse oscillante. L'utensile ruotato deve ora accostare la posizione 2.
Accostamento da pos1 a pos2:
Tool(tool1)
Lin(pos1)
Lin(pos2)
X
Z
Ventosa
Y
Lunghezza utensile
Asse rotativo
TCP
14. Utensili
128 Festo GDCP-CMXR-SW-IT it 0909a
Per le istruzioni di traslazione cartesiane da pos1 a pos2, l'unità di comando considera automaticamente i dati utensile attivi tool1.
Rotazione dell'asse oscillante:
:
Tool(tool1)
Lin(pos1)
Lin(pos2)
CALL Rotate() // richiamo del sottoprogramma
:
Il movimento oscillante provoca lo spostamento verso l'alto del TCP (Tool Center Point). A causa dell'asse pneumatico, l'unità di comando non può eseguire movimenti di compensazione automatici. Per raggiungere la posizione 2 è ora necessario definire il nuovo orientamento dell'utensile.
X
Z Y
Pezzo pos1 pos2
Z
X
Y
Pezzo pos1
pos2
Z
14. Utensili
Festo GDCP-CMXR-SW-IT it 0909a 129
Nuovo avvicinamento a pos2 con tool2:
:
Tool(tool1)
Lin(pos1)
Lin(pos2)
CALL Rotate() // richiamo del sottoprogramma
Tool(tool2)
Lin(pos2)
:
Il nuovo accostamento della posizione 2 ha come conseguenza che il TCP con i suoi nuovi dati viene allineato sulla posizione 2. A seconda dei casi può avvenire un movimento di compensazione con max. tutti gli assi.
Nota
Se si utilizza un asse oscillante elettrico caricato come grado di libertà nella cinematica cartesiana, non è necessario modificare l'orientamento dell'utensile come nel caso dell'asse oscillante pneumatico.
Con l'asse oscillante elettrico, l'orientamento desiderato viene programmato in un'istruzione di traslazione.
Il controller CMXR calcola poi automaticamente la posizione degli assi tenendo in considerazione l'orientamento programmato.
X
Y
Pezzo
pos2
Z Z
Movimento di compensazione
15. Interfaccia PROFIBUS
130 Festo GDCP-CMXR-SW-IT it 0909a
15. Interfaccia PROFIBUS Il CMXR può essere gestito da un comando principale (PLC/PC industriale) tramite l'interfaccia PROFIBUS. Inoltre è possibile scrivere e leggere dati sotto forma di variabili. Tutti questi dati sono dati globali del sistema e sono a disposizione di tutti i programmi FTL. La comunicazione con il comando principale avviene ciclicamente nel ciclo di aggiornamento del PROFIBUS.
Al riavvio del sistema tutti i valori sono azzerati. Eventuali dati necessari per l'elaborazione dei programmi devono essere trasmessi dal comando principale primo dell'avvio del programma.
Nota
Se un programma richiede dati consistenti, prima di elaborarli è necessario copiarli ad es. sui dati locali.
Nota
I dati dell'interfaccia non vengono archiviati nella memoria tam-pone e perciò, dopo un riavvio del sistema, hanno tutti il valore zero. Eventuali dati necessari per l'elaborazione devono essere scritti primi dell'avvio.
15. Interfaccia PROFIBUS
Festo GDCP-CMXR-SW-IT it 0909a 131
15.1 Indicazioni per l'elaborazione dei segnali
Le variabili FTL dell'interfaccia PLC trattate nei capitoli seguenti vengono sempre calcolate, come altre variabili, nel calcolo preliminare dei record del programma FTL. Se determinate variabili devono essere eseguite durante l'esecuzione della riga di programma attiva (elaborazione principale del programma), è necessario adottare misure supplementari. A tale scopo si può utilizzare ad esempio l'istruzione DO.
Nella grafica seguente vengono spiegate le differenze dell'elaborazione dei segnali:
15.2 Ingressi e uscite booleani
L'interfaccia comprende 16 segnali d'ingresso e di uscita digitali, che di seguito verranno sempre considerati dal punto di vista del CMXR. Tali segnali sono disponibili sul controller
sotto forma di variabile booleana. Questi segnali booleani vengono ciclicamente scambiati con il comando principale.
Nota
Le variabili booleane vengono automaticamente trasmesse al comando principale, o lette dal medesimo, tramite il ciclo del PROFIBUS.
Le variabili booleane sono memorizzate in un array accessibile mediante gli indici da 0 a 15.
Lin(pos1)
Lin(pos2)
Lin(pos3)
Lin(pos4)
Lin(pos5)
plc_Dint[1] := 2
Lin(pos6)
Lin(pos7)
Lin(pos8)
Lin(pos9)
Elaborazione
principale
Calcolo
preliminare
Lin(pos1)
Lin(pos2)
Lin(pos3)
Lin(pos4)
Lin(pos5) DO plc_Dint[1] := 1
Lin(pos6)
Lin(pos7) DO plc_DInt[3] := 2
Lin(pos8)
Lin(pos9)
Lin(pos10)
Elaborazione
principale
Calcolo
preliminare
La variabile viene
elaborata nel calcolo
preliminare dei record.
Utilizzo dell'istruzione DO, la
variabile viene elaborata durante
l'elaborazione principale del
programma.
15. Interfaccia PROFIBUS
132 Festo GDCP-CMXR-SW-IT it 0909a
Sintassi
plc_InBool [ <indice array> ] : BOOL
plc_OutBool [ <indice array> ] : BOOL
Nella variabile dell'array plc_InBool sono memorizzati tutti i segnali di ingresso. La varia-bile dell'array plc_OutBool contiene tutti i dati di uscita.
Esempio:
:
plc_OutBool[9] := FALSE // bit 9 al PLC su FALSE
IF plc_InBool[5] THEN // controllo bit 5 dal PLC
Lin(pos1)
Lin(pos2)
END_IF
plc_OutBool[9] := TRUE // bit 9 al PLC su TRUE
:
Esempi con calcolo preliminare dei record e con l'istruzione DO
15.3 Variabili intere a 32 bit
L'interfaccia offre 256 variabili intere del tipo di dati DINT, che comprende 32 bit. Queste variabili non sono soggette allo scambio ciclico dei dati e, in caso di necessità, possono essere scritte e lette dall'unità di comando esterna.
Nota
Le variabili intere non vengono automaticamente lette dal comando principale o trasmesse al medesimo. Se necessario devono essere trasmesse o lette dal comando principale.
Le variabili intere sono memorizzate in un array accessibile mediante gli indici da 0 a 255.
Sintassi
plc_Dint [ <indice array> ] : DINT
15. Interfaccia PROFIBUS
Festo GDCP-CMXR-SW-IT it 0909a 133
Esempio:
:
IF plc_Dint[3] = 13 THEN
:
:
END_IF
15.4 Posizioni
L'interfaccia supporta due tipi di dati di posizione. Dall'unità di comando esterna al con-
troller multiassiale CMXR possono essere trasmesse le posizioni degli assi e le posizioni cartesiane. Il numero massimo di posizioni è pari a 256 posizioni degli assi e 256 posizioni cartesiane. Queste variabili non sono soggette allo scambio ciclico dei dati e, in caso di necessità, possono essere scritte e lette dall'unità di comando esterna.
Nota
Le variabili di posizione non vengono automaticamente lette dal comando principale o trasmesse al medesimo. Se necessario devono essere inviate o lette dall'unità di comando esterna.
Le variabili di posizione sono memorizzate in array accessibili mediante gli indici da
0 a 255.
Nota
plc_AxisPos [ <indice array> ] : AXISPOS
plc_CartPos [ <indice array> ] : CARTPOS
La variabile dell'interfaccia plc_AxisPos contiene 256 posizioni del tipo di dati AXISPOS, la variabile plc_CartPos contiene 256 posizioni del tipo di dati CARTPOS.
Esempio:
:
Ptp(plc_AxisPos[17])
Lin(plc_AxisPos[18])
Lin(plc_AxisPos[19])
Lin(plc_CartPos[1])
:
15. Interfaccia PROFIBUS
134 Festo GDCP-CMXR-SW-IT it 0909a
15.5 Sistemi di riferimento
Mediante l'interfaccia esterna è possibile preimpostare al massimo 16 sistemi di riferi-mento. Queste variabili sono del tipo di dati REFSYSDATA e possono essere utilizzate con l'istruzione SetRefSys. Queste variabili non sono soggette allo scambio ciclico dei dati e,
in caso di necessità, possono essere scritte e lette dall'unità di comando esterna.
Nota
I sistemi di riferimento non vengono automaticamente letti dal comando principale o trasmessi al medesimo. Se necessario devono essere inviati o letti dall'unità di comando esterna.
I sistemi di riferimento sono memorizzati in un array accessibile mediante gli indici da 0 a 15.
Sintassi
plc_RefSys [ <indice array> ] : REFSYSDATA
Il tipo di dati REFSYSDATA offre la possibilità di associare un sistema di riferimento ad un altro in modo additivo. L'interfaccia supporta questa funzionalità, ma solo se avviene nell'ambito dell'interfaccia stessa. Ciò significa che non è possibile creare un riferimento a sistemi di riferimento che si trovano nel sistema. Il riferimento a un altro sistema di riferi-
mento viene creato preimpostando un numero da 0 a 15 mediante l'unità di comando esterna. Preimpostando il valore -1 viene creato il riferimento al sistema di coordinate globali della cinematica.
Nota
I sistemi di riferimento preimpostati mediante l'interfaccia esterna possono essere associati solo ad altri sistemi di riferimento dell'in-terfaccia. Non è possibile creare un riferimento a sistemi che si trovano all'esterno dell'interfaccia.
Esempio:
:
Lin(pos2)
SetRefSys(plc_RefSys[3])
Lin(pos3)
Lin(pos4)
:
15. Interfaccia PROFIBUS
Festo GDCP-CMXR-SW-IT it 0909a 135
15.6 Arresto programmato <ProgHold>
Questa istruzione funziona in abbinamento al segnale HALTENA dell'interfaccia PLC. È indicata per scopi di test o per la messa in servizio e può essere inserita in qualsiasi riga di programma per provocare l'arresto del programma quando richiesto.
Quando il segnale HALTENA sull'interfaccia è attivato, cioè ha lo stato TRUE, richiamando la macro ProgHold viene arrestato il programma di movimenti. In questo caso viene arrestato solo il programma nel quale si trova la macro ProgHold. Altri programmi, ad es. i programmi paralleli, continuano ad essere elaborati. Quando il PLC imposta il segnale HALTENA su FALSE, il programma arrestato viene proseguito.
Nota
Se con la macro ProgHold vengono arrestati più programmi (ad es. programmi paralleli), essi verranno riavviati insieme non appena è disponibile lo stato di segnale FALSE. Un avvio selettivo di singoli programmi arrestati non è possibile.
Sintassi
ProgHold ( )
Per richiamare la macro non è necessario alcun parametro.
Esempio:
:
OvlVel(100) // approssimazione completa
Lin(pos1)
Lin(pos2)
ProgHold ( ) // arresto programmato
Lin(pos3)
Lin(pos4)
ProgHold ( ) // arresto programmato
Lin(pos5)
:
In questo esempio di programma vengono accostate diverse posizioni con un'approssimazione della velocità impostata al 100 %. Settando il segnale per l'arresto programmato, in queste posizioni si verifica un arresto. Ne risulta il seguente andamento della velocità:
15. Interfaccia PROFIBUS
136 Festo GDCP-CMXR-SW-IT it 0909a
Andamento con l'arresto programmato:
Andamento senza l'arresto programmato:
pos2 pos1 pos3 pos4 pos5
Velocità
Tempo
Intervallo di tempo tra l'arresto e il riavvio
pos2 pos1 pos3 pos4 pos5
Velocità
Tempo
16. Sistema di segnalazione
Festo GDCP-CMXR-SW-IT it 0909a 137
16. Sistema di segnalazione Il programma di movimenti può generare dei messaggi. Esistono i seguenti tipi di messaggio:
Informazione
Avvertenza
Errore
Questi messaggi vengono registrati nella memoria messaggi dell'unità di comando e archiviati in maniera corrispondente. I messaggi vengono resettati (cancellati) sull'unità di comando manuale o tramite un'unità di comando esterna.
Illustrazione della memoria errori sull'unità di comando manuale:
16.1 Testi dei messaggi
La programmazione in FTL (Festo Teach Language) consente la generazione di messaggi d'informazione, di avvertimento e d'errore dal programma di movimenti. I testi dei messaggi vengono definiti dall'utente stesso come catena di caratteri (stringa). Questa catena di caratteri può contenere anche registrazioni variabili sotto forma di un massimo di 2 parametri (ad es. DINT, REAL, String, BOOL). I 2 parametri opzionali vengono inseriti nel testo del messaggio mediante l'indicazione di un carattere percentuale e un numero.
%1 significa 1° parametro opzionale
%2 significa 2° parametro opzionale
16. Sistema di segnalazione
138 Festo GDCP-CMXR-SW-IT it 0909a
Indicando tipi di dati quali le posizioni degli assi, nella stringa viene inserito solamente il
nome della variabile. I tipi di dati strutturati non possono essere rappresentati nel testo di un messaggio.
Nota
In caso di trasferimento di variabili del tipo DINT, REAL e String viene inserito il contenuto delle variabili nel testo del messaggio. Con variabili del tipo BOOL, nel testo del messaggio viene inserito il testo TRUE o FALSE a seconda dello stato.
Esempio:
In un programma vengono create due variabili, alle quali vengono poi assegnati dei valori. Questi valori vengono emessi con la macro SetInfo.
Variabili:
param1 : DINT := 7
param2 : REAL := 3.48
Codice del programma:
SetInfo(“Sensor %1, pressure %2 bar”, param1, param2)
Viene visualizzato il seguente testo informativo: “Sensor 7, pressure 3,48 bar”.
16. Sistema di segnalazione
Festo GDCP-CMXR-SW-IT it 0909a 139
16.2 Informazione <SetInfo>
L'istruzione SetInfo genera un messaggio d'informazione nel sistema di segnalazione.
Sintassi
SetInfo( <text> : STRING,
OPT <param1> : ANY,
OPT <param2> : ANY)
Parametro Significato Unità
text Testo del messaggio informativo STRING
param1 1° parametro possibile ANY
param2 2° parametro possibile ANY
Tabella 16.1 Parametri dell'istruzione SetInfo
La composizione del testo del messaggio è descritta nel capitolo 16.1 Testi dei messaggi a pagina 137.
Un messaggio d'informazione viene contrassegnato con il simbolo nella memoria errori del controller multiassiale CMXR.
Nota
Un messaggio d'informazione non ha alcun effetto sul movimento. Serve unicamente come informazione.
Esempio:
pressure := Sensor.Read(); // lettura di un valore
di pressione
cycle := cycle + 1 // conteggio ciclo
SetInfo (“Cycle %1 finished, Value %2”, cycle, pressure)
Visualizzazione sull'unità di comando manuale:
16. Sistema di segnalazione
140 Festo GDCP-CMXR-SW-IT it 0909a
16.3 Avvertenza <SetWarning>
L'istruzione SetWarning genera un messaggio di avvertimento nel sistema di
segnalazione.
Sintassi
SetWarning( <text> : STRING,
OPT <param1> : ANY,
OPT <param2> : ANY)
Parametro Significato Unità
text Testo del messaggio di
avvertimento
STRING
param1 1° parametro possibile ANY
param2 2° parametro possibile ANY
Tabella 16.2 Parametri dell'istruzione SetWarning
La composizione del testo del messaggio è descritta nel capitolo 16.1 Testi dei messaggi a pagina 137.
Un messaggio di avvertimento viene contrassegnato con il simbolo nella memoria
errori del controller multiassiale CMXR.
Nota
Un messaggio di avvertimento non ha alcun effetto sul movimento. Serve unicamente come informazione.
Esempio:
pressure := Sensor.Read(); // lettura di un valore di pressione
cycle := cycle + 1 // conteggio ciclo
SetWarning(“Cycle %1 finished, Value %2”,cycle, pressure)
Visualizzazione sull'unità di comando manuale:
16. Sistema di segnalazione
Festo GDCP-CMXR-SW-IT it 0909a 141
16.4 Messaggio di errore <SetError>
L'istruzione SetError genera un messaggio d'errore nel sistema di segnalazione. Questa
istruzione influisce sull'elaborazione del programma, il quale viene arrestato. Eventuali movimenti in corso vengono arrestati, il programma / movimento viene proseguito solo dopo aver confermato il messaggio di errore.
Sintassi
SetError( <text> : STRING,
OPT <param1> : ANY,
OPT <param2> : ANY)
Parametro Significato Unità
Testo Testo del messaggio di errore STRING
param1 1° parametro possibile ANY
param2 2° parametro possibile ANY
Tabella 16.3 Parametri dell'istruzione SetError
Un messaggio di errore viene contrassegnato con il simbolo nella memoria errori del controller multiassiale CMXR.
Nota
L'emissione di un messaggio di errore provoca un'interruzione del movimento. La cinematica può proseguire la lavorazione solo dopo la conferma del messaggio di errore.
Esempio:
pressure := Sensor.Read(); // lettura di un valore
di pressione
cycle := cycle + 1 // conteggio ciclo
SetError(“Cycle %1 error, pressure %2”, cycle, pressure)
Visualizzazione sull'unità di comando manuale:
Nel caso di un messaggio di errore, il testo dell'errore viene visualizzato anche nella riga di intestazione dell'unità di comando manuale. Inoltre si accende in rosso il LED Error sull'unità di comando manuale.
17. Funzioni
142 Festo GDCP-CMXR-SW-IT it 0909a
17. Funzioni
17.1 Lettura della posizione corrente <ReadActualPos>
Lettura della posizione corrente della cinematica.
Sintassi
ReadActualPos (<Pos> : POSITION)
La posizione corrente del robot viene scritta nella variabile passata. Se la variabile passata
è del tipo CARTPOS, la posizione viene memorizzata come valore cartesiano. Se viene passata una variabile del tipo AXISPOS, la posizione viene memorizzata in coordinate degli assi.
Parametro Significato Unità
Pos Variabile di arrivo della posizione letta AXISPOS o CARTPOS
Tabella 17.1 Parametri dell'istruzione ReadActualPos
Attenzione
Un valore di posizione memorizzato in una variabile viene conservato solamente finché il programma o il progetto è caricato. I valori delle variabili non vengono memorizzati nel file di dati sulla scheda di memoria. Alla chiusura del programma/progetto, i valori vanno persi. Per salvare la posizione si può utilizzare la macro SavePosition.
Esempio:
Il programma nell'esempio legge la posizione corrente, esegue le istruzioni di movimento programmate e alla fine ritorna nella posizione letta.
Variabile:
startPos : AXISPOS := (0, 0, 0, 0, 0, 0, 0, 0, 0)
axis0 : AXISPOS := (0, 0, 0, 0, 0, 0, 0, 0, 0)
axis1 : AXISPOS := (60, -120, 0, 0, 0, 0, 0, 0, 0)
axis2 : AXISPOS := (-120, -120, -250, 0, 0, 0, 0, 0, 0)
17. Funzioni
Festo GDCP-CMXR-SW-IT it 0909a 143
Programma:
ReadActualPos(startPos)
PTP(axis0)
PTP(axis1)
PTP(axis2)
PTP(startPos)
17.2 Lettura della posizione di arrivo <ReadTargetPos>
Lettura della posizione di arrivo programmata della cinematica.
Sintassi
ReadTargetPos (<Pos> : POSITION)
La posizione di arrivo attualmente programmata del robot viene scritta nella variabile passata. Se la variabile passata è del tipo CARTPOS, la posizione viene memorizzata come valore cartesiano. Se viene passata una variabile del tipo AXISPOS, la posizione viene memorizzata in coordinate degli assi.
Parametro Significato Unità
Pos Variabile di arrivo della posizione letta AXISPOS o CARTPOS
Tabella 17.2 Parametri dell'istruzione ReadTargetPos
Attenzione
Un valore di posizione memorizzato in una variabile viene conservato solamente finché il programma o il progetto è caricato. I valori non vengono memorizzati nel file di dati sulla scheda di memoria. Alla chiusura del programma o del progetto, i valori vanno persi. Per salvare la posizione si può utilizzare la macro SavePosition.
17. Funzioni
144 Festo GDCP-CMXR-SW-IT it 0909a
17.3 Salvataggio permanente di un valore di posizione <SavePosition>
La macro memorizza un valore di posizione in modo permanente sulla scheda di memoria.
Sintassi
SavePosition (<Pos> : POSITION)
Con la macro SavePosition è possibile salvare i valori della variabile specificata <Pos> nel
file di dati sulla scheda di memoria. In tal modo è possibile ripristinare la posizione al
riavvio dell'unità di comando.
Parametro Significato Unità
Pos Posizione da memorizzare AXISPOS o CARTPOS
Tabella 17.3 Parametri dell'istruzione SavePosition
Attenzione
Una riscrittura frequente di posizioni sulla scheda di memoria riduce la durata della scheda. La macro SavePosition non si può richiamare ciclicamente. Può essere utilizzata per l'impostazione occasionale dell'applicazione.
17.4 Lettura dell'ora del sistema <Time>
Lettura dell'ora del sistema in secondi a partire dal 01.01.1970 alle ore 00:00.
Sintassi
(<valore di tempo> : DINT) := Time ( )
Questa istruzione legge l'ora corrente del sistema dell'unità di comando e la restituisce come valore DINT.
Esempio:
value := Time() // lettura dell'ora corrente del sistema
17. Funzioni
Festo GDCP-CMXR-SW-IT it 0909a 145
17.5 Conversione dell'ora in testo <TimeToStr>
Conversione di un'indicazione dell'ora in un testo.
Sintassi
(<stringa dell'ora> : STRING) := TimeToStr (OPT sysTime : DINT)
Questa istruzione consente di convertire un'indicazione dell'ora (parametro sysTime) in un testo formattato con il formato “DDD mon dd hh:mm:ss yyyy”. Senza il parametro sysTime viene restituita l'ora corrente del sistema formattata.
Il parametro sysTime segnala l'ora in secondi a partire dal 01.01.1970 alle ore 00:00.
Parametri:
Parametro Significato Unità
sysTime Indicazione opzionale, valore
temporale da convertire.
Secondi
Tabella 17.4 Parametri della funzione TimeStr
Esempio:
str_Time := TimeToStr() // lettura dell'ora corrente
del sistema
Valore restituito:
str_Time = “Mon Feb 13 11:23:44 2006”
17. Funzioni
146 Festo GDCP-CMXR-SW-IT it 0909a
17.6 Seno <SIN>, <ASIN>
La funzione seno crea la relazione matematica tra un angolo e i lati in un triangolo rettangolo.
Per il seno vale quanto segue:
sin (alpha) = cateto opposto / ipotenusa
sin (alpha) = a / c
L'angolo viene indicato in gradi.
Sintassi
(<valore seno> : REAL) := SIN(<angolo> : REAL)
Utilizzo:
La funzione seno serve per calcolare segmenti incogniti in un triangolo rettangolo. Se è
noto l'angolo e il cateto opposto oppure l'ipotenusa, è possibile calcolare il segmento incognito.
Se occorre invece calcolare l'angolo, il CMXR mette a disposizione la funzione arco seno. Questa funzione calcola l'angolo, ad es. alfa, in base al cateto opposto e all'ipotenusa.
Sintassi
(<angolo in gradi> : REAL) := ASIN(<valore seno>)
L'angolo viene indicato in gradi.
17. Funzioni
Festo GDCP-CMXR-SW-IT it 0909a 147
Esempio:
a := 30 // cateto opposto
alpha := 23.5 // angolo alfa
c := a / SIN(alpha) // calcolo dell'ipotenusa
a : = 45.89 // cateto opposto
c := 145.67 // ipotenusa
value := a / c
alpha := ASIN(value) // calcolo dell'angolo
17.7 Coseno <COS>, <ACOS>
La funzione coseno crea la relazione matematica tra un angolo e i lati in un triangolo rettangolo.
Per il coseno vale quanto segue:
cos (alpha) = cateto adiacente / ipotenusa
cos (alpha) = b / c
L'angolo viene indicato in gradi.
Sintassi
(<valore coseno> : REAL) := COS(<angolo>)
Utilizzo:
La funzione coseno serve per calcolare segmenti incogniti in un triangolo rettangolo. Se è noto l'angolo e il cateto adiacente oppure l'ipotenusa, è possibile calcolare il segmento incognito.
Se occorre invece calcolare l'angolo, il CMXR mette a disposizione la funzione arco coseno. Questa funzione calcola l'angolo, ad es. alfa, in base al cateto adiacente e all'ipotenusa.
17. Funzioni
148 Festo GDCP-CMXR-SW-IT it 0909a
Sintassi
(<angolo in gradi> : REAL) := ACOS(<valore coseno>)
L'angolo viene restituito in gradi.
Esempio:
b := 30 // cateto adiacente
alpha := 23.5 // angolo alfa
c := b / COS(alpha) // calcolo dell'ipotenusa
b := 45.89 // cateto adiacente
c := 145.67 // ipotenusa
value := b / c
alpha := ACOS(value) // calcolo dell'angolo
17. Funzioni
Festo GDCP-CMXR-SW-IT it 0909a 149
17.8 Tangente <TAN>, <ATAN>
La funzione tangente crea la relazione matematica tra un angolo e i lati in un triangolo rettangolo.
Per la tangente vale quanto segue:
tan (alpha) = cateto opposto / cateto adiacente
tan (alpha) = a / b
L'angolo viene indicato in gradi.
Sintassi
(<valore tangente> : REAL) := TAN( <angolo>)
Utilizzo:
La funzione tangente serve per calcolare segmenti incogniti in un triangolo rettangolo. Se è noto l'angolo e il cateto adiacente oppure il cateto opposto, è possibile calcolare il segmento incognito.
Se occorre invece calcolare l'angolo, il CMXR mette a disposizione la funzione arco tangente. Questa funzione calcola l'angolo, ad es. alfa, in base al cateto adiacente e al cateto opposto.
Sintassi
(<angolo in gradi> : REAL) := ATAN(<valore tangente>)
L'angolo viene restituito in gradi.
Esempio:
a := 30 // cateto opposto
alpha := 23.5 // angolo alfa
b := a / TAN(alpha) // calcolo del cateto adiacente
17. Funzioni
150 Festo GDCP-CMXR-SW-IT it 0909a
a := 45.89 // cateto opposto
b := 145.67 // cateto adiacente
value := a / b
alpha := ATAN(value) // calcolo dell'angolo incluso
17.9 Cotangente <COT>, <ACOT>
La funzione cotangente crea la relazione matematica tra un angolo e i lati in un triangolo rettangolo.
Per la cotangente vale quanto segue:
Cotan (alpha) = cateto adiacente / cateto opposto
cotan (alpha) = b / a
L'angolo viene indicato in gradi.
Sintassi
(<valore cotangente> : REAL) := COT(<angolo>)
Utilizzo:
La funzione cotangente serve per calcolare segmenti incogniti in un triangolo rettangolo. Se è noto l'angolo e il cateto adiacente oppure il cateto opposto, è possibile calcolare il segmento incognito.
Se occorre invece calcolare l'angolo, il CMXR mette a disposizione la funzione arco cotangente. Questa funzione calcola l'angolo, ad es. alfa, in base al cateto adiacente e al
cateto opposto.
Sintassi
(<angolo in gradi> : REAL) := ACOT(<valore cotangente>)
L'angolo viene restituito in gradi.
17. Funzioni
Festo GDCP-CMXR-SW-IT it 0909a 151
Esempio:
a := 30 // cateto opposto
alpha := 23.5 // angolo alfa
b := a * COT(alpha) // calcolo del cateto adiacente
a := 45.89 // cateto opposto
b := 145.67 // cateto adiacente
value := b / a
alpha := ACOT(value) // calcolo dell'angolo incluso
17.10 Arcotangente2 <ATAN2>
Calcola l'arcotangente con un aumento dell'intervallo di valori da + π a –π.
Sintassi
(<argomento> : REAL) := ATAN2 (<y> : REAL, <x> : REAL)
17.11 Logaritmo <LN>
La funzione logaritmo calcola il logaritmo naturale dell'argomento passato.
Sintassi
(<logaritmo naturale> : REAL) := LN (<valore> : REAL)
17.12 Esponente <EXP>
La funzione esponente calcola il valore e(x).
Sintassi
(<risultato> : REAL) := EXP (<valore>:REAL)
17. Funzioni
152 Festo GDCP-CMXR-SW-IT it 0909a
17.13 Valore assoluto <ABS>
La funzione di valore assoluto fornisce l'ammontare assoluto del valore REAL passato. Il valore restituito è quindi sempre positivo. I numeri negativi vengono restituiti come valore con segno positivo.
Sintassi
(<valore assoluto> : REAL) := ABS (<valore> : REAL)
Esempio
Level := 452.98
Level := ABS(Level) // Level ha il valore assoluto di 452.98
Level := -1056.61
Level := ABS(Level) // Level ha il valore assoluto di 1056.61
17.14 Radice quadrata <SQRT>
La funzione radice rileva il valore della radice quadrata di un'espressione.
Sintassi
(<valore radice> : REAL) := SQRT (<valore> : REAL)
Esempio:
Calcolo della lunghezza c in un triangolo rettangolo.
Secondo il teorema di Pitagora vale quanto segue:
C² = A² + B² oppure C = √(A² + B²)
Esempio di programma:
a := 152.67 // lunghezza del cateto A
b := 63.12 // lunghezza del cateto B
value := a * a + b * b
c := SQRT(value) // calcolo dell'ipotenusa
17. Funzioni
Festo GDCP-CMXR-SW-IT it 0909a 153
17.15 Spostamento dei bit <SHR>, <SHL>
Con le funzioni SHR e SHL è possibile spostare i bit di dati del tipo DWORD verso destra (funzione SHR) e verso sinistra (funzione SHL). I bit spostati “fuori” dalla variabile su un
lato vanno persi. Sull'altro lato vengono aggiunti bit con il valore “0”.
Sintassi
(<variabile> :DWORD) := SHR (<valore : DWORD>, <count> : DINT)
(<variabile> :DWORD) := SHL (<valore : DWORD>, <count> : DINT)
Esempio:
Con l'istruzione
Mask := SHL(Mask, 3)
il contenuto della variabile Mask viene spostato di 3 bit verso sinistra. Sul lato destro vengono inseriti 3 bit con il valore “0”.
Contenuto della variabile:
1001 1111 0000 1100 1111 1111 1001 1100
Si ottiene lo schema di codifica a bit seguente:
1111 1000 0110 0111 1111 1100 1110 0000
Con l'istruzione
Mask := SHR(Mask, 3)
il contenuto della variabile Mask viene spostato di 3 bit verso destra. Sul lato sinistro vengono inseriti 3 bit con il valore “0”.
Contenuto della variabile:
1001 1111 0000 1100 1111 1111 1001 1100
Si ottiene lo schema di codifica a bit seguente:
0001 0011 1110 0001 1001 1111 1111 0011
17. Funzioni
154 Festo GDCP-CMXR-SW-IT it 0909a
17.16 Rotazione dei bit <ROR>, <ROL>
Con le funzioni ROR e ROL è possibile ruotare i bit di dati del tipo DWORD verso destra (funzione ROR) e verso sinistra (funzione ROL). Durante la rotazione dello schema di
codifica a bit, il bit eliminato viene reinserito sull'altro lato.
Sintassi
(<variabile> : DWORD) := ROR (<valore : DWORD>, <count> : DINT)
(<variabile> : DWORD) := ROL (<valore : DWORD>, <count> : DINT)
Esempio:
Con l'istruzione
Mask := ROL(Mask, 4)
il contenuto della variabile Mask viene ruotato di 4 bit verso sinistra. I 4 bit vengono reinseriti sul lato destro.
Contenuto della variabile:
1011 1111 0110 1001 0011 000 1001 1010
Si ottiene lo schema di codifica a bit seguente:
1111 0110 1001 0011 000 1001 1010 1011
Con l'istruzione
Mask := ROR(Mask, 4)
il contenuto della variabile Mask viene ruotato di 4 bit verso destra. I 4 bit vengono reinseriti sul lato sinistro.
Contenuto della variabile:
1011 1111 0110 1001 0011 000 1001 1010
Si ottiene lo schema di codifica a bit seguente:
1010 1011 1111 0110 1001 0011 000 1001
17. Funzioni
Festo GDCP-CMXR-SW-IT it 0909a 155
17.17 Conversione di un valore in una stringa <STR>
Converte un tipo di dati qualsiasi in una stringa.
Sintassi
(<variabile> : STRING) := STR (<valore> : ANY)
Esempio:
Con l'istruzione STR il valore della variabile Real1 viene convertito in una stringa.
Real1 := 25.5
String1 := STR(Real1)
String1 ha ora il valore “25.500000”.
17.18 Conversione di un valore ASCII in un carattere <CHR>
Converte un valore ASCII in un singolo carattere.
Sintassi
(<variabile> : STRING) := CHR (<valore> : DINT / DWORD)
Esempio:
Con l'istruzione seguente la variabile String1 riceve il valore “a”.
String1 := CHR(97)
17.19 Conversione di un carattere in un valore ASCII <ORD>
Converte un singolo carattere nel valore ASCII.
Sintassi
(<variabile> : DINT / DWORD) := ORD (<valore> : STRING)
Esempio:
Con l'istruzione seguente la variabile Dint1 riceve il valore 65.
Dint1 := ORD(“A”)
18. Moduli
156 Festo GDCP-CMXR-SW-IT it 0909a
18. Moduli Il linguaggio FTL offre la possibilità di utilizzare i moduli. I moduli contengono, oltre ai dati, anche componenti in forma di codice di programma per ottenere determinate funzionalità. Per poter comunicare in FTL, un modulo dispone di dati di ingresso e di uscita.
Rappresentazione grafica di un modulo:
Il numero di dati di ingresso / uscita di un modulo in FTL è prestabilito in un tipo di dati. Per poter utilizzare un modulo nell'applicazione è necessario dichiararlo. Nel caso di un modulo si parla di istanziazione. Dal nome liberamente selezionabile del modulo (identificatore) viene creata una copia della struttura del modulo, che comprende i dati di ingresso e di uscita e i dati di programma interni. Il codice di programma vero e proprio esiste solo una volta.
Dichiarazione di un'istanza di modulo
<nome istanza> : <tipo istanza> ( parametro )
Analogamente alle variabili, le istanze vengono memorizzate nel rispettivo file di dati.
Modulo: valore analogico
Codice di programma
interno
Dati di ingresso del
modulo
Dati di uscita del
modulo
Tipo di modulo
valore analogico
Sistema operativo Programma FTL
Pressione: tipo valore analogico
Peso: tipo valore analogico
Istanze di modulo nel programma applicativo
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 157
Esempio di un'istanza
Sensor : AIN(…)
A seconda del tipo di modulo, durante la dichiarazione vengono assegnati dati al modulo, quali ad es. il nome di un segnale hardware. La documentazione dei moduli è riportata nei capitoli seguenti.
18.1 Funzioni
Per accedere ai dati o utilizzare le funzionalità di un modulo sono disponibili le funzioni di modulo corrispondenti. L'accesso alle funzioni del modulo avviene tramite il nome dell'istanza e l'operatore punto.
Accesso alle funzioni di un modulo
<nome istanza> . <nome funzione>
Nell'esempio è descritto l'accesso alla funzione di modulo Read dell'istanza Sensor:
merker := Sensor.Read()
Con alcune funzioni si possono passare dei parametri. Per maggiori dettagli consultare i capitoli seguenti dedicati ai singoli moduli.
18.2 Variabili
Oltre alle funzioni, i moduli possono contenere anche variabili. Con queste variabili è possibile accedere ai dati di un modulo. L'accesso alle variabili di un modulo avviene tramite il nome dell'istanza e l'operatore punto.
Accesso alla variabile di un modulo
<nome istanza> . <nome variabile>
In determinati moduli, l'accesso ai dati può avvenire sia con le variabili che con le funzioni. Il risultato è identico in entrambi i casi. Questi due tipi di accesso hanno tempi di
esecuzione diversi. Per maggiori dettagli consultare i capitoli dei singoli moduli.
Nell'esempio è descritto l'accesso alla variabile di modulo State dell'istanza Sensor:
IF Sensor.state THEN
Lin(pos1)
ELSE
Lin(pos2)
END_IF
18. Moduli
158 Festo GDCP-CMXR-SW-IT it 0909a
Consiglio:
Quando possibile è preferibile utilizzare l'accesso mediante una variabile, che richiede un minor tempo di esecuzione.
18.3 Comportamento in fase di esecuzione
Il programma FTL non viene elaborato ciclicamente bensì in modo sequenziale, istruzione dopo istruzione. Questo comportamento non è tuttavia sufficiente per determinate appli-cazioni. Se ad es. durante l'esecuzione di un programma di movimenti occorre verificare se su un ingresso si è verificata una variazione di fronte, è necessario creare un programma parallelo con un notevole dispendio di tempo. Per semplificare e ottimizzare il processo di elaborazione, alcuni moduli funzionano ciclicamente nel sistema operativo. L'utente può
così accedere ai risultati del modulo per mezzo di metodi o variabili.
18.3.1 Parametro ovlEnable
Alcuni metodi dei moduli seguenti dispongono di un parametro ovlEnable opzionale.
Questo parametro regola il momento di interrogazione del segnale di ingresso digitale. Il parametro è del tipo BOOL e può assumere lo stato TRUE o FALSE.
Stato FALSE
Il calcolo preliminare dei record viene arrestato in questo punto. Quando l'elaborazione principale dei record raggiunge questa istruzione di programma, il segnale viene letto e/o
eseguito. Il movimento viene arrestato e poi nuovamente accelerato dopo l'istruzione. Un'approssimazione per i movimenti successivi non è possibile.
Stato TRUE
Se al parametro ovlEnable viene passato lo stato TRUE, il segnale viene letto e/o eseguito nell'ultimo momento possibile per poter proseguire il movimento. Il movimento non viene arrestato bensì proseguito senza interruzioni. Un'approssimazione per i movimenti successivi è possibile.
Nota
Se il parametro non viene specificato, viene assunto lo stato FALSE.
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 159
18.4 Modulo di ingresso digitale DIN
Il modulo DIN serve per l'interrogazione e la gestione di un ingresso digitale.
18.4.1 Istanziazione
Per l'istanziazione del modulo di ingresso digitale è necessario il riferimento hardware con l'ingresso digitale. Questo viene indicato tramite il parametro <input> in fase di istanzia-zione.
Sintassi
<nome istanza> .DIN( <Timeout> : DINT,
<RisingEdge> : BOOL,
MAPX(“< input>”))
È possibile specificare ulteriori parametri, ad es. per eseguire delle preimpostazioni. Ciò non è tuttavia necessario ai fini dell'istanziazione e può avvenire anche nel programma.
Esempio:
Un sensore viene impostato come istanza di un modulo:
Istanziazione nel file di dati:
Sensor : DIN := (-1, FALSE, MAPX(“_system.Input1”))
Istanziazione con l'editor FTL
L'istanziazione avviene nella finestra di dialogo per la creazione di variabili, selezionando il
tipo (<Type:>) DIN e impostando l'identificatore (<Identifier:>) Sensor. Nella riga <MAPTO DINPORT> viene creato il riferimento reale ad un ingresso digitale configurato.
18. Moduli
160 Festo GDCP-CMXR-SW-IT it 0909a
Istanziazione con l'unità di comando manuale
L'istanziazione del modulo di ingresso digitale mediante l'unità di comando manuale avviene nella maschera delle variabili selezionando il tipo di dati DIN. La registrazione viene automaticamente memorizzata nel file di dati.
Il modulo di ingresso digitale possiede le seguenti variabili:
Variabile Tipo Significato Stato alla creazione
Timeout REAL Timeout di attesa con le istruzioni Wait e WaitN.
-1 = nessun timeout (attesa infinita)
0 = controllo immediato
>0 = timeout in millisecondi
-1
RisingEdge BOOL Stato del fronte ascendente FALSE
Input DINPORT Rimando all'ingresso hardware ---
Tabella 18.1 Variabili del modulo di ingresso digitale
Timeout
Con il parametro Timeout si può definire un tempo di attesa. Il metodo del modulo attende lo stato del segnale richiesto per il tempo impostato.
Impostando il valore -1 si verifica un'attesa infinita.
Indicando un valore > 0 il programma attende al massimo per il tempo impostato. Se al termine del tempo di attesa non si è verificato lo stato di segnale desiderato, l'esecuzione del programma viene proseguita. Un messaggio d'errore deve essere
generato dal programma sequenziale stesso.
Indicando il valore 0 viene eseguito un controllo immediato. Se il segnale non ha il valore desiderato, il programma sequenziale deve generare un messaggio di errore.
Ulteriori informazioni e un esempio di creazione del messaggio di errore sono riportati nel capitolo 20.2 Utilizzo dei moduli di ingresso e di uscita.
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 161
RisingEdge
Sebbene non venga richiamato, il modulo memorizza lo stato di un fronte ascendente. Questo stato può essere analizzato nel programma.
Input
La variabile Input descrive il rimando all'ingresso hardware del modulo.
18.4.2 Metodi
Il modulo dispone di più metodi:
Metodo Descrizione
Wait Attesa finché l'ingresso non assume lo stato TRUE
WaitN Attesa finché l'ingresso non assume lo stato FALSE
Read Lettura dello stato dell'ingresso
RisingEdge Lettura dello stato del fronte ascendente
ResetRisingEdge Reset dello stato del fronte ascendente
Tabella 18.2 Metodi del modulo di ingresso digitale DIN
Nell'editor FTL, dopo l'immissione del punto i metodi disponibili vengono automatica-mente visualizzati in una lista da dove possono essere selezionati.
Mediante l'unità di comando manuale si possono selezionare questi metodi dalla struttura a menu nella cartella “Digital Inputs”.
La figura mostra le selezione dei metodi del modulo DIN sull'unità di comando manuale.
18. Moduli
162 Festo GDCP-CMXR-SW-IT it 0909a
18.4.3 Attesa dello stato, metodo Wait / WaitN
Con i metodi Wait e WaitN si può fare attendere al programma FTL fino a quando l'ingresso assume il valore TRUE o FALSE. L'attesa tiene in considerazione il timeout eventualmente impostato.
Sintassi
<nome istanza>.Wait (OPT ovlEnable : BOOL)
<nome istanza>.WaitN (OPT ovlEnable : BOOL)
Per la descrizione del parametro ovlEnable vedi capitolo 18.3.1 a pagina 158.
Esempio:
Ptp(pos0)
sensor.Wait() // attesa del segnale TRUE, movimento
arrestato
Ptp(pos1)
sensor.WaitN(TRUE) // attesa del segnale FALSE, nessun arresto
Ptp(pos2)
18.4.4 Lettura dello stato, metodo Read
Con il metodo Read si può leggere lo stato corrente dell'ingresso. Come valore di ritorno viene restituito lo stato TRUE o FALSE.
Sintassi
<nome istanza>.Read (OPT ovlEnable: BOOL) : BOOL
Per la descrizione del parametro ovlEnable vedi capitolo 18.3.1 a pagina 158.
Esempio:
value := sensor.Read()
18.4.5 Fronte ascendente, metodo RisingEdge
Con il metodo RisingEdge si può controllare se sull'ingresso si è verificato un fronte ascendente e se questo è stato memorizzato. Il valore di ritorno può essere TRUE anche se l'ingresso nel frattempo ha assunto lo stato FALSE. Lo stato del fronte viene rilevato indipendentemente dal ciclo del programma FTL e si svolge in un ciclo proprio.
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 163
Sintassi
<nome istanza>.RisingEdge (OPT ovlEnable: BOOL) : BOOL
Per la descrizione del parametro ovlEnable vedi capitolo 18.3.1 a pagina 158.
Esempio:
value := sensor.RisingEdge()
18.4.6 Reset del fronte, metodo ResetRisingEdge
Questo metodo resetta il flag interno del fronte ascendente. Ciò si rende necessario quando si vuole controllare un fronte ascendente con il metodo RisingEdge.
Sintassi
<nome istanza>.ResetRisingEdge()
Nota
Se il valore dell'ingresso digitale è impostato nel momento in cui viene eseguita questa istruzione, lo stato di rilevamento del fronte viene resettato e non più reimpostato. Esso viene reimpostato solamente dopo che sull'ingresso si è verificato un fronte positivo (variazione di stato dell'ingresso da 0 a 1).
Esempio:
sensor.ResetRisingEdge()
value := sensor.RisingEgde()
18.5 Modulo di uscita digitale DOUT
Il modulo DOUT serve per l'interrogazione e la gestione di un'uscita digitale.
18.5.1 Istanziazione
Per l'istanziazione del modulo di uscita digitale è necessario il riferimento hardware con l'uscita digitale. Questo viene indicato tramite il parametro <output> in fase di istanziazione.
Sintassi
<nome istanza> .DOUT( <Timeout> : DINT,
<RisingEdge> : BOOL,
MAPX(“< output>”))
18. Moduli
164 Festo GDCP-CMXR-SW-IT it 0909a
È possibile specificare ulteriori parametri, ad es. per eseguire delle preimpostazioni. Ciò
non è tuttavia necessario ai fini dell'istanziazione e può avvenire anche nel programma.
Esempio:
Un cilindro viene impostato come istanza di un modulo:
Istanziazione nel file di dati:
cylinder : DOUT := (-1,FALSE, MAPX(“_system.Output3”))
Istanziazione con l'editor FTL
L'istanziazione avviene nella finestra di dialogo per la creazione di variabili, selezionando il tipo (<Type:>) DOUT e impostando l'identificatore (<Identifier:>) Cylinder. Nella riga <MAPTO DOUTPORT> viene creato il riferimento reale ad un'uscita digitale configurata.
Istanziazione con l'unità di comando manuale
L'istanziazione del modulo di uscita digitale mediante l'unità di comando manuale avviene nella maschera delle variabili selezionando il tipo di dati DOUT.
Con l'istanziazione sull'unità di comando manuale, la registrazione viene automatica-mente memorizzata nel file di dati.
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 165
18.5.2 Variabili
Il modulo di uscita digitale possiede le seguenti variabili:
Variabile Tipo Significato Stato alla
creazione
Timeout REAL Timeout di attesa con le istruzioni Wait e WaitN.
-1 = nessun timeout (attesa infinita)
0 = controllo immediato
>0 = timeout in millisecondi
-1
RisingEdge BOOL Stato del fronte ascendente FALSE
Output DOUTPORT Rimando all'uscita hardware ---
Tabella 18.3 Variabili del modulo di uscita digitale
Timeout
Con il parametro Timeout si può definire un tempo di attesa. Il metodo del modulo attende lo stato del segnale richiesto per il tempo impostato.
Impostando il valore -1 si verifica un'attesa infinita.
Indicando un valore > 0 il programma attende al massimo per il tempo impostato. Se al termine del tempo di attesa non si è verificato lo stato di segnale desiderato, l'esecuzione del programma viene proseguita. Un messaggio d'errore deve essere generato dal programma sequenziale stesso.
Indicando il valore 0 viene eseguito un controllo immediato. Se il segnale non ha il valore desiderato, il programma sequenziale deve generare un messaggio di errore.
Ulteriori informazioni e un esempio di creazione del messaggio di errore sono riportati nel capitolo 20.2 Utilizzo dei moduli di ingresso e di uscita.
RisingEdge
Sebbene non venga richiamato, il modulo memorizza lo stato di un fronte ascendente. Questo stato può essere analizzato nel programma.
Output
La variabile Output descrive il rimando all'uscita hardware del modulo.
18. Moduli
166 Festo GDCP-CMXR-SW-IT it 0909a
18.5.3 Metodi
Il modulo dispone di più metodi:
Metodo Descrizione
Wait Attesa finché l'uscita non assume il valore TRUE
WaitN Attesa finché l'uscita non assume il valore FALSE
Read Lettura del valore di uscita
RisingEdge Lettura dello stato del fronte ascendente
ResetRisingEdge Reset dello stato del fronte ascendente
Set Attivazione dell'uscita, stato TRUE
Reset Reset dell'uscita, stato FALSE
Write Impostazione dell'uscita sul valore indicato
Tabella 18.4 Metodi del modulo di uscita digitale DOUT
Mediante l'unità di comando manuale si possono selezionare questi metodi dalla struttura a menu nella cartella “Digital Outputs”.
Nell'editor FTL, dopo l'immissione del punto i metodi disponibili vengono automatica-mente visualizzati in una lista da dove possono essere selezionati.
La figura mostra le selezione dei metodi del modulo DOUT sull'unità di comando manuale.
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 167
18.5.4 Attesa dello stato, metodo Wait / WaitN
Con i metodi Wait e WaitN si può fare attendere al programma FTL fino a quando l'uscita
assume il valore TRUE o FALSE. L'attesa tiene in considerazione il timeout eventualmente impostato.
Sintassi
<nome istanza>.Wait (OPT ovlEnable : BOOL)
<nome istanza>.WaitN (OPT ovlEnable : BOOL)
Per la descrizione del parametro ovlEnable vedi capitolo 18.3.1 a pagina 158.
Esempio:
Ptp(pos0)
cylinder.Wait() // attesa del segnale TRUE all'uscita,
movimento arrestato
Ptp(pos1)
cyinder.WaitN(TRUE) // attesa del segnale FALSE all'uscita,
nessun arresto
Ptp(pos2)
18.5.5 Lettura dello stato, metodo Read
Con il metodo Read si può leggere lo stato corrente dell'uscita. Come valore di ritorno
viene restituito lo stato TRUE o FALSE.
Sintassi
<nome istanza>.Read (OPT ovlEnable: BOOL) : BOOL
Per la descrizione del parametro ovlEnable vedi capitolo 18.3.1 a pagina 158.
Esempio:
value := cylinder.Read()
18.5.6 Fronte ascendente, metodo RisingEdge
Con il metodo RisingEdge si può controllare se sull'uscita si è verificato un fronte ascen-
dente e se questo è stato memorizzato. Il valore di ritorno può essere TRUE anche se l'uscita nel frattempo ha assunto lo stato FALSE. Lo stato del fronte viene rilevato indipendentemente dal ciclo del programma FTL e si svolge in un ciclo proprio.
Sintassi
<nome istanza>.RisingEdge (OPT ovlEnable: BOOL) : BOOL
18. Moduli
168 Festo GDCP-CMXR-SW-IT it 0909a
Per la descrizione del parametro ovlEnable vedi capitolo 18.3.1 a pagina 158.
Esempio:
value := cylinder.RisingEdge()
18.5.7 Reset del fronte, ResetRisingEdge
Questo metodo resetta il flag interno del fronte ascendente. Ciò si rende necessario quando si vuole controllare un fronte ascendente con il metodo RisingEdge.
Sintassi
<nome istanza>.ResetRisingEdge()
Nota
Se il valore dell'uscita digitale è impostato nel momento in cui viene eseguita questa istruzione, lo stato di rilevamento del fronte viene resettato e non più reimpostato. Esso viene reimpostato solamente dopo che sull'uscita si è verificato un fronte positivo (variazione di stato dell'uscita da 0 a 1).
Esempio:
cylinder.ResetRisingEdge()
value := cylinder.RisingEgde()
18.5.8 Attivazione e reset, metodo Set / Reset
Con il metodo Set viene attivata un'uscita (stato TRUE), con il metodo Reset viene
resettata un'uscita (stato FALSE).
Sintassi
<nome istanza>.Set ( )
<nome istanza>.Reset ( )
Set e Reset vengono eseguiti durante l'elaborazione principale del programma. La fun-zione di approssimazione NON viene influenzata dal modulo.
Esempio:
Lin(pos1)
Lin(pos2)
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 169
cylinder.Set() // impostazione dell'uscita cylinder su
TRUE
Lin(pos3)
cylinder.Reset() // impostazione dell'uscita cylinder su
FALSE
Lin(pos4)
18.5.9 Attivazione dell'uscita, metodo Write
Con il metodo Write si può descrivere lo stato di un'uscita. Lo stato desiderato (TRUE o FALSE) viene passato come parametro. Il funzionamento di Write è identico a quello dei metodi Set e Reset.
Sintassi
<nome istanza>.Write (Value: BOOL)
Il metodo Write viene eseguito durante l'elaborazione principale del programma.
La funzione di approssimazione NON viene influenzata dal modulo.
Esempio:
cylinder.Write(TRUE) // impostazione dell'uscita cylinder
su TRUE
state := FALSE
cylinder.Write(state) // impostazione dell'uscita cylinder
su FALSE
18.5.10 Impostazione dell'uscita per un determinato periodo, metodo Pulse
Il metodo Pulse imposta un'uscita su TRUE per un determinato periodo di tempo. L'esecuzione di Pulse avviene durante l'elaborazione principale del programma e non
influenza l'approssimazione.
Sintassi
<nome istanza>.Pulse (timeMs :DINT;
OPT pauseAtInterrupt: BOOL)
Parametro Tipo Significato
timeMs DINT Tempo per la durata dell'impulso in msec
pauseAtInterrupt BOOL Arresto del tempo dell'impulso quando il
programma è arrestato
Tabella 18.5 Parametri del metodo Pulse
18. Moduli
170 Festo GDCP-CMXR-SW-IT it 0909a
Il metodo Pulse aziona un'uscita digitale con un impulso di durata determinata. La durata
dell'impulso viene indicata in millisecondi. L'uscita viene sempre impostata su TRUE all'inizio dell'impulso e sempre su FALSE alla fine dell'impulso. Se però l'uscita ha già lo stato TRUE, al termine del tempo dell'impulso viene resettata.
Con il parametro opzionale “pauseAtInterrupt” si può indicare quale dovrà essere la reazione nel caso di un arresto del programma FTL. Se questo parametro non viene specificato, il sistema imposta internamente lo stato FALSE.
pauseAtInterruppt = TRUE:
Con TRUE viene arrestato il tempo dell'impulso e l'uscita viene impostata sul valore FALSE. Quando il programma FTL viene proseguito, l'uscita viene reimpostata su TRUE per il restante periodo di tempo. Una volta trascorso il tempo dell'impulso viene ripristinato lo stato FALSE.
pauseAtInterruppt = FALSE:
Se il parametro opzionale non è specificato o è impostato su FALSE, l'impulso viene eseguito dall'inizio alla fine. Un arresto del programma FTL non ha alcun effetto.
Nota
Se un programma FTL arrestato viene scaricato, la funzione dell'impulso viene automaticamente terminata e l'uscita impostata su FALSE.
Esempio:
// impostazione dell'uscita cylinder per 200 msec su TRUE
cylinder.Pulse(200)
18.6 Modulo di ingresso analogico AIN
Il modulo AIN serve per l'interrogazione e la gestione di un ingresso analogico.
18.6.1 Istanziazione
Per l'istanziazione del modulo di ingresso analogico è necessario il riferimento hardware con l'ingresso analogico. Questo viene indicato tramite il parametro Input in fase di istanziazione.
Sintassi
<nome istanza> .AIN( <Timeout> : DINT, MAPX(“< input>”))
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 171
Il parametro “input” è il nome con il quale viene definito l'ingresso hardware. Questa
assegnazione crea un riferimento tra il modulo e l'hardware. È possibile specificare ulteriori parametri, ad es. per eseguire delle preimpostazioni. Ciò non è tuttavia necessario ai fini dell'istanziazione e può avvenire anche nel programma.
Esempio:
Un sensore viene impostato come istanza di un modulo:
Istanziazione nel file di dati:
temperature : AIN := (-1, MAPX(“_system.Sensor1”))
Istanziazione con l'editor FTL
L'istanziazione avviene nella finestra di dialogo per la creazione di variabili, selezionando il tipo (<Type:>) AIN e impostando l'identificatore (<Identifier:>) ainTemperature. Nella riga <MAPTO AINPORT> viene creato il riferimento reale con un ingresso analogico configurato.
Istanziazione con l'unità di comando manuale
L'istanziazione del modulo di ingresso analogico mediante l'unità di comando manuale avviene nella maschera delle variabili selezionando il tipo di dati AIN.
Con l'istanziazione sull'unità di comando manuale, la registrazione viene automatica-mente memorizzata nel file di dati.
18. Moduli
172 Festo GDCP-CMXR-SW-IT it 0909a
18.6.2 Variabili Il modulo di ingresso analogico possiede le seguenti variabili:
Variabile Tipo Significato Stato alla creazione
Timeout REAL Timeout di attesa con le istruzioni WaitLss, WaitGrt,
WaitIns e Waitouts.
-1 = nessun timeout (attesa infinita)
0 = controllo immediato
>0 = timeout in millisecondi
-1
Input AINPORT Rimando all'ingresso hardware ---
Tabella 18.6 Variabili del modulo di ingresso analogico
Timeout
Con il parametro Timeout si può definire un tempo di attesa. Il metodo del modulo attende lo stato del segnale richiesto per il tempo impostato.
Impostando il valore -1 si verifica un'attesa infinita.
Indicando un valore > 0 il programma attende al massimo per il tempo impostato. Se al termine del tempo di attesa non si è verificato lo stato di segnale desiderato, l'esecuzione del programma viene proseguita. Un messaggio d'errore deve essere generato dal programma sequenziale stesso.
Indicando il valore 0 viene eseguito un controllo immediato. Se il segnale non ha il valore desiderato, il programma sequenziale deve generare un messaggio di errore.
Ulteriori informazioni e un esempio di creazione del messaggio di errore sono riportati nel capitolo 20.2 Utilizzo dei moduli di ingresso e di uscita.
Input
La variabile Input descrive il rimando all'ingresso hardware del modulo.
18.6.3 Metodi Il modulo dispone di più metodi:
Metodo Descrizione
WaitLss Attesa finché il valore di ingresso non è inferiore a quello
indicato
WaitGrt Attesa finché il valore di ingresso non è maggiore di quello
indicato
WaitIns Attesa finché il valore di ingresso non si trova entro il limite
indicato
WaitOuts Attesa finché il valore di ingresso non si trova oltre il limite
indicato
Read Lettura del valore di ingresso
Tabella 18.7 Metodi del modulo di ingresso analogico
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 173
Nell'editor FTL, dopo l'immissione del punto i metodi disponibili vengono automatica-
mente visualizzati in una lista da dove possono essere selezionati.
Mediante l'unità di comando manuale si possono selezionare questi metodi dalla struttura a menu nella cartella “Analog Inputs”.
La figura mostra le selezione dei metodi del modulo AIN sull'unità di comando manuale.
18.6.4 Attesa finché il valore non è inferiore/superiore, metodo WaitLss, WaitGrt
I metodi WaitLss e WaitGrt consentono di interrogare un ingresso analogico per sapere se
il suo stato è superiore o inferiore al valore specificato. Il parametro Timeout del modulo viene considerato.
Sintassi
<nome istanza>.WaitLss(value : REAL, OPT ovlEnable : BOOL)
<nome istanza>.WaitGrt(value : REAL, OPT ovlEnable : BOOL)
Per la descrizione del parametro ovlEnable vedi capitolo 18.3.1 a pagina 158.
Parametro Tipo Significato
value REAL Valore limite
Tabella 18.8 Parametri dei metodi WaitLss, WaitGrt
Esempio:
Lin(pos1)
temperature.WaitLss(65.0, TRUE)
Lin(pos2)
18. Moduli
174 Festo GDCP-CMXR-SW-IT it 0909a
18.6.5 Attesa finché il valore non è dentro/fuori dall'intervallo, metodo WaitIns, WaitOuts
Con i metodi WaitIns e WaitOuts si può aspettare finché il valore dell'ingresso analogico
non si trova all'interno o all'esterno dell'intervallo di valori specificato. Il parametro Timeout del modulo viene considerato.
Sintassi
<nome istanza>.WaitIns( minValue : REAL,
maxValue : REAL,
OPT ovlEnable : BOOL)
<nome istanza>.WaitOuts( minValue : REAL,
maxValue : REAL,
OPT ovlEnable : BOOL)
Per la descrizione del parametro ovlEnable vedi capitolo 18.3.1 a pagina 158.
Parametro Tipo Significato
minValue REAL Valore limite inferiore
maxValue REAL Valore limite superiore
Tabella 18.9 Parametri dei metodi WaitIns, WaitOuts
Esempio
Lin(pos1)
// attesa finché la temperatura non si trova entro i limiti
temperature.WaitIns(50.0, 55.0, TRUE)
Lin(pos2)
18.6.6 Lettura del valore, metodo Read
Il metodo Read legge il valore corrente dell'ingresso analogico.
Sintassi
<nome istanza>.Read(OPT ovlEnable)
Per la descrizione del parametro ovlEnable vedi capitolo 18.3.1 a pagina 158.
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 175
Esempio
Lin(pos1)
// lettura della temperatura senza arresto sulla traiettoria
value := temperature.Read(TRUE)
Lin(pos2)
18.7 Modulo di uscita analogico AOUT
Il modulo AOUT serve per l'interrogazione e la gestione di un'uscita analogica.
18.7.1 Istanziazione
Per l'istanziazione del modulo di uscita analogico è necessario il riferimento hardware con l'uscita analogica. Questo viene indicato tramite il parametro <port> in fase di istanzia-zione.
Sintassi
<nome istanza> .AOUT( <Timeout> : DINT, MAPX(“< port>”))
È possibile specificare ulteriori parametri, ad es. per eseguire delle preimpostazioni. Ciò non è tuttavia necessario ai fini dell'istanziazione e può avvenire anche nel programma.
Esempio:
Una quantità prestabilita viene impostata come istanza di un modulo:
Istanziazione nel file di dati:
quantity : AOUT := (-1, MAPX(“_system.SetValue”))
Istanziazione con l'editor FTL
L'istanziazione avviene nella finestra di dialogo per la creazione di variabili, selezionando il tipo (<Type:>) AOUT e impostando l'identificatore (<Identifier:>) aoutQuantity. Nella riga <MAPTO AOUTPORT> viene creato il riferimento reale con un'uscita analogica configurata.
18. Moduli
176 Festo GDCP-CMXR-SW-IT it 0909a
Istanziazione con l'unità di comando manuale
L'istanziazione del modulo di uscita analogico mediante l'unità di comando manuale avviene nella maschera delle variabili selezionando il tipo di dati AOUT.
Con l'istanziazione sull'unità di comando manuale, la registrazione viene automatica-mente memorizzata nel file di dati.
18.7.2 Variabili
Il modulo di uscita analogico possiede le seguenti variabili:
Variabile Tipo Significato Stato alla
creazione
Timeout REAL Timeout di attesa con le istruzioni WaitLss, WaitGrt,
WaitIns e Waitouts.
-1 = nessun timeout (attesa infinita)
0 = controllo immediato
>0 = timeout in millisecondi
-1
Output AOUTPORT Rimando all'uscita hardware ---
Tabella 18.10 Variabili del modulo di uscita analogico
Timeout
Con il parametro Timeout si può definire un tempo di attesa. Il metodo del modulo attende lo stato del segnale richiesto per il tempo impostato.
Impostando il valore -1 si verifica un'attesa infinita.
Indicando un valore > 0 il programma attende al massimo per il tempo impostato. Se al termine del tempo di attesa non si è verificato lo stato di segnale desiderato, l'esecuzione del programma viene proseguita. Un messaggio d'errore deve essere generato dal programma sequenziale stesso.
Indicando il valore 0 viene eseguito un controllo immediato. Se il segnale non ha il valore desiderato, il programma sequenziale deve generare un messaggio di errore.
Ulteriori informazioni e un esempio di creazione del messaggio di errore sono riportati nel capitolo 20.2 Utilizzo dei moduli di ingresso e di uscita.
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 177
Output
La variabile Output descrive il rimando all'uscita hardware del modulo.
18.7.3 Metodi
Il modulo dispone di più metodi:
Metodo Descrizione
Write Scrive un valore sull'uscita analogica
WaitLss Attesa finché il valore di uscita non è inferiore a quello indicato
WaitGrt Attesa finché il valore di uscita non è maggiore di quello indicato
WaitIns Attesa finché il valore di uscita non si trova entro il limite
indicato
WaitOuts Attesa finché il valore di uscita non si trova oltre il limite indicato
Read Lettura del valore di uscita
Tabella 18.11 Metodi del modulo di uscita analogico
Nell'editor FTL, dopo l'immissione del punto i metodi disponibili vengono automatica-mente visualizzati in una lista da dove possono essere selezionati.
Mediante l'unità di comando manuale si possono selezionare questi metodi dalla struttura a menu nella cartella “Analog Outputs”.
La figura mostra le selezione dei metodi del modulo AOUT sull'unità di comando manuale.
18. Moduli
178 Festo GDCP-CMXR-SW-IT it 0909a
18.7.4 Scrittura del valore di uscita, metodo Write
Con il metodo Write viene scritta un'uscita analogica. Il valore nominale desiderato viene
passato al parametro “value”.
Sintassi
<nome istanza>.Write(value :REAL)
Parametro Tipo Significato
value REAL Valore nominale per l'uscita analogica
Tabella 18.12 Parametri del metodo Write
Esempio:
quantity.Write(110.0) // imposta l'uscita su 110.0
value := 1.3
quantity.Write(value) // imposta l'uscita su 1.3
18.7.5 Attesa finché il valore non è superiore/inferiore, metodo WaitLss, WaitGrt
I metodi WaitLss e WaitGrt consentono di interrogare un'uscita analogica per sapere se il
suo stato è superiore o inferiore al valore specificato. Il parametro Timeout del modulo viene considerato.
Sintassi
<nome istanza>.WaitLss(value : REAL, OPT ovlEnable : BOOL)
<nome istanza>.WaitGrt(value : REAL, OPT ovlEnable : BOOL)
Per la descrizione del parametro ovlEnable vedi capitolo 18.3.1 a pagina 158.
Parametro Tipo Significato
value REAL Valore limite
Tabella 18.13 Parametri dei metodi WaitLss, WaitGrt
Esempio:
Lin(pos1)
// attesa finché non è inferiore a 110.0
quantity.WaitLss(110.0, TRUE)
Lin(pos2)
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 179
18.7.6 Attesa finché il valore non è dentro/fuori dall'intervallo, metodo WaitIns, WaitOuts
Con i metodi WaitIns e WaitOuts si può aspettare finché il valore dell'uscita analogica non
si trova all'interno o all'esterno dell'intervallo di valori specificato. Il parametro Timeout del modulo viene considerato.
Sintassi
<nome istanza>.WaitIns(minValue : REAL,
maxValue : REAL, OPT ovlEnable : BOOL)
<nome istanza>.WaitOuts(minValue : REAL,
maxValue : REAL, OPT ovlEnable : BOOL)
Per la descrizione del parametro ovlEnable vedi capitolo 18.3.1 a pagina 158.
Parametro Tipo Significato
minValue REAL Valore limite inferiore
maxValue REAL Valore limite superiore
Tabella 18.14 Parametri dei metodi WaitIns, WaitOuts
Esempio
Lin(pos1)
// attesa finché la qualità non rientra nei limiti
quantity.WaitIns(100.0, 110.0, TRUE)
Lin(pos2)
18.7.7 Lettura del valore di uscita, metodo Read
Il metodo Read legge il valore corrente dell'uscita analogica.
Sintassi
<nome istanza>.Read(OPT ovlEnable)
Per la descrizione del parametro ovlEnable vedi capitolo 18.3.1 a pagina 158.
Esempio
Lin(pos1)
// lettura della quantità senza arresto sulla traiettoria
value := quantity.Read(TRUE)
Lin(pos2)
18. Moduli
180 Festo GDCP-CMXR-SW-IT it 0909a
18.8 Modulo orologio CLOCK
Il modulo orologio (Timer) può essere utilizzato per un semplice misurazione del tempo durante l'esecuzione del programma. I tempi vengono misurati in millisecondi.
18.8.1 Istanziazione
Per l'istanziazione del modulo orologio CLOCK è necessario il nome del modulo. Il modulo
non possiede variabili.
Istanziazione
<nome istanza> : CLOCK
Istanziazione nel file di dati:
Timer : CLOCK
Istanziazione con l'editor FTL
L'istanziazione avviene nella finestra di dialogo per la creazione di variabili, selezionando il tipo (<Type:>) CLOCK e impostando l'identificatore (<Identifier:>) clkTimer.
Istanziazione con l'unità di comando manuale
L'istanziazione del modulo orologio mediante l'unità di comando manuale avviene nella maschera delle variabili selezionando il tipo di dati CLOCK.
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 181
Con l'istanziazione sull'unità di comando manuale, la registrazione viene automatica-mente scritta nel file di dati.
18.8.2 Metodi
Il modulo orologio dispone dei seguenti metodi:
Metodo Descrizione
Reset Reset dell'orologio
Start Avvio dell'orologio
Stop Arresto dell'orologio
Read Lettura del tempo arrestato in msec
ToStr Conversione del tempo in una stringa
Tabella 18.15 Metodi del modulo orologio
Nell'editor FTL, dopo l'immissione del punto i metodi disponibili vengono automatica-mente visualizzati in una lista da dove possono essere selezionati.
Mediante l'unità di comando manuale si possono selezionare questi metodi dalla struttura a menu nella cartella “Timing Blocks”.
La figura mostra le selezione dei metodi del modulo CLOCK sull'unità di comando
manuale.
18. Moduli
182 Festo GDCP-CMXR-SW-IT it 0909a
18.8.3 Avvio dell'orologio, metodo Start
Con il metodo Start viene avviato il timer. Il momento di avvio viene memorizzato inter-
namente nel modulo. Se l'avvio viene impartito su un timer già arrestato, il timer arrestato viene riattivato e il tempo continua a scorrere. Il timer può essere riavviato solo con l'istruzione Reset.
Sintassi
<nome istanza>.Start ( )
Esempio:
Timer.Start() // l'orologio viene avviato
18.8.4 Arresto dell'orologio, metodo Stop
Il metodo Stop arresta una misurazione del tempo già avviata. Il tempo trascorso viene
calcolato internamente nel modulo e messo a disposizione per la lettura.
Sintassi
<nome istanza>.Stop ( )
Esempio:
Timer.Stop() // l'orologio viene arrestato
18.8.5 Reset dell'orologio, metodo Reset
Il richiamo del metodo Reset azzera il timer. Se viene eseguito un reset su un timer in
funzionamento, questo viene azzerato e poi continua a funzionare.
Sintassi
<nome istanza>.Reset ( )
Esempio:
Timer.Reset() // l'orologio viene resettato
18.8.6 Lettura dell'orologio, metodo Read
Con il metodo Read si può leggere il valore di tempo attuale in millisecondi (msec).
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 183
Sintassi
<nome istanza>.Read(OPT ovlEnable : BOOL) : DINT
Per la descrizione del parametro ovlEnable vedi capitolo 18.3.1 a pagina 158.
Valore di ritorno: tempo misurato in millisecondi (msec)
Esempio:
Dati:
value : DINT
Programma:
:
Lin(pos1)
value := Timer.Read() // lettura con arresto sulla
traiettoria
Lin(pos2)
value := Timer.Read(TRUE) // lettura nell'elaborazione
principale dei record
Lin(pos3)
:
18.8.7 Conversione del valore di tempo in una stringa
Con il metodo ToStr si può convertire il valore di tempo attuale in una stringa con la
struttura <Giorni> <Ore>:<Minuti>:<Secondi>:<Millisecondi>.
Sintassi
<nome istanza>.ToStr(OPT ovlEnable : BOOL) : STRING
Per la descrizione del parametro ovlEnable vedi capitolo 18.3.1 a pagina 158.
Valore di ritorno: stringa con l'informazione di tempo formattata gg hh:mm:ss:ms.
Esempio:
Dati:
time : STRING
Programma:
Lin(pos1)
18. Moduli
184 Festo GDCP-CMXR-SW-IT it 0909a
time := Timer.ToStr() // lettura con arresto sulla
traiettoria
Lin(pos2)
time := Timer.ToStr(TRUE) // lettura nell'elaborazione
principale dei record
Lin(pos3)
18.9 Modulo encoder ENCODER
Il modulo encoder può essere utilizzato nel programma per leggere gli encoder incremen-tali collegati, che possono essere al massimo due.
18.9.1 Istanziazione
Per l'istanziazione del modulo encoder è necessario il riferimento hardware con l'ingresso. Questo viene indicato tramite il parametro <port> in fase di istanziazione.
Sintassi
<nome istanza> .ENCODER( <Timeout> : DINT, MAPX(“<port>”))
È possibile specificare ulteriori parametri, ad es. per eseguire delle preimpostazioni. Ciò non è tuttavia necessario ai fini dell'istanziazione e può avvenire anche nel programma.
Esempio:
Un encoder viene impostato come istanza di un modulo:
Istanziazione nel file di dati:
enc0 : ENCODER := (-1, MAPX(“_system.Encoder_0”))
Istanziazione con l'editor FTL
L'istanziazione avviene nella finestra di dialogo per la creazione di variabili, selezionando il tipo (<Type:>) ENCODER e impostando l'identificatore (<Identifier:>) encTrack. Nella riga <MAPTO ENCPORT> viene creato il riferimento reale con un ingresso encoder configurato.
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 185
Istanziazione con l'unità di comando manuale
L'istanziazione del modulo encoder mediante l'unità di comando manuale avviene nella maschera delle variabili selezionando il tipo di dati ENCODER.
Con l'istanziazione sull'unità di comando manuale, la registrazione viene automatica-mente memorizzata nel file di dati.
18.9.2 Variabili
Il modulo encoder possiede le seguenti variabili:
Variabile Tipo Significato Stato alla
creazione
timeout REAL Timeout di attesa -1
port ENCPORT Rimando all'ingresso hardware ---
Tabella 18.16 Variabili del modulo encoder
Timeout – (attualmente privo di funzione in questo modulo)
Con il parametro Timeout si può definire un tempo di attesa. Il metodo del modulo attende lo stato del segnale richiesto per il tempo impostato. Attualmente il modulo encoder non dispone di metodi in grado di considerare il timeout.
Port
La variabile Port descrive il rimando all'ingresso hardware.
18.9.3 Metodi
Il modulo encoder dispone dei seguenti metodi:
Metodo Descrizione
Set Impostazione manuale del valore dell'encoder incrementale
Read Lettura del valore dell'encoder incrementale
Tabella 18.17 Metodi del modulo encoder
18. Moduli
186 Festo GDCP-CMXR-SW-IT it 0909a
Nell'editor FTL, dopo l'immissione del punto i metodi disponibili vengono automatica-
mente visualizzati in una lista da dove possono essere selezionati.
Mediante l'unità di comando manuale si possono selezionare questi metodi dalla struttura a menu nella cartella “Incremental Encoder”.
La figura mostra le selezione dei metodi del modulo encoder sull'unità di comando manuale.
18.9.4 Impostazione dell'encoder, metodo Set
Con il metodo Set si può attivare un valore dell'encoder incrementale dal programma
utente.
Sintassi:
<ENCODER>.Set ( OPT <count> : DINT, OPT <mode> : SETCOUNTMODE)
Parametro Tipo Significato
count DINT Valore sul quale deve essere impostato l'encoder incrementale
(incrementi)
mode SETCOUNTMODE Parametro per l'impostazione del momento di acquisizione
Tabella 18.18 Parametri del metodo Set
Il modulo imposta il valore in sincrono con l'elaborazione principale del programma, ma non arresta il calcolo preliminare. Nel parametro mode si può definire il momento in cui verrà impostato il valore.
mode Significato
DIRECT Il valore viene acquisito nel ciclo successivo
del sistema I/O
ZEROPULSE Il valore viene acquisito all'impulso zero
successivo dell'encoder
Tabella 18.19 Modalità del metodo Set
Esempio:
enc0.Set(1000, DIRECT)
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 187
18.9.5 Lettura dell'encoder, metodo Read
Con il metodo Read si può leggere il valore corrente dell'encoder incrementale dal
programma utente.
Sintassi:
<ENCODER>.Read ( OPT <ovlEnable> : BOOL) : DINT
Parametro Tipo Significato
ovlEnable BOOL Parametro per l'impostazione del momento di lettura
Tabella 18.20 Parametri del metodo Read
Il metodo restituisce il valore incrementale dell'encoder. Questo valore non viene calcolato con il fattore di conversione. Per leggere il valore normale bisogna accedere direttamente alla porta dell'ingresso encoder con l'elemento Value.
Esempio di lettura del valore normale:
value := enc0.port.value
Esempio di lettura del valore incrementale:
value := enc0.Read()
18.10 Modulo CANopen COPDEVICE
Il modulo CANopen può essere utilizzato nel programma per accedere ad unità che sono collegate al CMXR tramite il bus CAN delle periferiche.
Attenzione
Con il bus CAN delle periferiche si possono azionare unità CANopen. Questa unità non sono però assoggettate al comportamento di STOP EMERGENZA della cinematica. Non si verifica nessuna frenatura controllata degli attuatori ausiliari. Se il bus CAN delle periferiche viene azionato da un programma parallelo, nel caso di uno STOP EMERGENZA esso non verrà arrestato!
Nota
Le modalità di attivazione delle singole unità collegate al CMXR tramite il bus CAN sono descritte nella rispettiva documentazione del costruttore del modulo.
18. Moduli
188 Festo GDCP-CMXR-SW-IT it 0909a
18.10.1 Istanziazione
L'istanziazione del modulo CANopen avviene in modo automatico, in ragione della configu-razione I/O dell'unità di comando, e non può essere eseguita manualmente.
L'accesso alle unità CANopen collegate avviene tramite un nome univoco, preimpostato con il software di configurazione FCT. Il nome specificato in FCT non può essere utilizzato direttamente e perciò gli viene assegnata l'estensione “_copd”. Ciò vale sia per gli attuatori collegati al DriveBus che per le unità CANopen collegate al bus CAN delle periferiche.
Esempio:
L'asse 1 della cinematica viene denominato Axis1 nella configurazione DriveBus in FCT.
L'accesso avviene tramite Axis1_copd.MetodoModulo( ).
Configurazione CANopen:
[IO.ONBOARD.SLOTCAN:0.FX200A:0.CAN:0.COPDEVICE:1]
name=“Axis1” // nome dell'unità COP
Codice del programma:
Axis1_copd.WriteSDO(16#6060,0,7,eight_bits)
18.10.2 Metodi
Il modulo CANopen dispone dei seguenti metodi:
Metodo Descrizione
WriteSDO Scrittura di SDO
ReadSDOUnsigned Lettura di SDO senza segno matematico
ReadSDOSigned Lettura di SDO con segno matematico
Tabella 18.21 Metodi del modulo CANopen
Nell'editor FTL, dopo l'immissione del punto i metodi disponibili vengono automatica-
mente visualizzati in una lista da dove possono essere selezionati.
Mediante l'unità di comando manuale si possono selezionare questi metodi dalla struttura a menu nella cartella “CANopen Devices”.
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 189
La figura mostra le selezione dei metodi del modulo CANopen sull'unità di comando manuale.
18.10.3 Scrittura di SDO, metodo WriteSDO
Con il metodo WriteSDO è possibile scrivere pacchetti di dati sul bus CAN.
Sintassi:
<COPDEVICE>.WriteSDO ( <index> : DINT, <subindex> : DINT, <data> : DINT, <type> : SdoDataType ) : BOOL
Parametro Tipo Significato
index DINT Indice dell'SDO
subindex DINT Sottoindice dell'SDO
data DINT Dati da scrivere
type SdoDataType Tipo di dati (Enum)
eight_bits (8 bit)
sixteen_bits (16 bit)
thirtytwo_bit (32 bit)
Tabella 18.22 Parametri del metodo WriteSDO
Se la scrittura del pacchetto ha esito positivo viene restituito TRUE, altrimenti FALSE.
Esempio:
oData := 12000
Axis3_copd.WriteSDO(16#6085, 0, oData, thirtytwo_bits)
18.10.4 Lettura di SDO, metodo ReadSDOSigned
Con il metodo ReadSDOSigned è possibile leggere pacchetti di dati con segno matematico
dal bus CAN.
18. Moduli
190 Festo GDCP-CMXR-SW-IT it 0909a
Sintassi:
<COPDEVICE>.ReadSDOSigned (<index> : DINT, <subindex> : DINT, <data> : DINT) : BOOL
Parametro Tipo Significato
index DINT Indice dell'SDO
subindex DINT Sottoindice dell'SDO
data DINT Dati da leggere
Tabella 18.23 Parametri del metodo ReadSDOSigned
Se la lettura del pacchetto ha esito positivo viene restituito TRUE, altrimenti FALSE.
Esempio:
dint_iData : DINT := 0
Programma:
Axis3_copd.ReadSDOSigned(16#6098, 0, dint_iData)
SetInfo(“metodo della corsa di riferimento letto: %1”,
dint_iData)
:
18. Moduli
Festo GDCP-CMXR-SW-IT it 0909a 191
18.10.5 Lettura di SDO, metodo ReadSDOUnsigned
Con il metodo ReadSDOUnsigned è possibile leggere pacchetti di dati dal bus CAN.
Il metodo riconosce automaticamente la lunghezza dei dati letti dal bus CAN. Questi vengono restituiti come valore a 32 bit senza segno matematico.
Sintassi:
<COPDEVICE>.ReadSDOUnigned (<index> : DINT, <subindex> : DINT, <data> : DWORD) : BOOL
Parametro Tipo Significato
index DINT Indice dell'SDO
subindex DINT Sottoindice dell'SDO
data DWORD Dati da leggere
Tabella 18.24 Parametri del metodo ReadSDOUnsigned
Se la lettura del pacchetto ha esito positivo viene restituito TRUE, altrimenti FALSE.
19. Segnali delle periferiche
192 Festo GDCP-CMXR-SW-IT it 0909a
19. Segnali delle periferiche
19.1 Utilizzo di ingressi e uscite digitali
I segnali digitali vengono definiti mediante la configurazione, dove ad ogni segnale hardware viene assegnato un proprio nome. Questi nomi possono essere utilizzati nel programma di movimenti per interrogazioni o per comandi.
Ogni segnale digitale è rappresentato sotto forma di un tipo di dati strutturato. Esso contiene i dati seguenti:
State : BOOL Stato del segnale TRUE o FALSE
Error : BOOL Informazioni su un errore del segnale
L'accesso a questi dati avviene tramite il nome hardware e l'operatore punto.
Esempio:
Un segnale d'ingresso del sensore è denominato “GripperOpen”. L'accesso allo stato del sensore sarà:
GripperOpen.State
Questa espressione è del tipo di dati BOOL e può essere utilizzata come una variabile booleana nel programma.
19.2 Utilizzo di ingressi e uscite analogici
I segnali analogici vengono definiti mediante la configurazione, dove ad ogni segnale hardware viene assegnato un proprio nome. Il nome può essere utilizzato come una variabile nel programma di movimenti e, in questo modo, si può ad es. utilizzare un valore analogico per un calcolo.
Ogni segnale analogico è rappresentato sotto forma di un tipo di dati strutturato. Esso contiene i dati seguenti:
Value : REAL Valore del segnale
Error : BOOL Informazioni su un errore del segnale
L'accesso a questi dati avviene tramite il nome hardware e l'operatore punto.
19. Segnali delle periferiche
Festo GDCP-CMXR-SW-IT it 0909a 193
Esempio:
Un segnale d'ingresso analogico è denominato “Level”. L'accesso allo stato del sensore sarà:
Level.Value
Questa espressione è del tipo di dati REAL e può essere utilizzata come una variabile nel programma.
20. Esempi
194 Festo GDCP-CMXR-SW-IT it 0909a
20. Esempi Nei capitoli seguenti sono riportati esempi di utilizzo del linguaggio programmazione.
Avvertenza
Tutti gli esempi servono per descrivere l'utilizzo del linguaggio di programmazione, senza alcuna pretesa di correttezza, completezza e di presentazione degli esempi come applicazione in grado di funzionare. Se in un'applicazione vengono incorporati sottopro-grammi descritti in questi esempi, è necessario verificare che siano adatti all'uso previsto e garantirne il corretto funzionamento con una messa in funzione corrispondente.
La non osservanza può comportare danni alle cose e alle persone
20.1 Arresto di movimenti
Un robot di manipolazione deve prelevare un pannello da una pila di lamiere e depositarlo
su un nastro trasportatore a rulli. L'altezza esatta della pila non è nota. Il sistema di pinze è tuttavia provvisto di un sensore che consente di rilevare se l'utensile di presa urta un ostacolo. Questo sensore viene utilizzato per sondare il pannello di lamiera superiore. Per rilevare se una pila di lamiere è stata completamente elaborata è presente un ulteriore sensore (di rilevamento pila vuota).
Nastro
trasportatore a rulli Pila di lamiere
Sistema di pinze con
rilevamento di collisioni
Ingresso: inCollision
Sensore di rilevamento pila vuota
Ingresso: inStackNotEmpty
x
z
y
20. Esempi
Festo GDCP-CMXR-SW-IT it 0909a 195
Il programma di movimenti comprende le seguenti posizioni:
Descrizione Nome della variabile di posizione
Posizione di prelievo sulla pila di lamiere takePosStack
Posizione di sicurezza sopra la pila di lamiere safetyPosStack
Posizione di sicurezza sopra il nastro trasportatore
a rulli
safetyDepositPos
Posizione di deposizione sul nastro trasportatore
a rulli
depositPos
Posizione preliminare modificabile sopra la pila di
lamiere
prePosition
Tabella 20.1 Panoramica delle posizioni
Per questa applicazione si possono utilizzare ulteriori posizioni. L'esempio si limita tuttavia alle posizioni indicate.
Poiché l'altezza della posizione di prelievo non è nota, a causa dell'altezza variabile della pila, essa viene impostata sotto la pila.
safetyPosStack
takePosStack
safetyDepositPos
depositPos
20. Esempi
196 Festo GDCP-CMXR-SW-IT it 0909a
Programma di movimenti:
:
Vel(dynCart, 200) // velocità lenta
prePosition := safetyPosStack
WHILE TRUE DO
Lin(safetyPosStack)
WAIT inStackNotEmpty.State // verifica se ci sono pezzi
sulla pila
Lin(prePosition)
Vel(dynCart, 200) // velocità lenta
Lin(takePosStack)
WAIT inCollision.State // attesa segnale del sensore
per collisione
StopMove() // arresto del movimento
// rilevamento della posizione effettiva sopra la pila
ReadActualPos(prePosition)
// calcolo della distanza di sicurezza sopra la pila
prePosition.z := prePosition.z + 10
gripper.Set() // chiusura pinza
Vel(dynCart, 1000) // velocità rapida
Lin(safetyPosStack)
Lin(safetyDepositPos)
Lin(depositPos)
gripper.Reset() // apertura pinza
Lin(safetyDepositPos)
END_WHILE
:
Funzionamento
La cinematica si sposta sulla posizione di prelievo finché la pinza non viene a trovarsi sopra il pannello di lamiera e il sensore di rilevamento collisioni fornisce il segnale corrispondente. Questa operazione viene eseguita a velocità lenta per proteggere il sistema da eventuali danneggiamenti.
Per poter raggiungere una posizione possibilmente vicina sopra la pila al prossimo ciclo, la posizione effettiva sopra la pila viene memorizzata. Questa posizione viene poi integrata con una distanza di sicurezza in modo che, al prossimo ciclo, il sistema possa spostarsi sulla pila a velocità rapida. Infine viene attivata una velocità lenta fino al contatto finale con il pezzo.
20. Esempi
Festo GDCP-CMXR-SW-IT it 0909a 197
20.2 Utilizzo dei moduli di ingresso e di uscita
Durante l'istanziazione dei moduli di ingresso o di uscita si può definire un timeout. Se ad esempio si utilizza la funzione Wait del modulo nella sequenza di lavorazione, un timeout eventualmente attivato deve essere analizzato dal programma utente.
Programma di movimenti:
:
inSensor.Wait()
IF inSensor.Read() = FALSE THEN
//interruzione della sequenza
SetError(“Timeout over”)
RETURN
END_IF
//proseguimento della sequenza
Lin(pos)
:
Nota
L'emissione di un messaggio di errore provoca un'interruzione del movimento. Per poter proseguire la sequenza è necessario reset-tare il messaggio di errore.
20. Esempi
198 Festo GDCP-CMXR-SW-IT it 0909a
20.3 Controllo del calcolo preliminare dei record
Di seguito vengono descritte diverse possibilità, sulla base di esempi, per influenzare il calcolo preliminare dei record.
1. Attesa del segnale di ingresso digitale
Nello svolgimento del programma, con l'istruzione WAIT viene impostata l'attesa di un segnale di ingresso digitale. Se lo stato dell'ingresso digitale è FALSE, il calcolo prelimi-nare dei record viene arrestato. Se lo stato è TRUE, il calcolo preliminare viene proseguito. Ciò è illustrato nella figura seguente.
2. Contatori di cicli
Un sottoprogramma viene ripetuto con un ciclo per 10 volte. I cicli vengono conteggiati mediante un contatore di cicli. Il calcolo preliminare dei record interpreta il programma sequenziale e incrementa il contatore di cicli in modo corrispondente. Il calcolo preliminare dei record raggiunge così molto velocemente la fine del programma e allo stesso modo il contatore di cicli raggiunge il valore 10. In questo lasso di tempo l'elaborazione principale dei record ha raggiunto solo l'istruzione Lin(Pos1).
Se si desidera che il contatore visualizzi il ciclo effettivo, è necessario interrompere il
calcolo preliminare dei record con un'istruzione WaitTime. Dopodiché il contatore di cicli verrà incrementato sempre al raggiungimento di Pos3. Ciò è illustrato nella figura seguente.
Lin(Pos1)
Lin(Pos2)
Lin(Pos3)
Lin(Pos4)
WAIT Sensor.State
Lin(Pos5)
Lin(Pos6)
Lin(Pos7)
Lin(Pos8)
Lin(Pos9)
Elaborazione principale dei record
Calcolo preliminare dei record
Lin(Pos1)
Lin(Pos2)
Lin(Pos3)
Lin(Pos4)
WAIT Sensor.State
Lin(Pos5)
Lin(Pos6)
Lin(Pos7)
Lin(Pos8)
Lin(Pos9)
Elaborazione principale dei record
Calcolo
preliminare dei record
20. Esempi
Festo GDCP-CMXR-SW-IT it 0909a 199
20.4 Utilizzo delle pinze
Nella tecnica di manipolazione vengono utilizzati svariati tipi di pinze. Ogni processo di presa richiede un certo tempo per chiudere o per aprire la pinza. Questo tempo può influire in maniera decisiva sul tempo di ciclo.
Nota
I tempi di presa provocano un aumento del tempo di ciclo e perciò vanno sempre considerati. A seconda del tipo di pinza viene generato un tempo di attesa anche nel programma FTL per garantire l'apertura o la chiusura della pinza.
Nota
I tempi di attesa per gli stati Chiuso o Aperto nelle pinze pneu-matiche dipendono sempre dalla pressione impostata. Al variare della pressione occorre modificare anche i tempi di attesa. Se sul sistema di pinze sono applicati sensori di finecorsa, in genere si può rinunciare ai tempi di attesa.
Nei capitoli seguenti viene rappresentata l'integrazione di vari tipi di pinze nel controller CMXR.
count := 0
Lin(Pos1)
Lin(Pos2)
LOOP 10 DO
Lin(Pos3)
count:=count + 1
Lin(Pos4)
END_LOOP
Lin(Pos5)
Elaborazione principale dei record
Calcolo preliminare dei record
count := 0
Lin(Pos1)
Lin(Pos2)
LOOP 10 DO
Lin(Pos3)
WaitTime (1)
count:=count + 1
Lin(Pos4)
END_LOOP
Lin(Pos5)
Elaborazione principale dei record
Calcolo preliminare dei record
20. Esempi
200 Festo GDCP-CMXR-SW-IT it 0909a
20.4.1 Ventose
Le ventose sono tipi di pinze che permettono di eseguire cicli di presa molto rapidi. Richiedono un vuoto che può essere generato ad es. da un ugello di Venturi.
Al momento di prelevare un pezzo deve essere presente il vuoto. Quando il pezzo viene depositato, oltre al disinserimento del vuoto deve essere eseguito un impulso di espul-sione per eliminare il vuoto formatosi nella ventosa. I generatori del vuoto del tipo VN-..-H-...-A eseguono l'impulso di espulsione automaticamente dopo il disinserimento del vuoto.
In altri modelli è necessario attivare questo impulso di espulsione mediante un segnale digitale supplementare.
Ventosa ESG Generatore del vuoto VN-..-H-...-A con
impulso di espulsione incorporato
Esempio:
Un pezzo deve essere spostato da una posizione pos2 alla posizione pos4.
Come generatore del vuoto viene utilizzato un ugello di Venturi azionato mediante un'uscita digitale del CMXR. A tale scopo viene impostato un modulo di uscita digitale.
pos2 pos4
pos3 pos1
20. Esempi
Festo GDCP-CMXR-SW-IT it 0909a 201
Variabili:
vacuum : DOUT := (...) // modulo di uscita digitale
Programma:
Vel(dynCart, 1500) // velocità di avanzamento = 1500 mm/sec
Acc(dynCart, 5000) // accelerazione lungo la traiettoria
= 5000 mm/sec²
OvlVel(75) // approssimazione della velocità al 75%
Lin(pos1)
vacuum.Set() // inserimento immediato del vuoto
Lin(pos2) // posizione di presa
WaitTime(10) // 10 msec di attesa per il tempo di presa
Lin(pos1)
Lin(pos3) // sopra posizione di deposizione
Lin(pos4) // posizione di deposizione
vacuum.Reset() // disinserimento vuoto nel punto inferiore
WaitTime(20) // 20 msec di attesa per il tempo di presa
Lin(pos3)
Funzionamento:
Poiché per la pinza non ci sono segnali di conferma, è necessario impostare un tempo di attesa per la chiusura e l'apertura. Questo tempo deve essere rilevato e ottimizzato mediante la messa in servizio.
I movimenti vengono eseguiti con un'approssimazione della velocità del 75 %, ad eccezione delle posizioni di presa pos2 e di deposizione pos3. L'istruzione seguente WaitTime impedisce un'approssimazione in quanto il calcolo preliminare dei record viene arrestato in questo punto e proseguito al termine del tempo di attesa impostato.
20. Esempi
202 Festo GDCP-CMXR-SW-IT it 0909a
Profilo di movimento:
Comportamento temporale:
Tempo
pos1 pos3
Tempo di attesa
pos4
pos3
pos2
pos1
pos2 pos4
pos3 pos1
Area di approssimazione
Velocità
20. Esempi
Festo GDCP-CMXR-SW-IT it 0909a 203
20.4.2 Pinze parallele pneumatiche
Le pinze parallele sono equipaggiate con dita di presa che vengono chiuse parallelamente. Le dita di presa possono essere adattate individualmente all'applicazione.
In genere le pinze parallele vengono azionate con due uscite separate per l'apertura e la
chiusura. Opzionalmente si possono integrare dei sensori sulle pinze per ottenere segnali di feed-back (aperta o chiusa) mediante i finecorsa.
Esempio:
Un pezzo deve essere spostato da una posizione pos2 alla posizione pos4.
Viene utilizzata una pinza parallela dotata di sensori di finecorsa. Si ottengono i segnali digitali seguenti, che vengono incorporati sotto forma di moduli nella programmazione FTL.
pos2 pos4
pos3 pos1
20. Esempi
204 Festo GDCP-CMXR-SW-IT it 0909a
Variabili:
outGripperOpen : DOUT := (...) // modulo di uscita digitale
outGripperClose : DOUT := (...) // modulo di uscita digitale
inGripperOpen : DIN := (...) // modulo di ingresso digitale
inGripperClosed : DIN := (...) // modulo di ingresso digitale
Programma:
Vel(dynCart, 1500) // velocità di avanzamento = 1500 mm/sec
Acc(dynCart, 5000) // accelerazione lungo la traiettoria
= 5000 mm/sec²
OvlVel(75) // approssimazione della velocità al 75%
Lin(pos1)
outGripperOpen.Set() // apertura pinza
outGripperClose.Reset()
inGripperOpen.Wait(TRUE) // attesa fino all'apertura
Lin(pos2) // posizione di presa
outGripperClose.Set() // chiusura pinza
outGripperOpen.Reset()
inGripperClosed.Wait() // attesa fino alla chiusura
Lin(pos1)
Lin(pos3)
Lin(pos4) // posizione di deposizione
outGripperOpen.Set() // apertura pinza
outGripperClose.Reset()
inGripperOpen.Wait() // attesa fino all'apertura
Lin(pos3)
Funzionamento:
Se sono presenti sensori per la segnalazione di feed-back delle posizioni di finecorsa delle pinze, non sono necessari tempi di attesa.
I movimenti vengono eseguiti con un'approssimazione della velocità del 75 %. Mediante l'attesa delle segnalazioni di finecorsa con il metodo del modulo Wait viene inibita un'approssimazione sulle posizioni di presa e di deposizione. Il calcolo preliminare dei record viene arrestato in questa posizione e proseguito dopo l'attivazione del segnale di ingresso digitale.
20. Esempi
Festo GDCP-CMXR-SW-IT it 0909a 205
Profilo di movimento:
Comportamento temporale:
Tempo
pos3
pos4
pos3
pos2
pos1
Tempo di attesa fino al segnale di feed-back per
pinza chiusa
Tempo di attesa fino al segnale di feed-back per
pinza aperta
Velocità
pos1
pos2 pos4
pos3 pos1
Area di approssimazione
20. Esempi
206 Festo GDCP-CMXR-SW-IT it 0909a
20.4.3 Unità oscillante di presa pneumatica
L'unità oscillante di presa pneumatica HGDS della Festo combina una pinza parallela con un attuatore oscillante in un'unica unità.
L'unità HGDS offre la possibilità di montare sensori per il rilevamento dei fine corsa della pinza e dell'attuatore oscillante. I sensori sono necessari per comandare l'applicazione in modo sicuro.
Esempio:
Un pezzo deve essere spostato da una posizione pos2 alla posizione pos4 con una rotazione di 90 gradi.
Viene utilizzata l'unità HGDS, equipaggiata con sensori per il rilevamento delle posizioni di fine corsa. Si ottengono i segnali digitali seguenti, che vengono integrati sotto forma di moduli nella programmazione FTL.
pos2 pos4
pos3 pos1
Rotazione di 90 gradi
Unità oscillante di presa HGDS con pinza parallela
20. Esempi
Festo GDCP-CMXR-SW-IT it 0909a 207
Variabili:
outGripperOpen : DOUT := (...) // modulo di uscita digitale
outGripperClose : DOUT := (...) // modulo di uscita digitale
outPos0Degree : DOUT := (...) // modulo di uscita digitale
outPos90Degree : DOUT := (...) // modulo di uscita digitale
inGripperOpen : DIN := (...) // modulo di ingresso digitale
inGripperClose : DIN := (...) // modulo di ingresso digitale
inPos0Degree : DIN := (...) // modulo di ingresso digitale
inPos90Degree : DIN := (...) // modulo di ingresso digitale
Programma:
Vel(dynCart, 1500) // velocità di avanzamento = 1500 mm/sec
Acc(dynCart, 5000) // accelerazione lungo la traiettoria
= 5000 mm/sec²
OvlVel(75) // approssimazione della velocità al 75%
Lin(pos1) // corsa sopra il pezzo
outGripperClose.Reset() // apertura pinza
outGripperOpen.Set()
outPos0Degree.Set() // rotazione a 0 gradi
outPos90Degree.Reset()
inGripperOpen.Wait() // attesa fino all'apertura della pinza
inPos0Degree.Wait() // attesa fino a 0 gradi
Lin(pos2) // posizione di presa
outGripperClose.Set() // chiusura pinza
outGripperOpen.Reset()
inGripperClose.Wait() // attesa fino alla chiusura della
pinza
Lin(pos1)
outPos0Degree.Reset() // rotazione a 90 gradi
outPos90Degree.Set()
Lin(pos3)
inPos90Degree.Wait(TRUE) // rotazione a 90 gradi con
approssimazione
Lin(pos4) // posizione di deposizione
outGripperClose.Reset() // apertura pinza
outGripperOpen.Set()
inGripperOpen.Wait() // attesa fino all'apertura della
pinza
Lin(pos3)
20. Esempi
208 Festo GDCP-CMXR-SW-IT it 0909a
Funzionamento
Con i sensori integrati per la segnalazione di feed-back dei movimenti di presa e di rotazione non sono necessari tempi di attesa.
Il rilevamento del movimento rotativo a 90 gradi viene eseguito utilizzando l'approssimazione. Ciò significa che, in assenza della segnalazione di feed-back della rotazione a 90 gradi durante la corsa verso pos4, il movimento viene arrestato e si attende finché non si attiva il segnale di feed-back. Se il segnale di feed-back è già presente, viene direttamente eseguito un movimento di approssimazione verso la pos4.
Profilo di movimento:
Il segnale di feed-back del movimento rotativo a 90 gradi viene rilevato prima di raggiungere la posizione pos3. Viene eseguito un movimento di approssimazione verso la posizione pos4.
Il segnale di feed-back del movimento rotativo a 90 gradi non è arrivato prima di raggiungere la posizione pos3. Il sistema resta in attesa del segnale di feed-back presso la posizione pos3 e il movimento di approssimazione verso la posizione pos4 non viene eseguito.
pos2 pos4
pos3 pos1
Area di approssimazione
pos2 pos4
pos3 pos1
Area di approssimazione
20. Esempi
Festo GDCP-CMXR-SW-IT it 0909a 209
Comportamento temporale:
Il segnale di feed-back della rotazione a 90 gradi è presente prima di raggiungere la posizione pos3. Viene eseguito un movimento di approssimazione verso la posizione pos4.
Il segnale di feed-back della rotazione a 90 gradi non è presente alla posizione pos3. Il sistema rimane in attesa di questo segnale.
Tempo
pos1 pos3
pos4 pos3 pos2
pos1
Tempo di attesa fino al segnale
di feed-back per pinza chiusa
Tempo di attesa fino al segnale di
feed-back per pinza aperta
Velocità
Tempo di attesa fino al segnale di feed-back della rotazione a 90 gradi
Tempo
pos1 pos3
pos4
pos3
pos2
pos1
Tempo di attesa fino al segnale di feed-back per pinza chiusa
Tempo di attesa fino al segnale di feed-back per pinza aperta
Velocità
Segnale di feed-back della rotazione a 90 gradi
20. Esempi
210 Festo GDCP-CMXR-SW-IT it 0909a
20.5 Utilizzo dell'interfaccia PLC
20.5.1 Definizione del compito
Nell'esempio seguente vengono prelevati pezzi dalla posizione “pickPos” (posizione di prelievo) e trasportati nella posizione “depositPos” (posizione di deposizione). La posi-zione di prelievo è dinamica. La coordinate esatte vengono calcolate in ogni ciclo da un sistema di visione e inviate all'unità di comando mediante l'interfaccia PLC PROFIBUS.
Per la sequenza vengono calcolate due posizioni intermedie dinamiche dalla posizione di partenza e dalla posizione finale. Queste posizioni verranno utilizzate come punti di appoggio durante la sequenza.
Se il PLC non invia i dati per tempo, il ciclo viene arrestato sulla posizione “wartePos”
finché il PLC non è pronto.
20.5.2 Interfaccia PLC
Lo scambio dei dati tra il controller CMXR e il PLC viene realizzato con due bit di sincroniz-zazione. Nel primo passo il PLC segnala che i dati sono stati inviati. Appena i dati vengono ricevuti dal CMXR, ciò viene segnalato al PLC. Infine vengono resettati entrambi i segnali di interfaccia. La sequenza è rappresentata nel diagramma di flusso seguente.
Acquisizione della
posizione
Segnale dal PLC (dati pronti)
plc_inboolreg[0]
Segnale al PLC (dati letti)
plc_outboolreg[0]
Nuova posizione trasmessa
Posizione acquisita
Fine trasmissione
pickPos depositPos
aboveDepositPos abovePickPos waitPos
20. Esempi
Festo GDCP-CMXR-SW-IT it 0909a 211
20.5.3 Programma sequenziale
Variabili:
waitPos : CARTPOS := (...)
pickPos : CARTPOS := (...)
depositPos : CARTPOS := (...)
abovePickPos : CARTPOS := (...)
aboveDepositPos : CARTPOS := (...)
gripper : DOUT := (...)
Programma:
// inizializzazione
Acc(dynCart, 4000)
Vel(dynCart, 100)
Lin(waitPos)
WHILE TRUE DO
// Handshake
WAIT plc_inboolreg[0] // PLC segnala una nuova posizione
pickPos := plc_cposreg[0]
abovePickPos.x := plc_cposreg[0].x
abovePickPos.y := plc_cposreg[0].y
plc_outboolreg[0] := TRUE // conferma l'acquisizione
WAIT NOT plc_inboolreg[0] // attesa di una reazione del PLC
plc_outboolreg[0] := FALSE
// accostamento della posizione di prelievo
Lin(abovePickPos)
Lin(pickPos)
// presa
gripper.Set()
WaitTime(200)
// accostamento della posizione di deposizione
Lin(abovePickPos)
Lin(aboveDepositPos)
20. Esempi
212 Festo GDCP-CMXR-SW-IT it 0909a
Lin(depositPos)
// deposizione
gripper.Reset()
WaitTime(200)
// accostamento della posizione di attesa
Lin(aboveDepositPos)
Lin(waitPos)
END_WHILE
21. Struttura a menu delle istruzioni FTL
Festo GDCP-CMXR-SW-IT it 0909a 213
21. Struttura a menu delle istruzioni FTL
Per semplificare la programmazione, sull'unità di comando manuale CDSA e nell'editor di programmazione FTL viene visualizzata una struttura a menu contenente tutte le istruzioni FTL disponibili. Di seguito sono rappresentate tutte le istruzioni disponibili per la “Programmazione FTL di base”.
Rappresentazione della struttura a menu sull'unità di comando manuale CDSA:
PLC-Interface
ProgHold
Mathematical functions
Position Functions
o ReadTargetPos
o ReadActualPos
o SavePosition
SIN
COS
TAN
COT
LN
ABS
SQRT
EXP
ASIN
21. Struttura a menu delle istruzioni FTL
214 Festo GDCP-CMXR-SW-IT it 0909a
ACOS
ATAN
ATAN2
ACOT
Time
TimeToStr
Reference Axis
RefAxis
RefAxisAsync
WaitRefFinished
IsAxisReferenced
Movement
Ptp
Lin
CircIp
LinToCircIp
PtpToCircIp
MoveAxisPtp
MoveAxisCart
PtpRel
LinRel
StopMove
Dynamics
DynOvr
Vel
Acc
Jerk
Ovr
OvlVel
OvlCart
Ramp
VconstOn
VconstOff
21. Struttura a menu delle istruzioni FTL
Festo GDCP-CMXR-SW-IT it 0909a 215
Program commands
WaitOnPath
StopProgram
WaitTime
WaitOnPos
CALL
RUN
KILL
… := …
//
WAIT
LABEL
GOTO
IF … GOTO
IF … THEN … END_IF
ELSE
ELSIF … THEN
WHILE … DO … END_WHILE
LOOP
RETURN
Robot commands
Reference Systems
o SetRefSys
o SetRefSys3P
o SetRefSysWorld
Tool
System functions
Time measurement
o CLOCK.Reset
o CLOCK.Start
o CLOCK.Stop
o CLOCK.Read
o CLOCK.ToStr
21. Struttura a menu delle istruzioni FTL
216 Festo GDCP-CMXR-SW-IT it 0909a
Additional commands
o SHR
o SHL
o ROR
o ROL
o STR
o CHR
o ORD
Message System
SetInfo
SetWarning
SetError
I/O-Modules
Analog Input
o AIN.Read
o AIN.WaitLss
o AIN.WaitGrt
o AIN.WaitIns
o AIN.WaitOuts
Analog Output
o AOUT.Write
o AOUT.Read
o AOUT.WaitLss
o AOUT.WaitGrt
o AOUT.WaitIns
o AOUT.WaitOuts
CANopen devices
o COPDEVICE.WriteSDO
o COPDEVICE.ReadSDOUnsigned
o COPDEVICE.ReadSDOSigned
Digital Input
o DIN.Read
o DIN.Wait
o DIN.WaitN
o DIN.RisingEdge
o DIN.ResetRisingEdge
21. Struttura a menu delle istruzioni FTL
Festo GDCP-CMXR-SW-IT it 0909a 217
Digital Output
o DOUT.Set
o DOUT.Reset
o DOUT.Write
o DOUT.Pulse
o DOUT.Read
o DOUT.ResetRisingEdge
o DOUT.Wait
o DOUT.WaitN
o DOUT.RisingEdge
Incremental Encoder
o ENCODER.Set
o ENCODER.Read
Indice analitico
218 Festo GDCP-CMXR-SW-IT it 0909a
#
##........................................................ 61
/
// ........................................................ 61
_
_global.tt ............................................. 19
A
ABS ................................................... 152 Acc ...................................................... 91 ACOS ................................................. 147
ACOT ................................................. 150 AIN .................................................... 170 AOUT ................................................. 175 Array ................................................... 31
ASIN .................................................. 146 ATAN ................................................. 149 ATAN2 ............................................... 151 AXISPOS .............................................. 63
C
Calcolo preliminare dei record ........................... 54, 56, 198
CALL .................................................... 51 CARTPOS ............................................. 63 CHR ................................................... 155 CircIp ................................................... 81 CLOCK ............................................... 180 Commento ........................................... 61 Conversioni del tipo ............................. 30 COS ................................................... 147 COT ................................................... 150
D
DIN .................................................... 159
DO ....................................................... 39 DOUT ................................................. 163 DynOvr ................................................ 96
E
ENCODER .......................................... 184 Error .................................................. 192 Esempio
Arresto di movimenti ...................... 194 Controllo del calcolo preliminare dei
record.......................................... 198
Utilizzo dei moduli di ingresso e di
uscita .......................................... 197 Utilizzo delle pinze ......................... 199 Utilizzo dell'interfaccia PLC ............ 210 WAIT con ingresso digitale ............... 57
EXP ................................................... 151
F
FTL ........................................... 12, 16, 19
G
GOTO .................................................. 48
I
IF…GOTO ............................................. 47 IF…THEN ............................................. 45 Interfaccia Profibus ........................... 130 IS_MAPPED ......................................... 37
IsReferenced ..................................... 121
J
Jerk ..................................................... 92
K
KILL ..................................................... 54
L
LABEL ................................................. 47 Lin....................................................... 74 LinRel .................................................. 76 LinToCircIp .......................................... 85 LN ..................................................... 151 LOOP .................................................. 49 LOW, HIGH .......................................... 34
M
MAP .................................................... 37 MAPTO ................................................ 37
MoveAxisCart ...................................... 72 MoveAxisPtp ....................................... 72
O
ORD .................................................. 155 OvlCart .............................................. 107 OvlVel ............................................... 105 Ovr ...................................................... 94
Indice analitico
Festo GDCP-CMXR-SW-IT it 0909a 219
P
Parole chiave ....................................... 24 plc_AxisPos ....................................... 133 plc_CartPos ....................................... 133 plc_RefSys ......................................... 134 plc_VarDint ........................................ 132 Posizione cartesiana ............................ 66 Posizione dell'asse .............................. 64 ProgHold ........................................... 135 Ptp ...................................................... 67 PtpRel ................................................. 70 PtpToCircIp .......................................... 83
R
Ramp ................................................... 98 Read .................................................. 187 ReadActualPos .................................. 142
ReadSDOSigned ................................ 189 ReadSDOUnsigned ............................ 191 ReadTargetPos .................................. 143 Record di programma disattivato ......... 61 RefAxis .............................................. 116 RefAxisAsync ..................................... 118 RETURN ............................................... 52 ROL ................................................... 154
ROR ................................................... 154 RUN ..................................................... 54
S
SavePosition ..................................... 144 Segmento nullo ................................. 103 Set .................................................... 186 SetError ............................................. 141 SetInfo .............................................. 139 SetRefSys .......................................... 111 SetRefSys3P ...................................... 112 SetRefSysWorld ................................. 114
SetWarning........................................ 140
SHL ................................................... 153
SHR ................................................... 153 SIN .................................................... 146 Sistemi di riferimento ........................ 134 SQRT ................................................. 152 State ................................................. 192 StopMove ........................................... 86 StopProg ............................................. 87 STR ................................................... 155
T
TAN ................................................... 149 TCP ................................................... 122
Tempo di attesa .................................. 54 tid ................................................. 19, 20 Time .................................................. 144 TimeToStr ......................................... 145
tip ....................................................... 19 Tipi di dati ........................................... 28 Tool .................................................. 125
U
Utensili ............................................. 122
V
Value ................................................ 192 VconstOff .......................................... 101 VconstOn ............................................ 99 Vel ...................................................... 90
W
WAIT ................................................... 56 WaitOnPath ......................................... 58 WaitOnPos .......................................... 60 WaitRefFinished ................................ 120 WaitTime............................................. 54 WHILE ................................................. 48 WriteSDO .......................................... 189
Indice analitico
220 Festo GDCP-CMXR-SW-IT it 0909a