Festo€¦ · Festo GDCP-CMXR-SW-IT it Version 1.0 3 Edizione...
Transcript of Festo€¦ · Festo GDCP-CMXR-SW-IT it Version 1.0 3 Edizione...
Taglio: In alto: 61,5 mm In basso: 61,5 mm Sinistra: 43,5 mm Destra: 43,5 mm
Controllore
Descrizione Istruzioni di programmazione CMXR FTL base
Descrizione 560 319 it 1002b [752 935
]
Festo GDCP-CMXR-SW-IT it Version 1.0 3
Edizione _____________________________________________________ 1002b
Denominazione _____________________________________ GDCP-CMXR-SW-IT
Numero di ordinazione ________________________________________ 560 319
Festo AG & Co KG., D-73734 Esslingen, 2010
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 Version 1.0
Legenda delle revisioni
Compilato da:
Nome del manuale: GDCP-CMXR-SW-IT
Nome del file:
Percorso del file:
N. Descrizione Indice revisioni Data di modifica
001 Stesura 0805NH 25.06.2008
002 Adattamento alla versione 1.20 0909a 25.08.2009
003 Adattamento a CMXR-C2 versione 1.0 1002b 24.03.2010
INDICE
Festo GDCP-CMXR-SW-IT it Version 1.0 5
INDICE
1. Introduzione ........................................................................................................ 13
1.1 Validità .............................................................................................................. 13
2. Avvertenze di sicurezza ....................................................................................... 14
2.1 Utilizzo della documentazione ........................................................................... 14
2.2 Impiego conforme all'utilizzo previsto ............................................................... 14
2.3 Personale qualificato ......................................................................................... 15
2.4 Avvertenze di sicurezza per i prodotti ................................................................ 15
2.5 Avvertenze di sicurezza per questo manuale ...................................................... 15
2.6 Istruzioni di sicurezza per il prodotto descritto .................................................. 16
3. Elaborazione del programma .............................................................................. 17
3.1 Generalità .......................................................................................................... 17
3.2 Interprete .......................................................................................................... 17
3.3 Avvio del programma ......................................................................................... 17
3.4 Calcolo preliminare dei record ........................................................................... 17
3.5 Struttura dei programmi .................................................................................... 19
3.6 Progetti FTL ....................................................................................................... 19
3.6.1 Progetto FTL globale ........................................................................... 20
3.7 Programmi FTL ................................................................................................... 20
3.7.1 Programmi globali del progetto .......................................................... 20
3.8 File di dati FTL “<Nome>.tid” ............................................................................... 21
3.8.1 Dati locali del programma .................................................................. 21
3.8.2 Dati globali del progetto ..................................................................... 21
3.8.3 Dati globali del sistema ...................................................................... 22
3.8.4 Istanziazione di variabili ..................................................................... 23
4. Struttura del linguaggio ...................................................................................... 25
4.1 Formattazione ................................................................................................... 25
4.2 Identificatori ...................................................................................................... 25
4.3 Parole chiave ..................................................................................................... 25
4.4 Costanti numeriche ............................................................................................ 26
4.5 Catene di caratteri ............................................................................................. 26
4.6 Operatori e separatori ....................................................................................... 26
4.6.1 Operatori aritmetici ............................................................................ 27
4.6.2 Operatori logici .................................................................................. 27
4.6.3 Operatori di comparazione ................................................................. 27
4.6.4 Altri operatori ..................................................................................... 28
INDICE
6 Festo GDCP-CMXR-SW-IT it Version 1.0
4.6.5 Separatori .......................................................................................... 28
5. Tipi di dati base ................................................................................................... 29
5.1 Tipo di dati booleano (BOOL) ............................................................................. 30
5.2 Tipi di numeri interi, tipo di dati REAL, tipi di schema di codifica a bit ............... 31
5.3 Parentesi ........................................................................................................... 31
5.4 Catene di caratteri (STRING) .............................................................................. 32
5.5 Tipi di dati strutturati ......................................................................................... 32
5.6 Array.................................................................................................................. 32
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
6. Dichiarazioni di variabili ..................................................................................... 39
6.1 Inizializzazione .................................................................................................. 39
7. Espressioni ......................................................................................................... 40
7.1 Sequenza di esecuzione nelle espressioni ......................................................... 40
8. Comando a programma ....................................................................................... 41
8.1 Istruzioni ........................................................................................................... 41
8.2 Assegnazione del valore <:=> ............................................................................. 41
8.3 Condizioni ......................................................................................................... 41
8.4 Diramazione <IF…THEN> ..................................................................................... 42
8.5 Comandi di salto ................................................................................................ 43
8.5.1 Marcatura di salto <LABEL> ................................................................. 44
8.5.2 Salto condizionato <IF…GOTO> ............................................................ 44
8.5.3 Salto assoluto <GOTO> ........................................................................ 45
8.6 Cicli 45
8.6.1 Istruzione WHILE <WHILE> ................................................................... 45
8.6.2 Istruzione LOOP <LOOP> ...................................................................... 46
8.7 Sottoprogrammi ................................................................................................ 47
8.7.1 Richiamo di un sottoprogramma <CALL> .............................................. 48
8.7.2 Ritorno al programma <RETURN> ......................................................... 49
8.8 Programmi paralleli ........................................................................................... 50
8.8.1 Avvio di un programma parallelo <RUN> .............................................. 51
8.8.2 Termine di un programma parallelo <KILL> .......................................... 51
8.9 Modifiche del calcolo preliminare dei record ...................................................... 52
8.9.1 Istruzione WAIT con indicazione del tempo <WaitTime> ....................... 52
INDICE
Festo GDCP-CMXR-SW-IT it Version 1.0 7
8.9.2 Istruzione WAIT con condizione <WAIT> ............................................... 53
8.9.3 Istruzione WaitOnPath con indicazione del tempo <WaitOnPath> ........ 55
8.9.4 Istruzione WaitOnPos con indicazione del tempo <WaitOnPos> ........... 56
8.9.5 Attesa dell'elaborazione principale del programma <WaitOnMainRun> ............................................................................... 57
8.10 Istruzione DO ..................................................................................................... 58
8.11 Inserimento di commenti <//> ............................................................................. 60
8.12 Disattivazione di una riga di programma <##> .................................................... 60
9. Istruzioni di movimento ...................................................................................... 62
9.1 Descrizione della posizione ............................................................................... 62
9.1.1 Posizione dell'asse ............................................................................. 63
9.1.2 Posizione cartesiana .......................................................................... 65
9.1.3 Programmazione di variabili di posizione mediante “teach-in” .......... 67
9.2 Movimento point-to-point <Ptp> ......................................................................... 67
9.2.1 Programmazione del movimento Ptp mediante “teach-in” .................. 70
9.3 Movimento point-to-point relativo <PtpRel> ........................................................ 70
9.4 Movimento di un asse, <MoveAxisPtp>, <MoveAxisCart> ................................... 72
9.4.1 Programmazione della posizione mediante “teach-in” con MoveAxisPtp e MoveAxisCart ....................................................... 74
9.5 Movimento lineare <Lin> ..................................................................................... 76
9.5.1 Programmazione del movimento Lin mediante “teach-in” .................. 78
9.6 Movimento lineare relativo <LinRel> ................................................................... 78
9.7 Movimento circolare con punto di appoggio ...................................................... 80
9.7.1 Funzionamento .................................................................................. 80
9.7.2 Definizione del piano .......................................................................... 81
9.7.3 Istruzione circolare con punto di appoggio <CircIp> ............................. 83
9.7.4 Istruzione circolare con punto di appoggio, accostamento PTP <PtpToCircIp> ......................................................... 85
9.7.5 Istruzione circolare con punto di appoggio, accostamento Lin <LinToCircIp> .......................................................... 87
9.7.6 Programmazione delle istruzioni circolari mediante “teach-in” .......... 88
9.8 Arresto del movimento <StopMove> ................................................................... 89
9.9 Arresto del programma <StopProgram> .............................................................. 90
10. Istruzioni dinamiche ........................................................................................... 91
10.1 Limitazione autom. della dinamica, limitatore dinamico ................................... 92
10.2 Velocità <Vel> ..................................................................................................... 93
10.3 Accelerazione <Acc> ............................................................................................ 94
10.4 Strappo <Jerk> .................................................................................................... 95
10.5 Override ............................................................................................................ 97
10.5.1 Override dall'unità di comando manuale <Ovr>.................................... 97
INDICE
8 Festo GDCP-CMXR-SW-IT it Version 1.0
10.5.2 Override dinamico <DynOvr> ............................................................... 99
10.6 Rampe di accelerazione ................................................................................... 100
10.6.1 Impostazione delle forme di rampa <Ramp> ...................................... 101
10.7 Attivazione della velocità di avanzamento costante <VconstOn> ....................... 102
10.8 Disattivazione della velocità di avanzamento costante <VconstOff> .................. 104
11. Istruzioni di approssimazione ........................................................................... 105
11.1 Segmenti nulli ................................................................................................. 106
11.2 Campo limite ................................................................................................... 107
11.3 Approssimazione della velocità ....................................................................... 108
11.3.1 Con fattore percentuale <OvlVel> ....................................................... 108
11.4 Approssimazione geometrica ........................................................................... 110
11.4.1 Approssimazione degli assi X, Y e Z <OvlCart> ................................... 110
12. Sistemi di riferimento (spostamento del punto zero) ........................................ 112
12.1 Riferimento del sistema di riferimento ............................................................. 112
12.2 Dati del sistema di riferimento ......................................................................... 113
12.3 Sistema di riferimento con valori diretti <SetRefSys> ..................................... 114
12.4 Sistema di riferimento con 3 punti <SetRefSys3P> ............................................ 115
12.4.1 Programmazione del sistema di riferimento SetRefSys3P mediante “teach-in” ........................................................................................ 116
12.5 Sistema di riferimento globale <SetRefSysWorld> ............................................. 118
12.6 Sistema di riferimento dinamico <SetRefSysDyn> > ........................................... 118
12.7 Esempio .......................................................................................................... 119
13. Definizione dei riferimenti di una cinematica .................................................... 121
13.1 Corsa di riferimento <RefAxis> .......................................................................... 121
13.2 Corsa di riferimento asincrona <RefAxisAsync> ................................................. 123
13.3 Attesa della fine della corsa di riferimento <WaitRefFinished> ........................... 125
13.4 Interrogazione dello stato di un asse <IsAxisReferenced> ................................. 126
14. Utensili ............................................................................................................. 127
14.1 Dati dell'utensile ............................................................................................. 127
14.1.1 Dati del vettore TCP .......................................................................... 127
14.2 Attivazione dei dati dell'utensile <Tool> ............................................................ 130
14.2.1 Effetti dei dati TCP ............................................................................ 130
15. Interfaccia PROFIBUS ........................................................................................ 135
15.1 Ingressi e uscite booleani, plc_InBool, plc_OutBool ......................................... 136
15.2 Variabili intere a 32 bit, plc_Dint ...................................................................... 137
15.3 Posizioni, plc_AxisPos, plc_CartPos ................................................................. 138
15.4 Sistemi di riferimento, plcRefSys ..................................................................... 139
INDICE
Festo GDCP-CMXR-SW-IT it Version 1.0 9
15.5 Arresto programmato <ProgHold> ..................................................................... 140
16. Interfaccia FTL per il PLC interno (solo per controller multiassiali con CoDeSys) .................................................................................................... 142
16.1 Variabili di sistema FTL .................................................................................... 142
16.1.1 Esempio con variabili di sistema ....................................................... 143
16.1.2 Esempio con variabili di sistema e istruzione MAP ............................ 144
17. Sistema di segnalazione ................................................................................... 145
17.1 Testi dei messaggi ........................................................................................... 145
17.2 Informazione <SetInfo> ..................................................................................... 147
17.3 Avvertenza <SetWarning> ................................................................................. 148
17.4 Messaggio di errore <SetError> ......................................................................... 149
18. Funzioni ............................................................................................................ 151
18.1 Lettura della posizione corrente <ReadActualPos> ............................................ 151
18.2 Lettura della posizione di arrivo <ReadTargetPos> ............................................ 152
18.3 Salvataggio permanente di un valore di posizione <SavePosition> .................... 153
18.4 Lettura dell'ora del sistema <Time> ................................................................... 153
18.5 Conversione dell'ora in testo <TimeToStr> ........................................................ 154
18.6 Seno <SIN>, <ASIN> ........................................................................................... 155
18.7 Coseno <COS>, <ACOS> ..................................................................................... 156
18.8 Tangente <TAN>, <ATAN> ................................................................................... 158
18.9 Cotangente <COT>, <ACOT> ................................................................................ 159
18.10 Arcotangente2 <ATAN2> ................................................................................... 160
18.11 Logaritmo <LN> ................................................................................................. 160
18.12 Esponente <EXP> .............................................................................................. 160
18.13 Valore assoluto <ABS> ...................................................................................... 161
18.14 Radice quadrata <SQRT> ................................................................................... 161
18.15 Spostamento dei bit <SHR>, <SHL> .................................................................... 162
18.16 Rotazione dei bit <ROR>, <ROL> ......................................................................... 163
18.17 Conversione di un valore in una stringa <STR> .................................................. 164
18.18 Conversione di un valore ASCII in un carattere <CHR> ....................................... 164
18.19 Conversione di un carattere in un valore ASCII <ORD> ....................................... 164
18.20 Impostazione del bit in una variabile WORD <SetBit> ........................................ 165
18.21 Cancellazione del bit in una variabile WORD <ResetBit> .................................... 166
18.22 Controllo del bit in una variabile WORD <CheckBit> .......................................... 167
19. Moduli ............................................................................................................... 168
19.1 Funzioni ........................................................................................................... 169
INDICE
10 Festo GDCP-CMXR-SW-IT it Version 1.0
19.2 Variabili ........................................................................................................... 169
19.3 Comportamento in fase di esecuzione ............................................................. 170
19.3.1 Parametro ovlEnable ........................................................................ 170
19.4 Modulo di ingresso digitale DIN ....................................................................... 171
19.4.1 Istanziazione .................................................................................... 171
19.4.2 Metodi ............................................................................................. 173
19.4.3 Attesa dello stato, metodo Wait/WaitN ............................................ 174
19.4.4 Lettura dello stato, metodo Read ..................................................... 174
19.4.5 Fronte ascendente, metodo RisingEdge ............................................ 174
19.4.6 Reset del fronte, metodo ResetRisingEdge ....................................... 175
19.5 Modulo di uscita digitale DOUT ........................................................................ 175
19.5.1 Istanziazione .................................................................................... 175
19.5.2 Variabili ............................................................................................ 177
19.5.3 Metodi ............................................................................................. 178
19.5.4 Attesa dello stato, metodo Wait/WaitN ............................................ 179
19.5.5 Lettura dello stato, metodo Read ..................................................... 179
19.5.6 Fronte ascendente, metodo RisingEdge ............................................ 179
19.5.7 Reset del fronte, ResetRisingEdge .................................................... 180
19.5.8 Attivazione e reset, metodo Set/Reset ............................................. 180
19.5.9 Attivazione dell'uscita, metodo Write ............................................... 181
19.5.10 Impostazione dell'uscita per un determinato periodo, metodo Pulse ................................................................................... 181
19.6 Modulo di ingresso analogico AIN .................................................................... 182
19.6.1 Istanziazione .................................................................................... 182
19.6.2 Variabili ............................................................................................ 184
19.6.3 Metodi ............................................................................................. 184
19.6.4 Attesa finché il valore non è inferiore/superiore, metodo WaitLss, WaitGrt .................................................................. 185
19.6.5 Attesa finché il valore non è dentro/fuori dall'intervallo, metodo WaitIns, WaitOuts ................................................................ 186
19.6.6 Lettura del valore, metodo Read ....................................................... 186
19.7 Modulo di uscita analogico AOUT .................................................................... 187
19.7.1 Istanziazione .................................................................................... 187
19.7.2 Variabili ............................................................................................ 188
19.7.3 Metodi ............................................................................................. 189
19.7.4 Scrittura del valore di uscita, metodo Write ...................................... 190
19.7.5 Attesa finché il valore non è superiore/inferiore, metodo WaitLss, WaitGrt ............................................................................... 190
19.7.6 Attesa finché il valore non è dentro/fuori dall'intervallo, metodo WaitIns, WaitOuts ................................................................... 191
19.7.7 Lettura del valore di uscita, metodo Read ......................................... 191
19.8 Modulo orologio CLOCK ................................................................................... 192
19.8.1 Istanziazione .................................................................................... 192
19.8.2 Metodi ............................................................................................. 193
INDICE
Festo GDCP-CMXR-SW-IT it Version 1.0 11
19.8.3 Avvio dell'orologio, metodo Start ..................................................... 194
19.8.4 Arresto dell'orologio, metodo Stop ................................................... 194
19.8.5 Reset dell'orologio, metodo Reset .................................................... 194
19.8.6 Lettura dell'orologio, metodo Read .................................................. 194
19.8.7 Conversione del valore di tempo in una stringa, metodo ToStr ......... 195
19.9 Modulo encoder ENCODER .............................................................................. 196
19.9.1 Istanziazione .................................................................................... 196
19.9.2 Variabili ............................................................................................ 198
19.9.3 Metodi ............................................................................................. 198
19.9.4 Impostazione dell'encoder, metodo Set ........................................... 198
19.9.5 Lettura dell'encoder, metodo Read ................................................... 199
19.10 Modulo CANopen COPDEVICE .......................................................................... 200
19.10.1 Istanziazione .................................................................................... 200
19.10.2 Metodi ............................................................................................. 201
19.10.3 Scrittura di SDO, metodo WriteSDO .................................................. 201
19.10.4 Lettura di SDO, metodo ReadSDOSigned .......................................... 202
19.10.5 Lettura di SDO, metodo ReadSDOUnsigned ...................................... 203
20. Segnali delle periferiche ................................................................................... 204
20.1 Utilizzo di ingressi e uscite digitali ................................................................... 204
20.2 Utilizzo di ingressi e uscite analogici ................................................................ 204
21. Programmazione di eventi ................................................................................ 206
21.1 Eventi supportati ............................................................................................. 206
21.2 Utilizzo del set di istruzioni FTL ........................................................................ 207
21.3 Controllo dei tempi .......................................................................................... 208
21.4 Evento: avviamento a regime del sistema di comando <onstartup> ................ 208
21.5 Eventi del comando a programma .................................................................... 208
21.5.1 Comportamento di esecuzione durante il caricamentoFehler! Textmarke nicht definiert.
21.5.2 Comportamento di esecuzione durante l'esercizio ............................ 209
21.5.3 Sovrapposizione di eventi di programmi ........................................... 210
21.5.4 Impiego di progetti/programmi diversi ............................................. 210
21.5.5 Esempio: comando di un applicatore durante l'incollatura ............... 212
21.6 Eventi per i tasti F1 e F2 ................................................................................... 213
21.7 Istruzioni FTL specifiche per applicazioni con eventi ........................................ 215
21.7.1 Rilevamento del modo operativo attivo, <GetAutoModeActive, GetManualModeActive> .................................................................... 215
21.7.2 Caricamento di un programma FTL, <LoadProgram> .......................... 216
21.8 Testi di messaggio dei programmi associati agli eventi .................................. 217
22. Punti di commutazione semplici ....................................................................... 219
22.1 Punto di commutazione semplice con comando di traslazione, <DO> .............. 219
INDICE
12 Festo GDCP-CMXR-SW-IT it Version 1.0
22.2 Punto di commutazione semplice, <OnPosition> ............................................... 220
22.3 Comportamento nell'area di approssimazione ................................................. 220
22.4 Comportamento di esecuzione dell'istruzione DO ............................................ 221
23. Punti di commutazione traiettoria ..................................................................... 222
23.1 Segmento di traiettoria .................................................................................... 222
23.2 Comportamento nell'area di approssimazione ................................................. 223
23.3 Punto di commutazione con scostamento percentuale, <OnParameter> ........ 224
23.4 Punto di commutazione qualsiasi sulla traiettoria, <OnDistance> ..................... 225
23.5 Punto di commutazione su un piano di commutazione, <OnPlane> ................ 228
23.5.1 Programmazione mediante “teach-in” della posizione del piano di commutazione ................................................................................. 230
23.6 Offset di tempo opzionale ................................................................................ 231
23.6.1 Reazione del sistema in caso di valore di tempo non consentito ....... 232
23.7 Condizioni limite .............................................................................................. 233
23.7.1 Esercizio a passo singolo .................................................................. 233
23.7.2 Istruzioni di attesa che influiscono sull'elaborazione principale........ 233
23.7.3 Attivazione del puntatore di frase ..................................................... 233
23.7.4 Influsso dell'override ........................................................................ 234
23.7.5 Lavorazione in esercizio manuale a velocità ridotta .......................... 235
23.7.6 Interruzione del programma ............................................................. 235
23.8 Punti di commutazione non eseguiti ................................................................ 236
24. Esempi .............................................................................................................. 237
24.1 Arresto di movimenti ....................................................................................... 237
24.2 Utilizzo dei moduli di ingresso e di uscita ........................................................ 240
24.3 Controllo del calcolo preliminare dei record ..................................................... 241
24.4 Utilizzo delle pinze ........................................................................................... 242
24.4.1 Ventose ............................................................................................ 243
24.4.2 Pinze parallele pneumatiche ............................................................ 246
24.4.3 Unità oscillante di presa pneumatica ................................................ 249
24.5 Utilizzo dell'interfaccia PLC .............................................................................. 253
24.5.1 Definizione del compito .................................................................... 253
24.5.2 Interfaccia PLC.................................................................................. 253
24.5.3 Programma sequenziale ................................................................... 254
INDICE
Festo GDCP-CMXR-SW-IT it Version 1.0 13
A. Elenco di istruzioni FTL ..................................................................................... 256
B. Struttura a menu delle istruzioni FTL ................................................................ 261
C. Termini utilizzati ............................................................................................... 266
D. Indice ................................................................................................................ 267
1. Introduzione
14 Festo GDCP-CMXR-SW-IT it Version 1.0
1. Introduzione Nel presente documento viene descritto il set di istruzioni FTL (Festo Teach Language) dei
controller multiassiali CMXR di Festo. La programmazione del controller CMXR avviene con l'editor FTL nel relativo PlugIn del Festo Configuration Tool (FCT) o mediante l'unità di comando manuale CDSA-D1-VX.
Controller CMXR-C1 Controller CMXR-C2
PlugIn FCT con editor FTL Unità di comando manuale CDSA-D1-VX
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.
1.1 Validità
A causa della differenza tra le diverse potenze di elaborazione dei controller CMXR i set di istruzioni dei CMXR sono differenti tra di loro.
Il manuale contiene la versione delle istruzioni FTL valida al momento della stesura. Dalla diversità delle versioni possono, tuttavia, scaturire delle differenze. Nell'appendice 0 è disponibile un quadro riassuntivo di tutte le istruzioni con il relativo rimando alla versione e alle piattaforme di comando.
2. Avvertenze di sicurezza
Festo GDCP-CMXR-SW-IT it Version 1.0 15
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 conforme all'utilizzo previsto
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 protezione 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
16 Festo GDCP-CMXR-SW-IT it Version 1.0
2.3 Personale qualificato
Nota
Gli impianti elettrici devono essere azionati esclusivamente da 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: possono essere danneggiati se non vengono utilizzati correttamente.
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!
L'inosservanza di quanto indicato può causare gravi danni materiali e lesioni personali.
Attenzione
L'inosservanza di quanto indicato può causare elevati danni materiali.
2. Avvertenze di sicurezza
Festo GDCP-CMXR-SW-IT it Version 1.0 17
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 eseguiti 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
18 Festo GDCP-CMXR-SW-IT it Version 1.0
3. Elaborazione del programma
3.1 Generalità
FTL è l'acronimo di Festo Teach Language. FTL è un linguaggio di programmazione orien-
tato 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 FTL 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 Version 1.0 19
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'elabora-zione 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 24.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
20 Festo GDCP-CMXR-SW-IT it Version 1.0
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 Version 1.0 21
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 Programmi FTL
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 Nome del file per il codice del programma
<Nome>.tid Nome 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 FTL 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.
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.
Questi programmi globali 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. Elaborazione del programma
22 Festo GDCP-CMXR-SW-IT it Version 1.0
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.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
3. Elaborazione del programma
Festo GDCP-CMXR-SW-IT it Version 1.0 23
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 configurato accuratamente ed eventualmente bloccato nell'applicazione mediante misure corrispondenti.
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. Elaborazione del programma
24 Festo GDCP-CMXR-SW-IT it Version 1.0
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>
Si può assegnare un nome a piacere alle variabili, tenendo conto delle regole menzionate nel capitolo 4.3 Parole chiave. 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.
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.
3. Elaborazione del programma
Festo GDCP-CMXR-SW-IT it Version 1.0 25
Nota
Per memorizzare in modo permanente i valori di posizione sulla scheda di memoria, utilizzare l'istruzione FTL “SavePosition”.
4. Struttura del linguaggio
26 Festo GDCP-CMXR-SW-IT it Version 1.0
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 sottolinea-tura). 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 Version 1.0 27
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 rap-presentazione decimale, binaria o esadecimale.
Esempi di numeri interi validi:
Modo di scrittura decimale 100 -100
Modo di scrittura binario 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.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.
4. Struttura del linguaggio
28 Festo GDCP-CMXR-SW-IT it Version 1.0
4.6.1 Operatori aritmetici
Operatore Significato
+ Addizione
- Sottrazione
* Moltiplicazione
/ Divisione
MOD Operazione 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
< Minore
<= Minore 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 Version 1.0 29
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 dei parametri e per la
strutturazione dell'esecuzione nel caso delle
espressioni
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 istruzioni FTL
Tabella 4.5 Separatori
5. Tipi di dati base
30 Festo GDCP-CMXR-SW-IT it Version 1.0
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 opera-
zioni 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 Version 1.0 31
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 Conversioni possibili
A seconda del tipo di dati sono possibili le seguenti conversioni:
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
32 Festo GDCP-CMXR-SW-IT it Version 1.0
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 29). 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 elabora-
zione. 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 Version 1.0 33
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 62.
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
34 Festo GDCP-CMXR-SW-IT it Version 1.0
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
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.
5. Tipi di dati base
Festo GDCP-CMXR-SW-IT it Version 1.0 35
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
Se necessario è possibile indicare un indice del campo anche negli array multidimensio-nali. L'esempio seguente mostra un array con 3 x 3 elementi e indice del campo rispettiva-mente 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> )
5. Tipi di dati base
36 Festo GDCP-CMXR-SW-IT it Version 1.0
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 multidimen-sionali 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 dà 0
o Il richiamo di HIGH dà 4
Seconda dimensione da 0 a 18
o Il richiamo di LOW dà 0
o Il richiamo di HIGH dà 18
Terza dimensione da 10 a 34
o Il richiamo di LOW dà 10
o Il richiamo di HIGH dà 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
Festo GDCP-CMXR-SW-IT it Version 1.0 37
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
38 Festo GDCP-CMXR-SW-IT it Version 1.0
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> )
Esempio:
MyIndex := MAP(Index)
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.
Sintassi
IS_MAPPED (<variabile di riferimento>) : BOOL
5. Tipi di dati base
Festo GDCP-CMXR-SW-IT it Version 1.0 39
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 sotto-programma.
Esempio:
IF IS_MAPPED(Level) THEN
:
:
ELSIF
SetError(“Not mapped”)
END_IF
6. Dichiarazioni di variabili
40 Festo GDCP-CMXR-SW-IT it Version 1.0
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 varia-bili 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 Version 1.0 41
7. Espressioni Un'espressione descrive un valore assegnato a un determinato tipo di dati. Un'espressione può contenere variabili e funzioni. I componenti di un'espressione ven-gono 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
42 Festo GDCP-CMXR-SW-IT it Version 1.0
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 istruzione, 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 condizioni possono contenere operandi booleani (ad es. AND, OR) oppure un operando di comparazione (ad es. >, <=,=). Il collegamento di più comparazioni 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 Version 1.0 43
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 condizioni nell'esecuzione 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 a cui si ricorre nel caso in cui nessuna delle condizioni venga soddisfatta. L'istruzione IF viene terminata con l'istruzione END_IF.
8. Comando a programma
44 Festo GDCP-CMXR-SW-IT it Version 1.0
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 Version 1.0 45
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 diramazione 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
46 Festo GDCP-CMXR-SW-IT it Version 1.0
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ò pro-grammare 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 Version 1.0 47
Nota
Un ciclo di istruzioni che viene eseguito molto spesso e non con-tiene 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 diretta-mente 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
8. Comando a programma
48 Festo GDCP-CMXR-SW-IT it Version 1.0
Esempi:
LOOP 10 DO // 10 ripetizioni
index := index + 13
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 20). 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 Version 1.0 49
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
50 Festo GDCP-CMXR-SW-IT it Version 1.0
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 non è possibile. In caso di necessità, si possono utilizzare le variabili globali 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 Version 1.0 51
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
I comandi di traslazione ad una cinematica da un programma parallelo sono possibili solo se, in precedenza, non è stato impartito alcun comando di traslazione dal programma principale. Se viene impartito un comando di traslazione dal programma principale e da un programma parallelo, il sistema genera 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'azionamento 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 sincro-
nizzazione 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
52 Festo GDCP-CMXR-SW-IT it Version 1.0
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 potenza di elaborazione 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 varia-bili 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 pro-gramma 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. Comando a programma
Festo GDCP-CMXR-SW-IT it Version 1.0 53
8.9 Modifiche del calcolo preliminare dei record
Per eseguire efficientemente i movimenti riconoscendo situazioni critiche come ad es. il superamento della dinamica di azionamento massima si deve calcolare in anticipo la traiettoria. In alcune situazioni è tuttavia necessario che il calcolo preliminare del programma venga sincronizzato con l'esecuzione. A questo scopo la programmazione FTL propone diverse istruzioni, che sospendono il calcolo preliminare, con conseguente arresto del movimento, oppure attendono durante l'esecuzione del programma a tempo ottimizzato, per non influire sulla dinamica del movimento. Queste istruzioni vengono descritte nelle pagine seguenti.
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.
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'elaborazione 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
54 Festo GDCP-CMXR-SW-IT it Version 1.0
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 pro-gramma 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 Version 1.0 55
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 52) è 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.
Sensore
X
Z
Ventosa
Pezzo
Vassoio
Pos2
Pos1
Pos3
Pos4
8. Comando a programma
56 Festo GDCP-CMXR-SW-IT it Version 1.0
Estratto dal programma di movimenti:
:
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 pro-gramma viene proseguito. Se al momento dell'accostamento è 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>
L'istruzione FTL 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
L'istruzione 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 Version 1.0 57
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
:
8.9.4 Istruzione WaitOnPos con indicazione del tempo <WaitOnPos>
L'istruzione FTL 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.
Tempo di attesa di 150 msec
Tempo
Velocità di avanzamento
pos1
pos1
printPos
8. Comando a programma
58 Festo GDCP-CMXR-SW-IT it Version 1.0
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
8.9.5 Attesa dell'elaborazione principale del programma <WaitOnMainRun>
L'istruzione FTL WaitOnMainRun arresta il calcolo preliminare dei record finché l'elabo-razione principale del programma non l'ha raggiunto. Questo non ha però alcun effetto sulla dinamica della traiettoria. Un'approssimazione su una posizione successiva non viene quindi pregiudicata.
Sintassi
WaitOnMainRun ( )
Questa istruzione permette un'eventuale descrizione o valutazione di segnali successive, senza che il movimento sia pregiudicato. L'approssimazione al segmento successivo fa sì che una posizione precedentemente programmata non venga raggiunta con precisione.
Esempio:
Nella sequenza di movimento mostrata di seguito viene eseguita l'istruzione WaitOnMainRun immediatamente prima di raggiungere la posizione pos2 e successivamente viene descritta la variabile plc_InBool[3], diretta al PLC.
:
Lin(pos1) // corsa su pos1
Lin(pos2) // corsa su pos2
WaitOnMainRun() // attesa dell'elaborazione principale
del programma
Pos2
Pos1
80%
8. Comando a programma
Festo GDCP-CMXR-SW-IT it Version 1.0 59
plc_InBool[3] := TRUE // segnale al PLC
Lin(pos3) // corsa su pos3
:
Il diagramma seguente mostra l'esecuzione di WaitOnMainRun nel tempo:
8.10 Istruzione DO
Con l'istruzione DO è possibile attuare un'esecuzione forzata di determinate istruzioni FTL durante l'elaborazione principale del programma. L'istruzione presenta la seguente sintassi:
Sintassi
<istruzione FTL> DO <istruzione FTL>
L'istruzione FTL 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 è possibile utilizzare una quantità limitata di istruzioni FTL. Non sono ammesse istruzioni riferite ad una cinematica, come ad es. un'indicazione di dina-micità o una traslazione in posizione.
Tempo
Velocità di avanzamento
pos3
pos1
pos2
Esecuzione di WaitOnMainRun prima del
raggiungimento della posizione pos2
Ejecución principal
Avance
8. Comando a programma
60 Festo GDCP-CMXR-SW-IT it Version 1.0
Nota
L'istruzione DO viene eseguita dopo che è stata eseguita l'istru-zione FTL precedente nell'elaborazione principale. L'esecuzione avviene incondizionatamente. Una riga di programma può contenere una sola istruzione DO, seguita esattamente da una istruzione FTL.
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)
:
Esempio di descrizione di variabili al PLC:
:
Lin(pos1)
SetVel(dynCart, 1000)) DO plc_Dint[3] := 5
Lin(pos2)
:
8. Comando a programma
Festo GDCP-CMXR-SW-IT it Version 1.0 61
8.11 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.12 Disattivazione di una riga di programma <##>
Con la sequenza di caratteri “##” vengono disattivate righe di programma per l'elabora-zione 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 Version 1.0
Nota
Per le istruzioni di programma composte da più righe, come ad es. IF..THEN…ELSE, occorre disattivare tutte le relative righe di pro-gramma.
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 Version 1.0 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 21).
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 automatica-mente 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 32).
9. Istruzioni di movimento
64 Festo GDCP-CMXR-SW-IT it Version 1.0
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 32). 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 posi-zioni 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 Version 1.0 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 rotativo 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 rotativo 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 Version 1.0
9.1.2 Posizione cartesiana
A differenza della posizione dell'asse del tipo di dati AXISPOS, il tipo di posizione carte-siano 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 posi-zione. 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 32). 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 Version 1.0 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 pro-grammazione delle variabili a, b, c, aux1, aux2 o aux3 nell'indicazione di posizione del tipo
di dati CARTPOS non ha alcun effetto.
9. Istruzioni di movimento
68 Festo GDCP-CMXR-SW-IT it Version 1.0
9.1.3 Programmazione di variabili di posizione mediante “teach-in”
È possibile programmare singole variabili di posizione del tipo AXISPOS e CARTPOS mediante “teach-in” con l'ausilio dell'unità di comando manuale o del software di emulazione nel monitor delle variabili.
Per eseguire il “teach-in” di una variabile di posizione è necessario che il controller multiassiale CMXR si trovi nel modo operativo MANUALE e che la variabile da pro-grammare sia selezionata.
Premendo il softkey si salva la posizione corrente nella variabile specificata. Per una
variabile del tipo CARTPOS viene salvato il valore cartesiano, per una variabile del tipo AXISPOS la posizione dell'asse. La programmazione mediante “teach-in” avviene sempre su una variabile di posizione.
Nota
Quando si programma mediante “teach-in” una posizione cartesiana del tipo CARTPOS il valore viene sempre programmato nel sistema di riferimento momentaneamente selezionato. Questo viene sempre indicato nel box di selezione della pagina della posizione. Per il “teach-in” di una posizione dell'asse del tipo AXISPOS il sistema di riferimento selezionato è irrilevante.
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.
1. Cliccare sulla variabile che
diventa blu
2. Il softkey Teach viene attivato
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it Version 1.0 69
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
70 Festo GDCP-CMXR-SW-IT it Version 1.0
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 90 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
Festo GDCP-CMXR-SW-IT it Version 1.0 71
9.2.1 Programmazione del movimento Ptp mediante “teach-in”
L'istruzione FTL Ptp dispone della posizione di arrivo quale parametro che può essere programmato mediante “teach-in” con l'unità di comando manuale o il software di emulazione.
Nel modo operativo MANUALE, quando si crea l'istruzione o si preme il softkey Modifica si apre la maschera dei parametri dell'istruzione. Marcando la riga Posizione si attiva il softkey e può quindi essere utilizzato.
Premendo il softkey si salva la posizione corrente nella variabile specificata. La
programmazione mediante “teach-in” avviene sempre su una variabile di posizione.
Nota
Quando si programma mediante “teach-in” una posizione carte-siana del tipo CARTPOS il valore viene sempre programmato nel sistema di riferimento momentaneamente selezionato. Questo viene sempre indicato nel box di selezione della pagina della posizione. Per il “teach-in” di una posizione dell'asse del tipo AXISPOS il sistema di riferimento selezionato è irrilevante.
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
1. cliccare sul campo parametri
che diventa blu
2. Il softkey Teach viene attivato
9. Istruzioni di movimento
72 Festo GDCP-CMXR-SW-IT it Version 1.0
L'indicazione della distanza può avvenire nel sistema cartesiano o nel sistema di coordi-nate degli assi. Il controller multiassiale 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.
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)
pos2
Asse X
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 Version 1.0 73
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.
Attenzione
Pericolo di collisione!
Se durante un movimento relativo il movimento viene arrestato e poi ripreso, viene percorsa l'intera distanza programmata.
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
9. Istruzioni di movimento
74 Festo GDCP-CMXR-SW-IT it Version 1.0
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.
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
:
pos2
Asse X
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
Festo GDCP-CMXR-SW-IT it Version 1.0 75
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
:
9.4.1 Programmazione della posizione mediante “teach-in” con MoveAxisPtp e MoveAxisCart
È possibile programmare la posizione delle istruzioni MoveAxisPtp e MoveAxisCart mediante “teach-in” con l'ausilio dell'unità di comando manuale o del software di emulazione.
Nel modo operativo MANUALE, quando si crea l'istruzione o si preme il softkey Modifica si apre la maschera dei parametri dell'istruzione. Marcando la riga Posizione si attiva il softkey e può quindi essere utilizzato.
Prima del “teach-in” si deve selezionare l'asse desiderato del parametro CartComp (istruzione MoveAxisCart) o l'asse (istruzione MoveAxisPtp). Sulla base di questa selezione si stabilisce la posizione mediante “teach-in” e la si scrive nel parametro Pos. Se al parametro Pos è assegnata una variabile REAL, il valore viene scritto in questa variabile.
1. Cliccare sul campo parametri
che diventa blu
2. Il softkey Teach
viene attivato
9. Istruzioni di movimento
76 Festo GDCP-CMXR-SW-IT it Version 1.0
Nota
Quando si programma mediante “teach-in” la posizione cartesiana dell'istruzione MoveAxisCart, il valore viene sempre programmato nel sistema di riferimento momentaneamente selezionato. Questo viene sempre indicato nel box di selezione della pagina della posizione. Per il “teach-in” della posizione dell'asse dell'istruzione MoveAxisPtp il sistema di riferimento selezionato è irrilevante.
Box di selezione di singoli assi per la macro
MoveAxisPtp. Vengono visualizzati solo gli
assi disponibili nella configurazione.
Box di selezione degli assi cartesiani per la
macro MoveAxisCart.
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it Version 1.0 77
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 inter-namente. 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.
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 127).
Variabile:
Asse X
Asse Y
Asse Z
Asse rotativo con pinza
Vettore su TCP
9. Istruzioni di movimento
78 Festo GDCP-CMXR-SW-IT it Version 1.0
:
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)
:
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.
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 Version 1.0 79
9.5.1 Programmazione del movimento Lin mediante “teach-in”
L'istruzione Lin dispone della posizione di arrivo quale parametro che può essere programmato mediante “teach-in” con l'unità di comando manuale o il software di emulazione.
Nel modo operativo MANUALE, quando si crea l'istruzione o si preme il softkey Modifica si apre la maschera dei parametri dell'istruzione. Marcando la riga Posizione si attiva il softkey e può quindi essere utilizzato.
Premendo il softkey si salva la posizione corrente nella variabile specificata. La
programmazione mediante “teach-in” avviene sempre su una variabile di posizione.
Nota
Quando si programma mediante “teach-in” una posizione carte-siana del tipo CARTPOS il valore viene sempre programmato nel sistema di riferimento momentaneamente selezionato. Questo viene sempre indicato nel box di selezione della pagina della posizione. Per il “teach-in” di una posizione dell'asse del tipo AXISPOS il sistema di riferimento selezionato è irrilevante.
9.6 Movimento lineare relativo <LinRel>
L'istruzione Lin relativo funziona in modo analogo all'istruzione Lin. In questo caso l'indi-cazione 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
1. Cliccare sul campo parametri
che diventa blu
2. Il softkey Teach viene attivato
9. Istruzioni di movimento
80 Festo GDCP-CMXR-SW-IT it Version 1.0
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.
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
:
Programma:
:
Lin(pos1)
Lin(pos2)
direction := TRUE
LOOP 5 DO
IF direction = TRUE THEN
LinRel(distYpos)
pos2
Asse X
Asse Y
100
1050
387
98.5
45
pos3
pos1
57
112
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it Version 1.0 81
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.
Attenzione
Pericolo di collisione!
Se durante un movimento relativo il movimento viene arrestato e poi ripreso, viene percorsa l'intera distanza programmata.
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 si rag-giunge 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
82 Festo GDCP-CMXR-SW-IT it Version 1.0
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 composto da 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 deside-
rati sul punto di partenza e sul punto finale.
9.7.2 Definizione del piano
L'orbita circolare viene percorsa su un piano definito in base a 3 punti, punto di partenza, punto di appoggio e punto finale. Il piano, su cui si delinea l'orbita circolare, si estende nello spazio in base a questa definizione.
Punto di appoggio
Punto di appoggio
Punto di partenza
Punto di partenza
Punto finale
Punto finale
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it Version 1.0 83
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; un'interpolazione elicoidale, che richiede un'interpolazione supplementare perpendi-colare al piano, non è possibile.
Punto di partenza
Punto di appoggio
Punto finale
Piano definito dai 3 punti
9. Istruzioni di movimento
84 Festo GDCP-CMXR-SW-IT it Version 1.0
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 finale 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 è costituito 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
Festo GDCP-CMXR-SW-IT it Version 1.0 85
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 comando di traslazione separato, 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
86 Festo GDCP-CMXR-SW-IT it Version 1.0
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
Festo GDCP-CMXR-SW-IT it Version 1.0 87
Esempio:
Con una cinematica si deve percorrere il contorno seguente:
Il movimento avviene sul piano XY, il valore per l'asse Z è 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
88 Festo GDCP-CMXR-SW-IT it Version 1.0
9.7.5 Istruzione circolare con punto di appoggio, accostamento Lin <LinToCircIp>
Come l'istruzione PtpToCircIp, anche l'istruzione LinToCircIp comprende il punto di
partenza dell'orbita. L'accostamento dell'orbita circolare avviene ora sulla base di un sistema cartesiano. Ciò significa che il movimento verso il punto di partenza e l'orbita circolare in caso di approssimazione può 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 movimento avviene sul piano XY, il valore per l'asse Z è 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
Festo GDCP-CMXR-SW-IT it Version 1.0 89
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.7.6 Programmazione delle istruzioni circolari mediante “teach-in”
Le istruzioni circolari presentano 2 o 3 parametri a seconda del tipo. Esse possono essere programmate mediante “teach-in” con l'unità di comando manuale o il software di emulazione.
Nel modo operativo MANUALE, quando si crea l'istruzione o si preme il softkey Modifica si apre la maschera dei parametri dell'istruzione. Marcando la riga Posizione si attiva il
softkey e può quindi essere utilizzato.
Premendo il softkey si salva la posizione corrente nella variabile specificata. La
programmazione mediante “teach-in” avviene sempre sulla variabile di posizione. Per la programmazione di altre posizioni mediante “teach-in” si deve cliccare di nuovo sulla rispettiva posizione, selezionandola.
1. Cliccare sul campo parametri
che diventa blu
2. Il softkey Teach viene attivato
9. Istruzioni di movimento
90 Festo GDCP-CMXR-SW-IT it Version 1.0
Nota
Quando si programma mediante “teach-in” una posizione carte-siana del tipo CARTPOS il valore viene sempre programmato nel sistema di riferimento momentaneamente selezionato. Questo viene sempre indicato nel box di selezione della pagina della posizione. Per il “teach-in” di una posizione dell'asse del tipo AXISPOS il sistema di riferimento selezionato è irrilevante.
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'istru-zione StopMove. Nel capitolo 24.1 Arresto di movimenti a pagina 237 è descritto un esempio di utilizzo dell'istruzione StopMove.
9. Istruzioni di movimento
Festo GDCP-CMXR-SW-IT it Version 1.0 91
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
92 Festo GDCP-CMXR-SW-IT it Version 1.0
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 la preimpostazione dei valori dinamici nel Festo Configuration Tool:
Cartesiano:
Scossa
Scossa
Accelerazione
Accelerazione
Velocità
Velocità
Unità Jog: Riposizionamento:
Punto a punto:
Valori
standard
Standard
10. Istruzioni dinamiche
Festo GDCP-CMXR-SW-IT it Version 1.0 93
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 massimi possibili dei singoli assi. I valori in questione riguardano la velocità, l'accelera-zione 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 in questione viene traslato verso i suoi limiti. La traiettoria 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
94 Festo GDCP-CMXR-SW-IT it Version 1.0
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 dal movimento. Se si verifica una limitazione a causa delle velocità massime possibili degli assi, viene emesso un messaggio corrispon-dente.
Sintassi
Vel (<Mode> : ENUM, <Value> : REAL)
Parametro Significato Unità
Mode Tipo di velocità Enumerazione: dynPtp, dynCart
Value Valore di velocità Dipendente dal tipo (Mode) selezionato
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 Version 1.0 95
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 Dipendente dal tipo (Mode)
selezionato
ValueDec Valore per la decelerazione (indicazione
opzionale)
Dipendente dal tipo (Mode)
selezionato
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)
:
10. Istruzioni dinamiche
96 Festo GDCP-CMXR-SW-IT it Version 1.0
Programma:
:
Ptp(pos0)
Acc(dynPtp, 30, 30) // accelerazione per PTP al 30 %
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 Dipendente dal tipo (Mode)
selezionato
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 Version 1.0 97
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
98 Festo GDCP-CMXR-SW-IT it Version 1.0
10.5 Override
Un override consente di impostare i valori dinamici in percentuale. Con questa impostazione è 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 Version 1.0 99
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 l'istruzione 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
100 Festo GDCP-CMXR-SW-IT it Version 1.0
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.
Velocità di avanzamento
pos4
pos3
pos2
pos1
60%
100%
Tempo
10. Istruzioni dinamiche
Festo GDCP-CMXR-SW-IT it Version 1.0 101
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 quadra 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 para-metro 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
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
TrapezTrapezio Sinusoide
Minjerk Quadra sinusoidale
Acc
ele
razi
on
e
Acc
ele
razi
on
e
Acc
eler
azio
ne
Acc
eler
azio
ne
Tempo
Tempo Tempo
Tempo
Tempo
10. Istruzioni dinamiche
102 Festo GDCP-CMXR-SW-IT it Version 1.0
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 è sinus-oidale 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. Come valore iniziale è impo-stata la rampa quadra sinusoidale.
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 Version 1.0 103
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 Vconst
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 110). Un'approssimazione basata sulla velocità percentuale provoca una modifica della velocità di avanzamento nell'area di approssimazione.
Il controller multiassiale CMXR calcola la velocità di avanzamento possibile in base alla traiettoria e ai valori dinamici massimi dei componenti meccanici. Il limite della velocità di avanzamento possibile viene determinato dalla dinamica dei componenti meccanici. Se vengono programmati segmenti di traiettoria che non possono essere percorsi con una velocità costante a causa dei limiti dinamici, in questi punti si verificheranno cadute della velocità di avanzamento.
10. Istruzioni dinamiche
104 Festo GDCP-CMXR-SW-IT it Version 1.0
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 Version 1.0 105
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
106 Festo GDCP-CMXR-SW-IT it Version 1.0
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 pre-cisione. Per utilizzare la funzione di approssimazione è necessario attivarla con le funzioni corrispondenti.
L'approssimazione può essere di due tipi:
3. Approssimazione della velocità in base alla velocità
4. 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 Version 1.0 107
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
108 Festo GDCP-CMXR-SW-IT it Version 1.0
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 auto-maticamente 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 auto-maticamente al 50 % della lunghezza del segmento della traiet-toria.
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.
Traiettoria percorsa
Area di approssimazione generata dall'unità di comando
Area di approssimazione programmata
Area di approssimazione
sovrapposta
11. Istruzioni di approssimazione
Festo GDCP-CMXR-SW-IT it Version 1.0 109
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 approssi mazione 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 posi-zionamento possibilmente bassa. Con valori compresi tra 100 % e 200 % vengono aumen-tate 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 sulla posizione 2. Per l'area di approssimazione sono definiti valori differenti.
11. Istruzioni di approssimazione
110 Festo GDCP-CMXR-SW-IT it Version 1.0
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)
:
Tempo di ciclo
Area di approssimazione
3) Sovrapposizione completa
2) Sovrapposizione parziale
Direzione X
Tempo di ciclo
Tempo di ciclo
Direzione Y
1) Senza sovrapposizione
0 %
50 %
100 %
11. Istruzioni di approssimazione
Festo GDCP-CMXR-SW-IT it Version 1.0 111
11.4 Approssimazione geometrica
Con l'approssimazione geometrica vengono definite le tolleranze dalla posizione finale 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
112 Festo GDCP-CMXR-SW-IT it Version 1.0
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 102).
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
Aree di
approssimazione, curve polinomiali
12. Sistemi di riferimento (spostamento del punto zero)
Festo GDCP-CMXR-SW-IT it Version 1.0 113
12. Sistemi di riferimento (spostamento del punto zero)
I sistemi di riferimento sono sistemi di coordinate cartesiane con 3 gradi di libertà trasla-tori 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 si evince dalla figura è possibile definire più sistemi di riferimento allo zero carte-siano di un altro sistema di riferimento, mentre può essere attivo un solo riferimento.
Nota
Un concatenamento di sistemi di riferimento va utilizzato con molta prudenza. 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)
114 Festo GDCP-CMXR-SW-IT it Version 1.0
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 Version 1.0 115
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 riferimento agisce in modo additivo. Per creare un rimando al sistema di coordinate globali della cinematica occorre definire il riferimento sulla variabile di sistema world.
Esempio:
Dati:
refsysdata0 : REFSYSDATA := (MAP(world), 100, 150, 0, 0, 0, 0)
Programma:
SetRefSys(refsysdata0)
12. Sistemi di riferimento (spostamento del punto zero)
116 Festo GDCP-CMXR-SW-IT it Version 1.0
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 Lunghezza (mm)
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 calco-lazioni 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 world.
12. Sistemi di riferimento (spostamento del punto zero)
Festo GDCP-CMXR-SW-IT it Version 1.0 117
Esempio:
Dati:
refsys3p0 : REFSYS3P := (MAP(world),
(100.0, 100.0, 0.0),
(200.0, 100.0, 0.0),
(200.0, 200.0, 0.0))
Programma:
SetRefSys3P(refsys3p0)
12.4.1 Programmazione del sistema di riferimento SetRefSys3P mediante “teach-in”
La programmazione del sistema di riferimento SetRefSys3p mediante “teach-in” conferisce vantaggi rilevanti nell'applicazione. Il “teach-in” permette di acquisire direttamente ad es. lo zero di un pallet. Eventuali imprecisioni, dovute ad es. al montaggio o alla cinematica stessa, vengono quindi compensate. Inoltre non è necessario alcun rilevamento laborioso dello zero mediante misurazione e calcolo nello spazio.
Per la programmazione del sistema di riferimento SetRefSys3P mediante “teach-in” si deve tuttavia rispettare una sequenza:
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.
Questi 3 parametri possono essere programmati mediante “teach-in” con l'unità di comando manuale o il software di emulazione.
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)
118 Festo GDCP-CMXR-SW-IT it Version 1.0
Nel modo operativo MANUALE, quando si crea l'istruzione o si preme il softkey Modifica si apre la maschera dei parametri dell'istruzione. Marcando la riga Posizione si attiva il softkey e può quindi essere utilizzato.
Prima del “teach-in” delle posizioni si deve tuttavia fare in modo di selezionare un riferimento valido al sistema di riferimento desiderato mediante il parametro baseRs. In questo sistema di riferimento ha luogo la programmazione mediante “teach-in” delle posizioni seguenti. Se non esiste ancora il sistema di riferimento desiderato, occorre prima crearlo.
Premendo il softkey si salva la posizione cartesiana corrente nella variabile speci-ficata. La programmazione mediante “teach-in” avviene sempre su una variabile di posizione. Per il “teach-in” di un'ulteriore posizione occorre marcare tale posizione nuovamente cliccandoci sopra.
Nota
Il sistema di riferimento selezionato sulla pagina della posizione non ha alcun significato per l'istruzione SetRefSys3P. Il riferimento al sistema di riferimento viene creato mediante il parametro baseRs.
2. Cliccare sul campo parametri
che diventa blu
3. Il softkey Teach viene attivato
1. Selezione sistema di riferimento in cui si
attua il “teach-in”.
12. Sistemi di riferimento (spostamento del punto zero)
Festo GDCP-CMXR-SW-IT it Version 1.0 119
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 Sistema di riferimento dinamico <SetRefSysDyn> >
Per integrare i sistemi di riferimento statici, esiste l'istruzione SetRefSysDyn, che permette di definire un sistema di riferimento dinamico. Questo sistema di riferimento dinamico è necessario per realizzare la funzione di tracking.
Sintassi
SetRefSysDyn(<refSys> : CARTREFSYSVAR)
Parametro Significato Unità
refSys Sistema di riferimento, a cui vengono conferiti valori dal PLC
interno.
Lunghezze e unità angolari
Tabella 12 3 Parametri dell'istruzione SetRefSysDyn
Nota
Questa istruzione opera solo in combinazione con il PLC integrato. Per ulteriori informazioni sull'istruzione e sulla funzione di tracking ad essa connessa consultare la documentazione speciale “Programmazione FTL per il tracking”.
12. Sistemi di riferimento (spostamento del punto zero)
120 Festo GDCP-CMXR-SW-IT it Version 1.0
12.7 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 := (MAP(world), 0, 0, 0, 0, 0, 0)
refPal2 : REFSYSDATA := (MAP(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
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 Version 1.0 121
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 dei riferimenti di una cinematica
122 Festo GDCP-CMXR-SW-IT it Version 1.0
13. Definizione dei riferimenti di una cinematica
13.1 Corsa di riferimento <RefAxis>
L'istruzione RefAxis consente di referenziare gli 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 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 gli assi interessati possano traslare liberamente durante la corsa di riferimento. Per garantire una corretta ese-cuzione della corsa di riferimento occorre inoltre selezionare valori dinamici adeguati per questi movimenti. In questo caso non sono consigliabili valori dinamici elevati.
13. Definizione dei riferimenti di una cinematica
Festo GDCP-CMXR-SW-IT it Version 1.0 123
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 della corsa 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 riferimento 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 positivo Arresto meccanico Arresto meccanico
-17 negativo Arresto meccanico Arresto meccanico
-2 positivo Arresto meccanico Impulso zero
-1 negativo Arresto meccanico Impulso zero
1 negativo Finecorsa Impulso zero
2 positivo Finecorsa Impulso zero
7 positivo Interruttore di
riferimento Impulso zero
11 negativo Interruttore di
riferimento Impulso zero
13. Definizione dei riferimenti di una cinematica
124 Festo GDCP-CMXR-SW-IT it Version 1.0
Valore Direzione Destinazione Punto di riferimento per zero
17 negativo Finecorsa Finecorsa
18 positivo Finecorsa Finecorsa
23 positivo Interruttore di
riferimento Interruttore di riferimento
27 negativo Interruttore di
riferimento Interruttore di riferimento
33 negativo Impulso zero Impulso zero
34 positivo Impulso zero Impulso zero
35 - nessuna corsa Posizione effettiva corrente
99 - - Sequenza come definita nel progetto
FCT del controllore motore
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 interessato 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 referenziare parallelamente 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 dei riferimenti di una cinematica
Festo GDCP-CMXR-SW-IT it Version 1.0 125
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 RefAxis
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 consi-gliabili 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 dei riferimenti di una cinematica
126 Festo GDCP-CMXR-SW-IT it Version 1.0
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 dell'istruzione RefAxisAsync è assolutamente necessario utilizzare l'istruzione WaitRefFinished in modo da garantire 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 dei riferimenti di una cinematica
Festo GDCP-CMXR-SW-IT it Version 1.0 127
13.4 Interrogazione dello stato di un asse <IsAxisReferenced>
Interrogazione per sapere se un determinato asse è stato referenziato.
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 l'asse specificato è referenziato viene restituito TRUE, altrimenti FALSE.
14. Utensili
128 Festo GDCP-CMXR-SW-IT it Version 1.0
14. Utensili Il controller multiassiale CMXR 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 Version 1.0 129
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
130 Festo GDCP-CMXR-SW-IT it Version 1.0
Inoltre l'orientamento del sistema di coordinate dell'utensile deve essere rivolto in direzione 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 è possibile 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 assegnazione 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
Angolo
14. Utensili
Festo GDCP-CMXR-SW-IT it Version 1.0 131
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 cine-matica. 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 durante il calcolo preliminare dei record dell'interprete FTL e da lì vengono inclusi nell'ulteriore 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 dei comandi di traslazione successivi. Nell'esempio
seguente viene descritto il comportamento dei dati utensile in combinazione con l'utilizzo di un asse oscillante pneumatico.
14. Utensili
132 Festo GDCP-CMXR-SW-IT it Version 1.0
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 Version 1.0 133
Orientamento 2, utensile ruotato:
Per effetto del movimento oscillante il TCP si sposta di lato e l'utensile ha ora un orientamento 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 posi-zione 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
134 Festo GDCP-CMXR-SW-IT it Version 1.0
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 Version 1.0 135
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 al massimo 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
136 Festo GDCP-CMXR-SW-IT it Version 1.0
15. Interfaccia PROFIBUS Il CMXR può essere gestito da un comando host (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 comu-nicazione con il comando host 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 host prima 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 tampone 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 Version 1.0 137
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.1 Ingressi e uscite booleani, plc_InBool, plc_OutBool
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 host.
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)
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.
Elaborazione
principale
Utilizzo dell'istruzione DO, la variabile viene elaborata durante l'elaborazione principale del programma.
15. Interfaccia PROFIBUS
138 Festo GDCP-CMXR-SW-IT it Version 1.0
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
:
15.2 Variabili intere a 32 bit, plc_Dint
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 host o trasmesse al medesimo. Se necessario devono essere trasmesse o lette dal comando host.
Le variabili intere sono memorizzate in un array accessibile mediante gli indici da 0 a 255.
Sintassi
plc_Dint [ <indice array> ] : DINT
Esempio:
:
IF plc_Dint[3] = 13 THEN
:
:
END_IF
15. Interfaccia PROFIBUS
Festo GDCP-CMXR-SW-IT it Version 1.0 139
15.3 Posizioni, plc_AxisPos, plc_CartPos
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 host 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
140 Festo GDCP-CMXR-SW-IT it Version 1.0
15.4 Sistemi di riferimento, plcRefSys
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 host 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 riferimento 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'interfaccia. Non è possibile creare un riferimento a un sistema che è stato definito all'esterno dell'interfaccia.
Esempio:
:
Lin(pos2)
SetRefSys(plc_RefSys[3])
Lin(pos3)
Lin(pos4)
:
15. Interfaccia PROFIBUS
Festo GDCP-CMXR-SW-IT it Version 1.0 141
15.5 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.
Se il segnale HALTENA sull'interfaccia è attivato, cioè ha lo stato TRUE, quando viene richiamata l'istruzione ProgHold il programma di movimenti viene arrestato. In questo caso viene arrestato solo il programma nel quale si trova l'istruzione ProgHold. Altri programmi, ad es. i programmi paralleli, continuano ad essere eseguiti. Quando il PLC imposta il segnale HALTENA su FALSE, il programma arrestato viene proseguito.
Nota
Se con l'istruzione 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 l'istruzione 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
142 Festo GDCP-CMXR-SW-IT it Version 1.0
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. Interfaccia FTL per il PLC interno (solo per controller multiassiali con CoDeSys)
Festo GDCP-CMXR-SW-IT it Version 1.0 143
16. Interfaccia FTL per il PLC interno (solo per controller multiassiali con CoDeSys)
Per poter creare anche sequenze di processo individuali oltre ai programmi di movimento, il controller CMXR è dotato di un PLC CoDeSys integrato che consente una programma-zione a norma IEC 61131-3. Per maggiori informazioni sulle funzionalità supportate si rimanda alla descrizione delle prestazioni nel manuale di sistema del rispettivo controller CMXR.
Questo capitolo descrive l'interfaccia tra il controllore di movimento e il controllore di processo dal punto di vista della programmazione FTL. Questa interfaccia è caratterizzata
da variabili FTL che possono essere scritte e lette dal PLC CoDeSys.
16.1 Variabili di sistema FTL
Tutte le variabili FTL necessarie per l'interfaccia sono già memorizzate come variabili di sistema e immediatamente disponibili. Le variabili sono presenti come tipo di dati base BOOL, DWORD, DINT e REAL e come variabile di posizione dei tipi AXISPOS e CARTPOS.
Tutte le variabili sono realizzate come ARRAY con una dimensione di 256 elementi. Per semplificare l'utilizzo dei dati, per ogni tipo di dati è disponibile un array d'ingresso e un array di uscita. Le seguenti definizioni vengono utilizzate nella programmazione in FTL:
- i dati di ingresso sono i dati che vengono scritti dal PLC (suffisso: In),
- i dati di uscita sono i dati che vengono letti dal PLC (suffisso: Out).
Nota
I dati attesi dal PLC sono riportati nei dati di ingresso. I dati da inviare al PLC vanno sempre registrati nei dati di uscita. Uno scambio di queste aree dati provoca stati programma errati.
La tabella seguente mostra le variabili FTL disponibili per l'interfaccia:
Tipo di dati Dati di ingresso Dati di uscita
BOOL plc_InBool : ARRAY[256] OF BOOL plc_OutBool : ARRAY[256] OF BOOL
DINT plc_InDint : ARRAY[256] OF DINT plc_OutDint : ARRAY[256] OF DINT
REAL plc_InReal : ARRAY[256] OF Real plc_OutReal : ARRAY[256] OF Real
DWORD plc_InDword : ARRAY[256] OF DWORD plc_OutDword : ARRAY[256] OF DWORD
AXISPOS plc_InAxisPos : ARRAY[256] OF AXISPOS plc_OutAxisPos : ARRAY[256] OF AXISPOS
CARTPOS plc_InCartPos : ARRAY[256] OF CARTPOS plc_OutCartPos : ARRAY[256] OF CARTPOS
Tabella 16.1 Variabili di sistema FTL dell'interfaccia per il PLC
16. Interfaccia FTL per il PLC interno (solo per controller multiassiali con CoDeSys)
144 Festo GDCP-CMXR-SW-IT it Version 1.0
16.1.1 Esempio con variabili di sistema
Un programma FTL può elaborare un tipo di articolo A e un tipo di articolo B. Questi vengono selezionati dal PLC tramite una preimpostazione. Al termine della procedura, il programma FTL invia un segnale di conferma al PLC. Le variabili dell'interfaccia FTL vengono suddivise nel modo seguente:
- plc_OutBool[0] segnale di conferma, quando il programma è pronto
- plc_InBool[0] segnale di avvio per lo svolgimento del programma
- plc_InBool[1] selezione del tipo di articolo A
- plc_InBool[2] selezione del tipo di articolo B
Affinché il programma venga eseguito correttamente, il PLC deve garantire che prima del segnale di avvio sia correttamente attivata la selezione dei tipi di articolo tramite i due segnali plc_InBool[1] e plc_InBool[2].
:
OvlVel(100) // approssimazione completa
Lin(Home)
plc_OutBool[0] := FALSE // messaggio di esecuzione terminata
= FALSE
WAIT plc_InBool[0] // in attesa del segnale di avvio
IF plc_InBool[1] THEN // lavorazione articolo A
CALL PartTypeA
ELSIF plc_InBool[2] THEN // lavorazione articolo B
CALL PartTypeB
END_IF
plc_OutBool[0] := TRUE // messaggio di esecuzione terminata
= TRUE
Lin(Home)
:
L'istruzione WAIT mantiene in attesa il calcolo preliminare del programma finché il segnale plc_InBool[0] non assume lo stato TRUE.
Nota
Il programma FTL viene sempre calcolato in anticipo. Questo vale anche per tutte le variabili programmate dell'interfaccia. Il PLC deve quindi garantire che tutti i dati necessari siano a disposizione del programma FTL al momento giusto. Se necessario si devono imple-mentare misure adeguate, come ad es. l'attesa di dati speciali con il conseguente arresto del calcolo preliminare.
16. Interfaccia FTL per il PLC interno (solo per controller multiassiali con CoDeSys)
Festo GDCP-CMXR-SW-IT it Version 1.0 145
16.1.2 Esempio con variabili di sistema e istruzione MAP
Le variabili di sistema hanno nomi prestabiliti. Per assegnare nomi appropriati (definiti dall'utente stesso) ai segnali di interfaccia viene utilizzata l'istruzione MAP. Con l'istruzione MAP vengono creati dei riferimenti che vengono poi collegati alle singole variabili.
Analogamente all'esempio precedente:
Variabile FTL:
// dichiarazione e collegamento dei segnali alle singole
variabili
CycleFinished : MAPTO BOOL := MAP(plc_OutBool[0])
StartFromPlc : MAPTO BOOL := MAP(plc_InBool[0])
JobPartA : MAPTO BOOL := MAP(plc_InBool[1])
JobPartB : MAPTO BOOL := MAP(plc_InBool[2])
Programma FTL:
:
OvlVel(100) // approssimazione completa
Lin(Home)
CycleFinished := FALSE // messaggio di esecuzione terminata
= FALSE
WAIT StartFromPlc // in attesa del segnale di avvio
IF JobPartA THEN // lavorazione articolo A
CALL PartTypeA
ELSIF JobPartB THEN // lavorazione articolo B
CALL PartTypeB
END_IF
CycleFinished := TRUE // messaggio di esecuzione terminata
= TRUE
Lin(Home)
:
Nota
L'uso delle variabili di riferimento e dell'istruzione MAP semplifica la lettura dei programmi.
17. Sistema di segnalazione
146 Festo GDCP-CMXR-SW-IT it Version 1.0
17. 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) tramite l'unità di comando manuale o un'unità di comando esterna.
Illustrazione della memoria errori sull'unità di comando manuale:
17.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
17. Sistema di segnalazione
Festo GDCP-CMXR-SW-IT it Version 1.0 147
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 l'istruzione 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”.
17. Sistema di segnalazione
148 Festo GDCP-CMXR-SW-IT it Version 1.0
17.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 17.1 Parametri dell'istruzione SetInfo
La composizione del testo del messaggio è descritta nel capitolo 17.1 Testi dei messaggi a pagina 145.
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:
17. Sistema di segnalazione
Festo GDCP-CMXR-SW-IT it Version 1.0 149
17.3 Avvertenza <SetWarning>
L'istruzione SetWarning genera un messaggio di avvertimento nel sistema di segnala-
zione.
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 17.2 Parametri dell'istruzione SetWarning
La composizione del testo del messaggio è descritta nel capitolo 17.1 Testi dei messaggi a
pagina 145.
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:
17. Sistema di segnalazione
150 Festo GDCP-CMXR-SW-IT it Version 1.0
17.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 può essere proseguito solo dopo aver confermato il messaggio di errore. A tale scopo occorre abilitare il controllore motore e riavviare il programma.
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 17.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:
17. Sistema di segnalazione
Festo GDCP-CMXR-SW-IT it Version 1.0 151
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.
18. Funzioni
152 Festo GDCP-CMXR-SW-IT it Version 1.0
18. Funzioni
18.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 18.1 Parametri dell'istruzione ReadActualPos
Attenzione
Un valore di posizione memorizzato in una variabile viene conser-vato 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 l'istruzione SavePosition.
Esempio:
Il programma nell'esempio legge la posizione corrente, esegue i comandi di traslazione programmati 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)
18. Funzioni
Festo GDCP-CMXR-SW-IT it Version 1.0 153
Programma:
ReadActualPos(startPos)
PTP(axis0)
PTP(axis1)
PTP(axis2)
PTP(startPos)
18.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 18.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 l'istruzione SavePosition.
18. Funzioni
154 Festo GDCP-CMXR-SW-IT it Version 1.0
18.3 Salvataggio permanente di un valore di posizione <SavePosition>
L'istruzione FTL memorizza un valore di posizione in modo permanente sulla scheda di memoria.
Sintassi
SavePosition (<Pos> : POSITION)
Con l'istruzione 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 18.3 Parametri dell'istruzione SavePosition
Attenzione
Una riscrittura frequente di posizioni sulla scheda di memoria riduce la durata della scheda. L'istruzione SavePosition non può essere richiamata ciclicamente. Può essere utilizzata per l'impo-stazione occasionale dell'applicazione.
18.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
18. Funzioni
Festo GDCP-CMXR-SW-IT it Version 1.0 155
18.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 18.4 Parametri della funzione TimeStr
Esempio:
str_Time := TimeToStr() // lettura dell'ora corrente del
sistema
Valore di ritorno:
str_Time = “Mon Feb 13 11:23:44 2006”
18. Funzioni
156 Festo GDCP-CMXR-SW-IT it Version 1.0
18.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.
18. Funzioni
Festo GDCP-CMXR-SW-IT it Version 1.0 157
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
18.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.
18. Funzioni
158 Festo GDCP-CMXR-SW-IT it Version 1.0
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
18. Funzioni
Festo GDCP-CMXR-SW-IT it Version 1.0 159
18.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
a := 45.89 // cateto opposto
18. Funzioni
160 Festo GDCP-CMXR-SW-IT it Version 1.0
b := 145.67 // cateto adiacente
value := a / b
alpha := ATAN(value) // calcolo dell'angolo incluso
18.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.
18. Funzioni
Festo GDCP-CMXR-SW-IT it Version 1.0 161
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
18.10 Arcotangente2 <ATAN2>
Calcola l'arcotangente con un aumento dell'intervallo di valori da + π a –π.
Sintassi
(<argomento> : REAL) := ATAN2 (<y> : REAL, <x> : REAL)
18.11 Logaritmo <LN>
La funzione logaritmo calcola il logaritmo naturale dell'argomento passato.
Sintassi
(<logaritmo naturale> : REAL) := LN (<valore> : REAL)
18.12 Esponente <EXP>
La funzione esponente calcola il valore e(x).
Sintassi
(<risultato> : REAL) := EXP (<valore>:REAL)
18. Funzioni
162 Festo GDCP-CMXR-SW-IT it Version 1.0
18.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
18.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
18. Funzioni
Festo GDCP-CMXR-SW-IT it Version 1.0 163
18.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
18. Funzioni
164 Festo GDCP-CMXR-SW-IT it Version 1.0
18.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
18. Funzioni
Festo GDCP-CMXR-SW-IT it Version 1.0 165
18.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”.
18.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)
18.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. Funzioni
166 Festo GDCP-CMXR-SW-IT it Version 1.0
18.20 Impostazione del bit in una variabile WORD <SetBit>
La funzione SetBit consente di impostare un bit selezionato sul valore TRUE in una variabile DWORD. Se il bit è già settato su TRUE, questa funzione non ha alcun effetto. Il valore modificato è disponibile nel valore di ritorno per l'ulteriore lavorazione.
Sintassi
SetBit ( <val> : DWORD, <bitNr> : DINT) : DWORD
Metodo Descrizione
val Valore da modificare
bitNr Numero di bit che verrà settato nel parametro Val
Tabella 18.5 Variabili della funzione SetBit
Il numero di bit viene specificato mediante il parametro bitNr. L'intervallo di valori ammissibile per referenziare i bit della variabile WORD (32 bit) è compreso tra 0 e 31. Il bit di ordine più basso (LSB) viene attivato con il numero di bit = 0.
Valore di ritorno
Output dello schema di codifica a bit elaborato della variabile val.
Trattamento degli errori
Se nel parametro bitNr viene impostato un valore non ammesso, il sistema emette un errore.
Esempio:
// impostazione della variabile su 0
mask := 16#0000
// impostazione del terzo bit su TRUE
mask := SetBit(mask, 2)
// mask ha il valore 2#0000 0100
18. Funzioni
Festo GDCP-CMXR-SW-IT it Version 1.0 167
18.21 Cancellazione del bit in una variabile WORD <ResetBit>
La funzione ResetBit consente di impostare un bit selezionato sul valore FALSE in una variabile DWORD. Se il bit è già settato su FALSE, questa funzione non ha alcun effetto. Il valore modificato è disponibile nel valore di ritorno per l'ulteriore lavorazione.
Sintassi
ResetBit ( <val> : DWORD, <bitNr> : DINT): DWORD
Metodo Descrizione
val Valore da modificare
bitNr Numero del bit che verrà resettato nel parametro Val
Tabella 18.6 Variabili della funzione ResetBit
Il numero di bit viene specificato mediante il parametro bitNr. L'intervallo di valori ammissibile per referenziare i bit della variabile WORD (32 bit) è compreso tra 0 e 31. Il bit di ordine più basso (LSB) viene attivato con il numero di bit = 0.
Valore di ritorno
Output dello schema di codifica a bit elaborato della variabile val.
Trattamento degli errori
Se nel parametro bitNr viene impostato un valore non ammesso, il sistema emette un errore.
Esempio:
// impostazione della variabile su 2#0000 1111
mask := 16#000F
// impostazione del primo bit su FALSE
mask := ResetBit(mask, 0)
// mask ha il valore 2#0000 1110
18. Funzioni
168 Festo GDCP-CMXR-SW-IT it Version 1.0
18.22 Controllo del bit in una variabile WORD <CheckBit>
La funzione CheckBit consente di controllare il bit specificato nel numero di bit e resti-tuisce il risultato come valore di ritorno.
Sintassi
CheckBit ( <val> : DWORD, <bitNr> : DINT): BOOL
Metodo Descrizione
val Valore da controllare
bitNr Numero di bit che verrà controllato nel parametro Val
Tabella 18.7 Variabili della funzione CheckBit
Il numero di bit viene specificato mediante il parametro bitNr. L'intervallo di valori
ammissibile per referenziare i bit della variabile WORD (32 bit) è compreso tra 0 e 31. Il bit di ordine più basso (LSB) viene attivato con il numero di bit = 0.
Valore di ritorno
TRUE Il bit è impostato.
FALSE Il bit non è impostato.
Trattamento degli errori
Se nel parametro bitNr viene impostato un valore non ammesso, il sistema emette un errore.
Esempio
IF CheckBit(mask, 1) THEN
// Stato TRUE
SetInfo(“Bit 1 è impostato")
ELSE
// Stato FALSE
SetInfo(“Bit 1 non è impostato")
END_IF
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 169
19. 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
19. Moduli
170 Festo GDCP-CMXR-SW-IT it Version 1.0
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.
19.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.
19.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 esecu-zione 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
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 171
Raccomandazione:
Quando possibile è preferibile utilizzare l'accesso mediante una variabile, che richiede un minor tempo di esecuzione.
19.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 applicazioni. 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.
19.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.
19. Moduli
172 Festo GDCP-CMXR-SW-IT it Version 1.0
19.4 Modulo di ingresso digitale DIN
Il modulo DIN serve per l'interrogazione e la gestione di un ingresso digitale.
19.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,
<Input> : MAPTO DINPORT)
È 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, MAP(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.
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 173
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 19.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 24.2 Utilizzo dei moduli di ingresso e di uscita.
19. Moduli
174 Festo GDCP-CMXR-SW-IT it Version 1.0
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.
19.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 19.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.
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 175
19.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 19.3.1 a pagina 170.
Esempio:
Ptp(pos0)
sensor.Wait() // attesa del segnale TRUE, movimento
arrestato
Ptp(pos1)
sensor.WaitN(TRUE) // attesa del segnale FALSE, nessun arresto
Ptp(pos2)
19.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 19.3.1 a pagina 170.
Esempio:
value := sensor.Read()
19.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 indi-pendentemente dal ciclo del programma FTL e si svolge in un ciclo proprio.
19. Moduli
176 Festo GDCP-CMXR-SW-IT it Version 1.0
Sintassi
<nome istanza>.RisingEdge (OPT ovlEnable: BOOL) : BOOL
Per la descrizione del parametro ovlEnable vedi capitolo 19.3.1 a pagina 170.
Esempio:
value := sensor.RisingEdge()
19.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()
19.5 Modulo di uscita digitale DOUT
Il modulo DOUT serve per l'interrogazione e la gestione di un'uscita digitale.
19.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 istanzia-zione.
Sintassi
<nome istanza> .DOUT( <Timeout> : DINT,
<RisingEdge> : BOOL,
<Output> : MAPTO DOUTPORT)
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 177
È 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, MAP(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.
19. Moduli
178 Festo GDCP-CMXR-SW-IT it Version 1.0
19.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 19.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 24.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.
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 179
19.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 19.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.
19. Moduli
180 Festo GDCP-CMXR-SW-IT it Version 1.0
19.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 19.3.1 a pagina 170.
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)
19.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 19.3.1 a pagina 170.
Esempio:
value := cylinder.Read()
19.5.6 Fronte ascendente, metodo RisingEdge
Con il metodo RisingEdge si può controllare se sull'uscita si è verificato un fronte
ascendente 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 indipen-dentemente dal ciclo del programma FTL e si svolge in un ciclo proprio.
Sintassi
<nome istanza>.RisingEdge (OPT ovlEnable: BOOL) : BOOL
Per la descrizione del parametro ovlEnable vedi capitolo 19.3.1 a pagina 170.
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 181
Esempio:
value := cylinder.RisingEdge()
19.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()
19.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)
cylinder.Set() // impostazione dell'uscita cylinder su
TRUE
Lin(pos3)
cylinder.Reset() // impostazione dell'uscita cylinder su
FALSE
Lin(pos4)
19. Moduli
182 Festo GDCP-CMXR-SW-IT it Version 1.0
19.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 fun-
zione 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
19.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'esecu-zione 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 19.5 Parametri del metodo Pulse
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.
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 183
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 speci-ficato, 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)
19.6 Modulo di ingresso analogico AIN
Il modulo AIN serve per l'interrogazione e la gestione di un ingresso analogico.
19.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 istan-ziazione.
Sintassi
<nome istanza> .AIN( <Timeout> : DINT, <port> : MAPTO AINPORT)
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:
19. Moduli
184 Festo GDCP-CMXR-SW-IT it Version 1.0
Istanziazione nel file di dati
temperature : AIN := (-1, MAP(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.
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 185
19.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 19.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 24.2 Utilizzo dei moduli di ingresso e di uscita.
Input
La variabile Input descrive il rimando all'ingresso hardware del modulo.
19.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 19.7 Metodi del modulo di ingresso analogico
19. Moduli
186 Festo GDCP-CMXR-SW-IT it Version 1.0
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.
19.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 19.3.1 a pagina 170.
Parametro Tipo Significato
value REAL Valore limite
Tabella 19.8 Parametri dei metodi WaitLss, WaitGrt
Esempio:
Lin(pos1)
temperature.WaitLss(65.0, TRUE)
Lin(pos2)
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 187
19.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 19.3.1 a pagina 170.
Parametro Tipo Significato
minValue REAL Valore limite inferiore
maxValue REAL Valore limite superiore
Tabella 19.9 Parametri dei metodi WaitIns, WaitOuts
Esempio
Lin(pos1)
// in attesa finché la temperatura non si trova entro i limiti
temperature.WaitIns(50.0, 55.0, TRUE)
Lin(pos2)
19.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 19.3.1 a pagina 170.
19. Moduli
188 Festo GDCP-CMXR-SW-IT it Version 1.0
Esempio
Lin(pos1)
// lettura della temperatura senza arresto sulla traiettoria
value := temperature.Read(TRUE)
Lin(pos2)
19.7 Modulo di uscita analogico AOUT
Il modulo AOUT serve per l'interrogazione e la gestione di un'uscita analogica.
19.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,
<port> : MAPTO AOUTPORT))
È 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, MAP(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.
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 189
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.
19.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 19.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 24.2 Utilizzo dei moduli di ingresso e di uscita.
19. Moduli
190 Festo GDCP-CMXR-SW-IT it Version 1.0
Output
La variabile Output descrive il rimando all'uscita hardware del modulo.
19.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 19.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.
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 191
19.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 19.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
19.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 19.3.1 a pagina 170.
Parametro Tipo Significato
value REAL Valore limite
Tabella 19.13 Parametri dei metodi WaitLss, WaitGrt
Esempio:
Lin(pos1)
// in attesa finché non è inferiore a 110.0
quantity.WaitLss(110.0, TRUE)
Lin(pos2)
19. Moduli
192 Festo GDCP-CMXR-SW-IT it Version 1.0
19.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 19.3.1 a pagina 170.
Parametro Tipo Significato
minValue REAL Valore limite inferiore
maxValue REAL Valore limite superiore
Tabella 19.14 Parametri dei metodi WaitIns, WaitOuts
Esempio
Lin(pos1)
// in attesa finché la qualità non rientra nei limiti
quantity.WaitIns(100.0, 110.0, TRUE)
Lin(pos2)
19.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 19.3.1 a pagina 170.
Esempio
Lin(pos1)
// lettura della quantità senza arresto sulla traiettoria
value := quantity.Read(TRUE)
Lin(pos2)
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 193
19.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.
19.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.
19. Moduli
194 Festo GDCP-CMXR-SW-IT it Version 1.0
Con l'istanziazione sull'unità di comando manuale, la registrazione viene automatica-
mente scritta nel file di dati.
19.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 19.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.
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 195
19.8.3 Avvio dell'orologio, metodo Start
Con il metodo Start viene avviato il timer. Il momento di avvio viene memorizzato
internamente nel modulo. Se l'avvio viene impartito su un timer già arrestato, il timer arrestato viene riattivato e il tempo riprende a scorrere. Il timer può essere riavviato solo con l'istruzione Reset.
Sintassi
<nome istanza>.Start ( )
Esempio:
Timer.Start() // l'orologio viene avviato
19.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
19.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
19.8.6 Lettura dell'orologio, metodo Read
Con il metodo Read si può leggere il valore di tempo attuale in millisecondi (msec).
19. Moduli
196 Festo GDCP-CMXR-SW-IT it Version 1.0
Sintassi
<nome istanza>.Read(OPT ovlEnable : BOOL) : DINT
Per la descrizione del parametro ovlEnable vedi capitolo 19.3.1 a pagina 170.
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)
:
19.8.7 Conversione del valore di tempo in una stringa, metodo ToStr
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 19.3.1 a pagina 170.
Valore di ritorno: stringa con l'informazione di tempo formattata gg hh:mm:ss:ms.
Esempio:
Dati:
time : STRING
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 197
Programma:
Lin(pos1)
time := Timer.ToStr() // lettura con arresto sulla
traiettoria
Lin(pos2)
time := Timer.ToStr(TRUE) // lettura nell'elaborazione
principale dei record
Lin(pos3)
19.9 Modulo encoder ENCODER
Il modulo encoder può essere utilizzato nel programma per leggere gli encoder incre-mentali collegati, che possono essere al massimo due.
19.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,
<port> : MAPTO ENCPORT))
È 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, MAP(Encoder_0))
19. Moduli
198 Festo GDCP-CMXR-SW-IT it Version 1.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.
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.
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 199
19.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 19.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.
19.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 19.17 Metodi del modulo encoder
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.
19.9.4 Impostazione dell'encoder, metodo Set
Con il metodo Set si può attivare un valore dell'encoder incrementale dal programma
utente.
19. Moduli
200 Festo GDCP-CMXR-SW-IT it Version 1.0
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 19.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 19.19 Modalità del metodo Set
Esempio:
enc0.Set(1000, DIRECT)
19.9.5 Lettura dell'encoder, metodo Read
Con il metodo Read si può leggere il valore corrente dell'encoder incrementale dal pro-
gramma utente.
Sintassi:
<ENCODER>.Read ( OPT <ovlEnable> : BOOL) : DINT
Parametro Tipo Significato
ovlEnable BOOL Parametro per l'impostazione del momento di lettura
Tabella 19.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.
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 201
Esempio di lettura del valore normale:
value := enc0.port.value
Esempio di lettura del valore incrementale:
value := enc0.Read()
19.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 comporta-mento 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.
19.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 attua-tori 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
19. Moduli
202 Festo GDCP-CMXR-SW-IT it Version 1.0
Codice del programma:
Axis1_copd.WriteSDO(16#6060,0,7,eight_bits)
19.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 19.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”.
La figura mostra le selezione dei metodi del modulo CANopen sull'unità di comando
manuale.
19.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
19. Moduli
Festo GDCP-CMXR-SW-IT it Version 1.0 203
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 19.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)
19.10.4 Lettura di SDO, metodo ReadSDOSigned
Con il metodo ReadSDOSigned è possibile leggere pacchetti di dati con segno matematico
dal bus CAN.
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 19.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)
:
19. Moduli
204 Festo GDCP-CMXR-SW-IT it Version 1.0
19.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 19.24 Parametri del metodo ReadSDOUnsigned
Se la lettura del pacchetto ha esito positivo viene restituito TRUE, altrimenti FALSE.
20. Segnali delle periferiche
Festo GDCP-CMXR-SW-IT it Version 1.0 205
20. Segnali delle periferiche
20.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.
20.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.
20. Segnali delle periferiche
206 Festo GDCP-CMXR-SW-IT it Version 1.0
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.
21. Programmazione di eventi
Festo GDCP-CMXR-SW-IT it Version 1.0 207
21. Programmazione di eventi Il linguaggio FTL offre la possibilità di reagire a determinati eventi, come ad es. l'avvio e l'arresto di un programma. In questo caso, al verificarsi di un evento specificato viene avviato ed elaborato un programma con un nome prestabilito.
Nota
Il tempo di latenza per l'avvio dei programmi associati agli eventi è di circa 5 - 20 msec e non è di tipo deterministico. Ulteriori eventi possono essere programmati nel PLC integrato.
Tutti i programmi associati agli eventi devono essere memorizzati nel progetto globale “GLOBAL”. Non devono essere “caricati” e hanno nomi prestabiliti.
21.1 Eventi supportati
La seguente tabella mostra una panoramica degli eventi possibili:
Nome evento = nome programma Esecuzione del programma associato all'evento
onstartup Una volta dopo l'avviamento a regime del sistema di comando
onprogstart Avvio del programma
onproginterrupt Interruzione del programma attivo
onprogcontinue Proseguimento del programma interrotto
onprogend Fine del programma
onf1keypressed Tasto F1 dell'unità di comando manuale CDSA premuto
onf1keyreleased Tasto F1 dell'unità di comando manuale CDSA rilasciato
onf2keypressed Tasto F2 dell'unità di comando manuale CDSA premuto
onf2keyreleased Tasto F2 dell'unità di comando manuale CDSA rilasciato
Tabella 21.1 Panoramica degli eventi FTL
I nomi degli eventi/programmi indicati nella tabella devono essere tassativamente rispettati.
Nella figura seguente sono impostati i 3 eventi
- onkeyf1pressed,
- onprogstart,
- onstartup
nel progetto “GLOBAL”. Il sistema può reagire solo a questi eventi.
21. Programmazione di eventi
208 Festo GDCP-CMXR-SW-IT it Version 1.0
Attenzione
Se non si rispettano le convenzioni relative ai nomi, i programmi associati agli eventi non possono essere eseguiti. Inoltre non può essere emessa alcuna segnalazione diagnostica. In questo caso gli eventi devono essere testati separatamente ad ogni messa in servizio.
Nota
Per ragioni dipendenti dal sistema di file del CMXR, i nomi dei programmi vengono sempre scritti in minuscolo.
Nota
L'attivazione di un errore durante l'esecuzione di un programma associato agli eventi provoca l'arresto e l'annullamento di tale programma. Il programma non può essere eseguito di nuovo.
Nota
Anche le variabili utilizzate nei programmi associati agli eventi devono essere dichiarate nel progetto globale “GLOBAL”. È inoltre consentito l'uso di variabili di sistema adeguate.
21.2 Utilizzo del set di istruzioni FTL
All'interno dei programmi associati agli eventi è possibile utilizzare una quantità limitata di istruzioni FTL. Non sono espressamente ammesse le seguenti istruzioni:
- comandi di traslazione, ad es. Ptp, Lin,
- istruzioni che possono influenzare i comandi di traslazione, ad es. Tool, SetRefSys,
- istruzioni che possono influenzare i dati della cinematica, ad es. Vel, Acc,
- cicli di istruzioni infiniti,
21. Programmazione di eventi
Festo GDCP-CMXR-SW-IT it Version 1.0 209
- sottoprogrammi e programmi paralleli.
Attenzione
All'interno dei programmi associati agli eventi non sono ammessi comandi di traslazione e altre istruzioni in grado di influenzare i comandi di traslazione o i dati della cinematica. Se si utilizzano istruzioni non consentite viene emesso un errore corrispondente e l'evento viene interrotto.
21.3 Controllo dei tempi
In tutti i programmi associati agli eventi viene controllato il tempo di esecuzione. Al superamento di un tempo preimpostato di 1 secondo viene emesso un errore e il programma associato all'evento attivo viene interrotto.
21.4 Evento: avviamento a regime del sistema di comando <onstartup>
Dopo l'avviamento a regime del controller multiassiale CMXR viene eseguito una volta il programma associato all'evento “onstartup”. Una possibile applicazione per questo
evento è ad es. il caricamento automatico di un programma FTL.
Esempio
:
// caricamento del programma main dal progetto sorting
LoadProgram(“sorting”, “main")
:
21.5 Eventi del comando a programma
Mediante gli “eventi dei programmi” è possibile ad es. reagire all'avvio e all'arresto dei programmi FTL. Un caso di applicazione è ad es. la chiusura/apertura di un applicatore in caso di arresto e riavvio di un programma. Nella tabella seguente sono elencati tutti gli eventi disponibili per il comando a programma.
21. Programmazione di eventi
210 Festo GDCP-CMXR-SW-IT it Version 1.0
Nome dell'evento Frequenza di richiamo
Richiamo dell'evento in caso di
onprogstart una volta Al avvio del programma FTL.
onproginterrupt all'occorrenza All'arresto del programma FTL, ad es. tramite il tasto di arresto
sull'unità di comando manuale.
onprogcontinue all'occorrenza Al riavvio di un programma arrestato.
onprogend una volta Quando il programma viene terminato.
Tabella 21.2 Panoramica degli eventi del comando a programma
21.5.1 Comportamento di esecuzione durante l'esercizio
I diversi eventi comportano tempi di reazione corrispondentemente diversi nel programma FTL e nei relativi programmi associati agli eventi. La figura seguente mostra l'elaborazione temporale dei singoli eventi dei programmi:
Se dopo un'interruzione del programma la cinematica è stata traslata ad es. nell'esercizio manuale, prima dell'evento “onprogcontinue” viene eseguita la procedura di riposizio-namento sulla traiettoria.
Attenzione
I programmi associati agli eventi “onproginterrupt” e “onprogend” vengono eseguiti solo al raggiungimento degli stati programma, che comprendono anche l'arresto degli assi. Gli eventi “onprogstart” e “onprogcontinue” vengono richiamati prima dell'esecuzione del programma.
Quando si utilizzano questi eventi occorre quindi rispettare sempre questa sequenza temporale prestabilita.
Start del programma
onprogstart
onproginterrupt
onprogcontinue
onprogend
Stop del programma,
gli assi rallentano Nuovo start del
programma
Fine del programma
Programma Programma Tempo
Eventuale riposiziona-mento del robot sulla traiettoria
21. Programmazione di eventi
Festo GDCP-CMXR-SW-IT it Version 1.0 211
21.5.2 Sovrapposizione di eventi di programmi
La sovrapposizione di eventi dei programmi, ovvero la possibilità che un evento si verifichi prima che il programma associato all'evento attuale venga terminato, è disabilitata. Gli eventi avviati vengono sempre terminati prima che venga attivato un altro evento.
Attenzione
Per evitare di bloccare l'esecuzione di eventuali eventi successivi per ragioni di tempo, in un programma associato agli eventi è consentito programmare solo quanto strettamente necessario.
La grafica seguente mostra uno start del programma mentre l'evento di programma “onproginterrupt” è ancora attivo:
Lo start successivo del programma viene ritardato finché l'evento di programma “onproginterrupt” non è completamente elaborato.
21.5.3 Impiego di progetti/programmi diversi
Anche durante il funzionamento di progetti e programmi diversi vengono richiamati gli stessi programmi associati agli eventi. Se si desidera che le istruzioni all'interno del programma associato a un evento siano dipendenti da un programma avviato, è neces-sario programmare tale condizione esplicitamente. Ciò può essere impostato utilizzando le variabili globali.
Start del programma
onprogstart
onproginterrupt
onprogcontinue
onprogend
Stop del programma,
gli assi rallentano
Nuovo start del
programma
Fine del programma
Programma Programma Tempo
Spostamento
temporale dello start
21. Programmazione di eventi
212 Festo GDCP-CMXR-SW-IT it Version 1.0
Nota
Se vengono avviati diversi programmi, osservare assolutamente la sequenza sopra descritta per l'esecuzione dei programmi associati agli eventi e dei normali programmi generanti!
Programma “onprogstart”
// impostazione della variabile per l'identificativo su 0
ProgCode := 0
:
Programma FTL Handling
// impostazione della variabile per l'identificativo su 1
ProgCode := 1
:
21. Programmazione di eventi
Festo GDCP-CMXR-SW-IT it Version 1.0 213
Programma FTL Feeding
// impostazione della variabile per l'identificativo su 2
ProgCode := 2
:
Programmi “onproginterrupt”, “onprogcontinue” o “onprogend”
// controllo dell'identificativo del programma
IF(ProgCode = 1) THEN
// programma Handling
:
ELSIF(ProgCode = 2) THEN
// programma Feeding
:
END_IF
21.5.4 Esempio: comando di un applicatore durante l'incollatura
In un programma FTL, un applicatore di strisce di colla viene attivato e disattivato a seconda dei casi. Per chiudere l'applicatore in caso di arresto di un programma e riaprirlo quando viene riavviato il programma, è possibile utilizzare le funzioni di evento.
In tal caso l'applicatore viene comandato da un'uscita digitale, attivata a sua volta tramite il modulo Glue istanziato.
Se il programma FTL viene arrestato, nell'evento “onproginterrupt” viene memorizzato lo stato attuale dell'uscita digitale nella variabile GlueOpened e l'applicatore viene chiuso.
Programma “onproginterrupt”
// memorizzazione dello stato dell'applicazione
GlueOpened := Glue.State
// chiusura dell'applicatore
Glue.Reset()
Al riavvio del programma FTL arrestato viene eseguito il programma associato all'evento “onprogcontinue”. Qui viene verificato lo stato della variabile GlueOpened ed eventualmente viene riaperto l'applicatore.
21. Programmazione di eventi
214 Festo GDCP-CMXR-SW-IT it Version 1.0
Programma “onprogcontinue”
// verifica se l'applicatore era aperto
IF(GlueOpened)THEN
// apertura dell'applicatore
Glue.Set()
END_IF
// cancellazione della variabile per la memorizzazione dello
stato
GlueWasOpen := FALSE
Per motivi di sicurezza è possibile chiudere l'applicatore con l'evento “onprogend”.
Programma “onprogend”
// chiusura dell'applicatore
Glue.Reset()
// cancellazione della variabile per la memorizzazione dello
stato
GlueWasOpen := FALSE
Attenzione
L'attivazione e la disattivazione dell'applicatore non avvengono in sincrono al movimento di traiettoria. Sul punto di interruzione possono quindi verificarsi perdite di qualità sotto forma ad es. di rivestimenti di spessore eccessivo o insufficiente.
21.6 Eventi per i tasti F1 e F2
L'unità di comando manuale CDSA dispone di 2 tasti di funzione, denominati F1 e F2, che si trovano sul lato sinistro della barra di tasti di funzione inferiore.
Con l'ausilio degli eventi di programma
- onf1keypressed,
- onf1keyreleased,
- onf2keypressed,
- onf2keyreleased
è possibile utilizzare questi due tasti nell'applicazione.
21. Programmazione di eventi
Festo GDCP-CMXR-SW-IT it Version 1.0 215
Una possibile applicazione per questi tasti potrebbe essere l'apertura e la chiusura di una pinza in esercizio manuale.
Esempio:
In esercizio manuale, premendo il tasto F1 viene aperta una pinza e, premendo di nuovo il tasto, la pinza viene chiusa. Poiché la pinza viene utilizzata anche in un programma FTL, il suo stato deve essere tenuto in considerazione in caso di stop del programma. Inoltre, quando si riavvia il programma occorre ripristinare lo stato della pinza.
Interruzione del programma
In caso di interruzione del programma lo stato della pinza viene memorizzato in una variabile, in modo da poter ripristinare lo stato della pinza al riavvio del programma.
Programma “onproginterrupt”
// memorizzazione dello stato della pinza
GripperOpen := OpenGripper.State
Al proseguimento del programma (nuova istruzione di start) la pinza viene riportata nello stato in cui si trovava al momento dell'interruzione del programma.
Programma “onprogcontinue”
// verifica se la pinza era aperta
IF(GripperOpen)THEN
// apertura pinza
OpenGripper.Set()
ELSE
// chiusura pinza
OpenGripper.Reset()
END_IF
Tasti F1 e F2
21. Programmazione di eventi
216 Festo GDCP-CMXR-SW-IT it Version 1.0
In esercizio manuale la pinza viene alternativamente aperta o chiusa premendo il tasto F1. A tale scopo occorre rilevare il modo operativo attivo mediante l'istruzione GetManualModeActive.
Programma “onf1keypressed”
// verifica se è impostato il modo operativo manuale
IF(GetManualModeActive())THEN
// verifica se la pinza è aperta
IF(OpenGripper.State)THEN
// chiusura pinza
OpenGripper.Reset()
ELSE
// apertura pinza
OpenGripper.Set()
END_IF
END_IF
21.7 Istruzioni FTL specifiche per applicazioni con eventi
Le seguenti istruzioni sono riservate all'impiego in combinazione con gli eventi.
21.7.1 Rilevamento del modo operativo attivo, <GetAutoModeActive, GetManualModeActive>
Con questa istruzione è possibile verificare se è attivo il modo operativo manuale o
automatico.
Sintassi
GetAutoModeActive( ): BOOL
GetManualModeActive( ): BOOL
21. Programmazione di eventi
Festo GDCP-CMXR-SW-IT it Version 1.0 217
Valori di ritorno:
FALSE Modo operativo non attivo
TRUE Modo operativo attivo
21.7.2 Caricamento di un programma FTL, <LoadProgram>
Con l'istruzione “LoadProgram” è possibile caricare un programma FTL dalla scheda di
memoria alla memoria di lavoro, dove rimane pronto per l'esecuzione. Con l'esecuzione del programma vengono terminati e scaricati dalla memoria tutti gli altri programmi già caricati. Il programma associato all'evento non viene terminato, bensì eseguito fino alla fine.
Sintassi
LoadProgram ( <project>:STRING, <program>:STRING):BOOL
Metodo Descrizione
project Nome del progetto dal quale deriva il programma
program Nome del programma che viene caricato.
Tabella 21.3 Istruzione “LoadProgram”
Richiamo da un programma in esecuzione
Valore di ritorno
TRUE Il programma è stato caricato
FALSE Non è stato possibile caricare il programma
Trattamento degli errori
Se non è stato possibile caricare il programma a causa di un errore, ad es. perché non è presente, viene generato ed emesso un messaggio corrispondente.
Attenzione
Se l'istruzione “LoadProgram” viene eseguita all'esterno di un programma associato a un evento, il programma viene arrestato e scaricato dalla memoria. Tutte le righe di programma successive non vengono quindi eseguite.
21. Programmazione di eventi
218 Festo GDCP-CMXR-SW-IT it Version 1.0
21.8 Testi di messaggio dei programmi associati agli eventi
Tutti i messaggi relativi ai programmi associati agli eventi fanno parte del componente 50. Possono essere emessi i seguenti messaggi:
Nota
La categoria di messaggi “Errore” provoca sempre un arresto di tutti i programmi FTL, con un conseguente arresto degli assi della cinematica.
Numero di messaggio 1260
Categoria di messaggio Errore
Testo del messaggio Progetto non valido per l'istruzione 'LoadProgram'. <Nome
progetto/programma con numero di riga>
Effetto L'istruzione LoadProgram non può essere eseguita.
Causa Il progetto indicato nell'istruzione 'LoadProgram' non esiste o non è valido.
Misura Controllare i parametri della macro LoadProgram, rendere disponibile il
progetto/programma sulla scheda Compact Flash, verificare che il
programma non contenga errori.
Numero di messaggio 1261
Categoria di messaggio Errore
Testo del messaggio Programma non valido per l'istruzione 'LoadProgram'. <Nome
progetto/programma con numero di riga>
Effetto L'istruzione 'LoadProgram' non può essere eseguita.
Causa Il programma indicato nell'istruzione 'LoadProgram' non esiste o non è
valido.
Misura Controllare i parametri della macro LoadProgram, rendere disponibile
il progetto/programma sulla scheda Compact Flash, verificare che
il programma non contenga errori.
Numero di messaggio 1262
Categoria di messaggio Errore
Testo del messaggio Istruzione robot nell'evento: <nome evento> non è ammesso. <Nome
progetto/programma con numero di riga>
Effetto L'evento di programma viene interrotto.
Causa Nei programmi associati agli eventi non è consentito utilizzare istruzioni che
possono influire sulla cinematica, come ad es. comandi di traslazione, o dati
dinamici.
Misura Eliminare le istruzioni non consentite dal programma associato all'evento.
21. Programmazione di eventi
Festo GDCP-CMXR-SW-IT it Version 1.0 219
Numero di messaggio 1263
Categoria di messaggio Errore
Testo del messaggio Evento: <nome dell'evento> ha superato il timeout di: <valore di tempo> msec.
Effetto L'evento di programma viene interrotto.
Causa L'evento richiede troppo tempo. È stato programmato un numero forse
eccessivo di istruzioni, un'istruzione di attesa (WaitTime) o un ciclo di
istruzioni infinito.
Misura Controllare il programma, eliminare le istruzioni non ammesse.
22. Punti di commutazione semplici
220 Festo GDCP-CMXR-SW-IT it Version 1.0
22. Punti di commutazione semplici I punti di commutazione sono posizioni, su un percorso di movimento o su una posizione stessa, in corrispondenza dei quali viene eseguita un'azione. Queste azioni vengono eseguite in funzione della traiettoria del movimento. Possibili casi d'applicazione potrebbero essere ad es.:
- apertura e chiusura di un applicatore, ad es. per l'incollatura o il rivestimento
- modifica della portata di un fluido alimentato, ad es. il materiale di tenuta
- comando di sensori intelligenti, ad es. di un sistema di visione
22.1 Punto di commutazione semplice con comando di traslazione, <DO>
Un punto di commutazione semplice può essere creato tramite l'istruzione DO (vedi cap. 8.10 Istruzione DO) in abbinamento a un comando di traslazione. Prima dell'istruzione DO
viene impostato un comando di traslazione. Si possono utilizzare tutti i comandi di traslazione quali movimenti PTP o cartesiani, sia lineari che circolari.
Sintassi
<comando di traslazione> < istruzione > DO
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. Ciò significa che il comportamento di commuta-zione riferito alla traiettoria può cambiare in caso di modifica della dinamica della traiettoria. L'istruzione viene eseguita incondizionatamente.
Esempio
Sul contorno seguente si vuole attivare un'uscita digitale sui percorsi diritti e disattivarla negli archi di cerchio.
Pos2 Pos1
Pos3 Pos4
Ipos1
Ipos2
22. Punti di commutazione semplici
Festo GDCP-CMXR-SW-IT it Version 1.0 221
:
Lin(Pos1) DO Applicator.Set()
Lin(Pos2) DO Applicator.Reset()
CircIp(Ipos1,Pos3) DO Applicator.Set()
Lin(Pos4) DO Applicator.Reset()
CircIp(Ipos2,Pos1)
:
22.2 Punto di commutazione semplice, <OnPosition>
Oltre all'istruzione DO, anche la macro OnPosition può essere utilizzata per programmare un'azione di commutazione semplificata. In questo caso però non avviene alcuna con-nessione logica con un comando di traslazione. La macro OnPosition attende finché non viene raggiunta l'ultima posizione programmata, dopodiché esegue l'istruzione DO.
Sintassi
OnPosition() < istruzione > DO
Esempio:
Nell'esempio seguente viene richiamato un sottoprogramma che contiene comandi di traslazione. Una volta raggiunta l'ultima posizione, la macro OnPosition esegue l'istru-zione DO e imposta la variabile SequenceReady su TRUE.
:
Lin(Pos1)
Lin(Pos2)
CALL Sort
OnPosition() DO SequenceReady := TRUE
Lin(Home) DO Applicator.Reset()
:
22.3 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 il punto di commutazione viene proiettato ed
eseguito sulla traiettoria dell'area di approssimazione. Ne possono risultare imprecisioni la cui entità non è nota e deve essere rilevata attraverso una messa in servizio.
22. Punti di commutazione semplici
222 Festo GDCP-CMXR-SW-IT it Version 1.0
1
1 P1
1
1 P1´ 1
1 P2
1
1 P0
L'istruzione DO viene eseguita qui.
Nota
Se i segmenti di movimento convergono tangenzialmente, l'approssimazione non ha alcun effetto sull'esecuzione dell'istruzione DO.
22.4 Comportamento di esecuzione dell'istruzione DO
Quando si utilizza l'istruzione DO occorre tener presente che essa rappresenta una sorta di sequenza parallela. Di conseguenza va persa la linearità propria del programma FTL, in base al quale esso viene eseguito dall'alto verso il basso. Utilizzando l'istruzione DO occorre inoltre ricordare che i programmi FTL vengono sempre calcolati preliminarmente.
L'esempio seguente mostra un'esecuzione del programma che non genera l'evento desiderato:
:
Started := FALSE
Lin(Home)
Lin(Pos2) DO Started := TRUE
IF Started THEN
:
ELSE
:
END_IF
:
A causa del calcolo preliminare del programma FTL, l'istruzione IF viene sempre eseguita nella diramazione ELSE.
23. Punti di commutazione traiettoria
Festo GDCP-CMXR-SW-IT it Version 1.0 223
23. Punti di commutazione traiettoria I punti di commutazione traiettoria vengono calcolati sulla traiettoria descritta. In questo caso può trattarsi di movimenti PTP, lineari e/o circolari. Per la programmazione dei punti di commutazione traiettoria viene utilizzata la rispettiva macro insieme all'istruzione DO.
Sintassi
< macro del punto di commutazione > < istruzione > DO
Una riga di programma può contenere una sola istruzione DO, che può essere seguita al
massimo da un'istruzione.
I punti di commutazione traiettoria sono disponibili in varie esecuzioni, dai semplici procedimenti di commutazione fino alla compensazione dei tempi di commutazione. Queste varianti sono descritte nelle pagine seguenti.
Attenzione
I punti di commutazione traiettoria vengono calcolati mediante il calcolo preliminare del programma. Per garantirne un'esecuzione corretta è sempre necessario un override del 100% (vedi cap. 23.7.4 Influsso dell'override). Una modifica dell'override provoca un'esecuzione errata.
23.1 Segmento di traiettoria
Viene definito segmento di traiettoria il tratto compreso tra un punto di partenza e un punto di arrivo. Su un segmento di traiettoria vengono eseguiti i punti di commutazione traiettoria. Per l'esecuzione esistono diversi tipi di segmenti, che sono descritti nelle pagine seguenti. A seconda del tipo di esecuzione, i punti di commutazione traiettoria possono essere spostati su questo segmento in base a una posizione o ad un tempo.
Nella grafica seguente è riportata la definizione del segmento:
P1
P2
P3 Segmento di traiettoria
tra P1 e P2
Fine segmento
Inizio segmento
Punto di commutazione
23. Punti di commutazione traiettoria
224 Festo GDCP-CMXR-SW-IT it Version 1.0
Nota
Per ogni segmento di traiettoria si possono programmare al massimo 8 punti di commutazione. Superando questo limite viene emesso un messaggio di errore e il programma viene arrestato.
23.2 Comportamento nell'area di approssimazione
A causa di parametri quali valori di raccordo, offset di posizione o offset di tempo del punto di commutazione, un punto di commutazione non può trovarsi nell'area di approssimazione. La calcolazione del punto di commutazione avviene sui segmenti di
traiettoria, che sono stati calcolati senza approssimazione. Nell'area di approssimazione questo punto viene proiettato sulla curva della traiettoria dell'area di approssimazione. In base alle dimensioni dell'area di approssimazione possono verificarsi imprecisioni dei valori programmati.
Nota
Se queste imprecisioni nell'area di approssimazione sono inaccettabili, assicurarsi che siano presenti punti di commutazione all'esterno di questa area. Ciò può essere ottenuto ad es. inse-rendo segmenti circolari che convergono tangenzialmente.
P2
P1
P3
Punto di commutazione
programmato, spostato da P2
Punto di
commutazione
proiettato ed eseguito
23. Punti di commutazione traiettoria
Festo GDCP-CMXR-SW-IT it Version 1.0 225
1
1 P1
1
1 P2
1
1 P0
1
1 0% 1
1 70% 1
1 100%
L'istruzione DO viene eseguita qui.
23.3 Punto di commutazione con scostamento percentuale, <OnParameter>
Con la macro del punto di commutazione OnParameter è possibile spostare il punto di commutazione in percentuale sul segmento di traiettoria successivo. La posizione del punto di commutazione viene calcolata in base alla lunghezza del segmento, risultante dai punti programmati, e al valore percentuale specificato.
Sintassi
OnParameter( <percent> : REAL
OPT <timeMs> : DINT) < istruzione > DO
Parametro Significato Unità
percent Valore percentuale per il calcolo del punto
di commutazione.
Percentuale
0..100%
timeMs Scostamento temporale del punto di
commutazione
msec
Tabella 23.1 Parametri dell'istruzione OnParameter
L'istruzione OnParameter può essere applicata a movimenti PTP e cartesiani e a tutte le istruzioni con modifica dell'orientamento. La programmazione di OnParameter avviene sempre fra 2 comandi di traslazione che descrivono il segmento di traiettoria.
Oltre che con lo scostamento percentuale, il punto di commutazione può essere spostato anche con un offset di tempo. L'effetto dell'offset tempo (parametro timeMs) viene trattato nel capitolo 23.6 Offset di tempo opzionale a pagina 231.
Esempio:
Viene percorsa una traiettoria e, dopo un tratto pari al 70% della lunghezza del segmento, tra le posizioni P0 e P1 deve essere aperta una pinza.
:
Lin(P0)
OnParam(70) DO Gripper.Set()
Lin(P1)
:
23. Punti di commutazione traiettoria
226 Festo GDCP-CMXR-SW-IT it Version 1.0
23.4 Punto di commutazione qualsiasi sulla traiettoria, <OnDistance>
Con la macro del punto di commutazione OnDistance è possibile definire un punto di com-mutazione che si trova nel segmento di traiettoria successivo. Questo punto di commutazione può essere spostato con un offset riferito all'inizio o alla fine del segmento. In alternativa è anche possibile specificare un valore di tempo per eseguire uno spostamento temporale del punto di commutazione, ad es. per la compensazione dei tempi di commutazione.
Sintassi
OnDistance( <type> : DISTANCETYPE,
<offset> : REAL,
OPT <timeMs> : DINT ) DO < istruzione >
Parametro Significato Unità
type Valore di enumerazione per differenziare la
distanza dall'inizio o dalla fine del movimento.
Sono disponibili i valori FROMBEGIN e
FROMEND.
-
offset Offset di posizione riferito all'inizio o alla fine,
come descritto nel parametro type,
mm
timeMs Offset di tempo per lo spostamento del punto di
commutazione
msec
Tabella 23.2 Parametri dell'istruzione OnDistance
Nota
L'istruzione OnDistance può essere utilizzata solo in combinazione con movimenti cartesiani (ad es. Lin e CircIP). Un utilizzo con i movimenti PTP non è possibile. In caso di utilizzo davanti a co-mandi di traslazione PTP viene emessa un'avvertenza.
L'effetto dell'offset di tempo (parametro timeMs) viene trattato nel capitolo 23.6 Offset di tempo opzionale a pagina 231.
23. Punti di commutazione traiettoria
Festo GDCP-CMXR-SW-IT it Version 1.0 227
type
Il parametro type definisce se il punto di commutazione è riferito alla fine o all'inizio del segmento.
OnDistance (FROMBEGIN, 0) commuta all'inizio del segmento:
OnDistance (FROMEND, 0) commuta alla fine del segmento:
offset
Lo scostamento del punto di commutazione avviene sempre sul segmento di traiettoria interessato. Mediante il parametro type è possibile definire se questo offset è riferito
all'inizio o alla fine del segmento.
Selezionando un riferimento all'inizio del segmento, l'offset si estende lungo il segmento in direzione della fine segmento. Selezionando un riferimento a fine segmento, l'offset viene calcolato in direzione dell'inizio del segmento.
Nota
Il parametro offset deve essere impostato con un valore positivo. Impostando un valore negativo viene emesso un messaggio corrispondente.
P1 P2 P3
Fine segmento = punto di commutazione
P1 P2 P3
Fine segmento
Inizio segmento = punto di commutazione
Inizio segmento
23. Punti di commutazione traiettoria
228 Festo GDCP-CMXR-SW-IT it Version 1.0
Esempio di punto di commutazione con distanza dalla fine segmento:
:
Lin(P1)
OnDistance(FROMBEGIN, 30) DO <istruzione>
Lin(P2)
Lin(P3)
:
Esempio di punto di commutazione con distanza dalla fine segmento:
:
Lin(P1)
OnDistance(FROMEND, 30) DO <istruzione>
Lin(P2)
Lin(P3)
:
P1 P2 P3
Punto di commutazione
Fine segmento
Offset = 30 mm
Inizio segmento
P1 P2 P3
Punto di commutazione
Fine segmento Offset = 30 mm
Inizio segmento
23. Punti di commutazione traiettoria
Festo GDCP-CMXR-SW-IT it Version 1.0 229
23.5 Punto di commutazione su un piano di commutazione, <OnPlane>
La macro del punto di commutazione consente l'esecuzione di un'istruzione mentre viene percorso un piano programmabile nello spazio. Il piano di commutazione deve essere percorso nel segmento del successivo comando di traslazione cartesiano. Il piano si trova a distanza parametrizzabile in posizione parallela rispetto a un piano dell'attuale sistema di riferimento.
Sintassi
OnPlane( <plane> : PLANETYPE,
<pos> : REAL,
OPT <timeMs> : REAL ) DO < istruzione >
Parametro Significato Unità
plane Selezione del piano XYPLANE, YZPLANE,
XZPLANE.
-
pos Scostamento parallelo del piano rispetto allo
zero del sistema di riferimento attivo.
mm
timeMs Scostamento temporale del punto di
commutazione programmato.
Tabella 23.3 Parametri dell'istruzione OnPlane
L'effetto dell'offset di tempo (parametro timeMs) viene trattato nel capitolo 23.6 Offset di tempo opzionale a pagina 231.
Nota
La selezione del piano di commutazione XY, YZ o XZ mediante il parametro plane viene definita nel sistema di riferimento attivo. In caso di cambio del sistema di riferimento occorre tener presente che le posizioni dei piani possono modificarsi.
Nota
Il piano di commutazione può essere attivato solo attraverso movimenti cartesiani. Se viene percorso con un movimento PTP viene emessa un'avvertenza, in quanto il punto di commutazione non può essere calcolato nel caso di un movimento PTP.
23. Punti di commutazione traiettoria
230 Festo GDCP-CMXR-SW-IT it Version 1.0
Esempio:
Nell'esempio seguente viene definito un piano parallelo al piano XZ del sistema di riferimento attivo. Poiché il piano si trova nello zero del sistema di riferimento, è necessario spostarlo parallelamente mediante il parametro pos.
:
// corsa di andata
Lin(P0)
OnPlane(XZPLANE, 100) DO mySignal := TRUE
Lin(P1)
Lin(P2)
// corsa di ritorno
Lin(P1)
OnPlane(XZPLANE, 100) DO mySignal := FALSE
Lin(P0)
:
1
1 P1 Y
1
1 P1´
1
1 P0
1
1 P2
1
1 Piano XZ
100 mm
X
Z
23. Punti di commutazione traiettoria
Festo GDCP-CMXR-SW-IT it Version 1.0 231
23.5.1 Programmazione mediante “teach-in” della posizione del piano di commutazione
Per semplificare la lavorazione, la posizione del piano di commutazione può essere definita tramite l'immissione di un valore oppure programmata mediante “teach-in”. Questa procedura viene eseguita con l'unità di comando manuale o con il software di emulazione.
Nel modo operativo MANUALE, quando si crea la macro o si aziona la softkey Modifica viene aperta la maschera dei parametri della macro. Selezionando la riga Posizione, la
softkey diventa attiva e può essere utilizzata.
La programmazione della posizione mediante “teach-in” dipende dal piano selezionato tramite il parametro plane. Vengono programmati mediante “teach-in” i seguenti valori cartesiani:
Piano selezionato, parametro plane Asse cartesiano programmato
mediante “teach-in"
XYPlane Z
XZPlane Y
YZPlane X
Tabella 23.4 Programmazione del parametro plane mediante “teach-in”
Premendo la softkey viene eseguita la programmazione mediante “teach-in”. Il valore cartesiano del rispettivo asse (vedi tabella) viene rilevato e scritto nel parametro pos. Se a questo parametro è assegnata una variabile, il valore viene scritto in questa variabile.
Nota
Il valore viene sempre programmato nell'attuale sistema di riferimento selezionato. Questo viene visualizzato sul lato della posizione nella casella di selezione.
1. Cliccare sul campo parametri (viene
evidenziato in blu)
2. La softkey Teach viene attivata
23. Punti di commutazione traiettoria
232 Festo GDCP-CMXR-SW-IT it Version 1.0
Punto di
commutazione
P1 P2
Offset
Punto di
commutazione
P1 P2
Offset
P1 P2
Offset
Offset di tempo positivo
Offset di tempo negativo
Offset di tempo negativo
Punto di
commutazione
23.6 Offset di tempo opzionale
Nelle macro dei punti di commutazione OnParameter, OnDistance e OnPlane sopra descritte è possibile specificare un offset di tempo opzionale. Questo offset di tempo consente di spostare temporalmente le azioni di commutazione sul segmento di traiettoria.
Un valore di tempo positivo sposta l'azione di commutazione nel futuro, un valore di tempo negativo attiva l'azione di commutazione in un momento anteriore. Per un offset negativo sono ammessi max. 300 msec, per un offset positivo 1 sec.
Nota
Se l'offset di tempo opzionale non viene specificato, esso viene inizializzato con il valore 0. L'indicazione del valore di tempo avviene in msec.
Esempio con un offset di tempo negativo:
:
Lin(P1)
OnDistance(FROMEND, 0, -55) DO Lamp.Set()
Lin(P2)
:
Esempio di offset di tempo negativo per il segmento:
:
Lin(P1)
OnDistance(FROMEND, 0, -250) DO
Lamp.Set()
Lin(P2)
:
Esempio con un offset di tempo positivo:
:
Lin(P1)
OnDistance(FROMEND, 0, 250) DO
Lamp.Set()
Lin(P2)
:
23. Punti di commutazione traiettoria
Festo GDCP-CMXR-SW-IT it Version 1.0 233
Nota
L'offset di tempo negativo è limitato e può essere al massimo di 300 msec, quello positivo al massimo di 1 secondo. In caso di valori non consentiti viene emesso un messaggio di avvertimento in cui viene segnalato che questo punto di commutazione traiettoria ha un valore di tempo non valido.
23.6.1 Reazione del sistema in caso di valore di tempo non consentito
Se viene specificato un valore di tempo non conforme ai valori massimi ammessi, viene emesso un messaggio di avvertimento. In questo messaggio viene indicata la macro del punto di commutazione, il programma e la riga di programma interessata.
23. Punti di commutazione traiettoria
234 Festo GDCP-CMXR-SW-IT it Version 1.0
23.7 Condizioni limite
23.7.1 Esercizio a passo singolo
Se nell'esercizio manuale viene selezionato sull'unità di comando manuale l'esercizio passo-passo per l'esecuzione del programma, i punti di commutazione traiettoria programmati non vengono eseguiti. A causa dell'arresto dopo ogni riga di programma non è possibile la calcolazione e neppure l'esecuzione dei punti di commutazione traiettoria.
Nota
L'esercizio a passo singolo viene selezionato con il tasto , che si trova nella finestra della schermata del programma. In questa schermata viene visualizzato lo stato attivo nella riga di intestazione del programma.
23.7.2 Istruzioni di attesa che influiscono sull'elaborazione principale
Nei sottoprogrammi contenenti i punti di commutazione traiettoria non è consentito utilizzare istruzioni di attesa come ad es. WaitTime, WaitOnPos, WaitOnPath o WaitOnMainRun. Queste istruzioni influenzano il calcolo preliminare del programma e quindi anche il calcolo dei punti di commutazione traiettoria. In caso di utilizzo di queste funzioni viene visualizzato un messaggio corrispondente.
23.7.3 Attivazione del puntatore di frase
Attivando il puntatore di frase (freccia blu) su una macro di commutazione della traiettoria del tipo OnDistance, OnParameter o OnPlane, questa non viene eseguita all'avvio del programma. La sua esecuzione è possibile solamente dopo che è stato raggiunto il punto
di partenza del primo segmento di traiettoria completo e il movimento in direzione del punto di arrivo è attivo.
Nota
I punti di commutazione traiettoria programmati prima di un segmento di traiettoria iniziale non hanno alcun effetto. La loro esecuzione può avvenire solo all'interno di un segmento di traiettoria iniziato. Il sistema genera un messaggio di avvertimento, segnalando che questi punti di commutazione non possono essere eseguiti.
Avviando il programma rappresentato nella figura seguente, il punto di commutazione programmato sul quale si trova il puntatore non può essere eseguito.
23. Punti di commutazione traiettoria
Festo GDCP-CMXR-SW-IT it Version 1.0 235
23.7.4 Influsso dell'override
Con l'override è possibile ridurre in percentuale l'attuale velocità della cinematica. Questa modifica ha un effetto immediato sul movimento in corso e lo influenza in modo
corrispondente. Per garantire un'esecuzione sicura dei punti di commutazione traiettoria, l'override deve avere un valore costante durante l'esecuzione. Una modifica dell'override durante l'esecuzione dei punti di commutazione traiettoria può provocare imprecisioni.
Se si desidera che il programma venga sempre eseguito con un determinato valore di override, ad es. 100%, si può aggiungere la macro Ovr (vedi cap. 10.5.1 Override dall'unità di comando manuale <Ovr>). In questo modo l'override viene impostato una sola volta tramite il programma FTL. Una modifica manuale è possibile in qualsiasi momento.
Esempio:
:
// impostazione dell'override al 100%
Ovr(100)
Lin(HomePos)
Lin(pos1)
// punto di commutazione
OnDist(FROMEND, Offset, -55) DO Gripper.Set()
Lin(pos2)
Lin(pos3)
:
Il punto di commutazione
non può essere eseguito
23. Punti di commutazione traiettoria
236 Festo GDCP-CMXR-SW-IT it Version 1.0
23.7.5 Lavorazione in esercizio manuale a velocità ridotta
I punti di commutazione traiettoria possono essere eseguiti e testati anche in esercizio manuale a velocità ridotta. Questo tipo di esecuzione del programma deve tuttavia avvenire in esercizio continuo. Un'esecuzione nell'esercizio a passo singolo non è possibile (vedi cap. 23.7.1 Esercizio a passo singolo).
La velocità ridotta viene utilizzata come valore massimo per la velocità di avanzamento programmata. Questa viene poi usata per la calcolazione durante l'esecuzione dei punti di commutazione traiettoria. In tal modo la velocità di avanzamento ridotta non influisce in
alcun modo sulla precisione di commutazione dei punti di commutazione traiettoria.
Se si utilizza l'approssimazione della velocità (macro OvlVel) cambia tuttavia il compor-tamento di approssimazione, dato che questo viene calcolato dinamicamente in funzione della velocità di avanzamento. Se nell'area di approssimazione sono presenti punti di commutazione traiettoria, può risultare una differenza della posizione del punto di commutazione rispetto all'esercizio automatico.
L'utilizzo dell'approssimazione geometrica (macro OvlCart) non viene influenzato dalla velocità di avanzamento ridotta.
Attenzione
Se nell'area di approssimazione è presente un punto di commu-tazione traiettoria, a causa della velocità di avanzamento ridotta nella posizione di commutazione possono risultare differenze rispetto all'esercizio automatico (piena velocità). Perciò il comportamento di commutazione deve sempre essere testato e ottimizzato nell'esercizio automatico.
23.7.6 Interruzione del programma
Un programma attivo può essere arrestato, e quindi interrotto, premendo il tasto di arresto sull'unità di comando manuale oppure tramite un PLC. Al successivo riavvio il programma viene proseguito e vengono eseguiti gli eventuali punti di commutazione traiettoria seguenti. Se questo avvio e/o arresto ha luogo durante l'esecuzione di un punto di commutazione traiettoria, possono verificarsi imprecisioni nel comportamento di com-mutazione.
Attenzione
Se il programma viene arrestato e i punti di commutazione traiettoria si trovano già in fase di calcolazione, viene pregiudicata l'esecuzione e quindi anche la precisione nel caso di un successivo start del programma. Di conseguenza potrebbero verificarsi perdite di qualità.
23. Punti di commutazione traiettoria
Festo GDCP-CMXR-SW-IT it Version 1.0 237
23.8 Punti di commutazione non eseguiti
Alla fine di ogni segmento viene controllato se tutti i punti di commutazione programmati sono stati eseguiti. Qualora alcuni punti di commutazione non siano stati eseguiti, ad es. un piano definito non è stato percorso, per ogni trigger non eseguito viene emesso un messaggio di avvertimento.
Questo messaggio contiene le seguenti informazioni:
- Nome della macro del punto di commutazione dal programma FTL
- Nome del progetto e del programma
- Numero di riga
24. Esempi
238 Festo GDCP-CMXR-SW-IT it Version 1.0
24. 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 sotto-programmi descritti in questi esempi, è necessario verificare che siano adatti all'uso previsto e garantirne il corretto funzionamento con una messa in funzione corrispondente.
L'inosservanza di quanto indicato può causare danni materiali e lesioni personali.
24.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
Sensore di
rilevamento pila vuota
Ingresso: inCollision
Sensore di rilevamento pila vuota
Ingresso: inStackNotEmpty
x
z
y
24. Esempi
Festo GDCP-CMXR-SW-IT it Version 1.0 239
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 24.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
24. Esempi
240 Festo GDCP-CMXR-SW-IT it Version 1.0
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.
24. Esempi
Festo GDCP-CMXR-SW-IT it Version 1.0 241
24.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.
24. Esempi
242 Festo GDCP-CMXR-SW-IT it Version 1.0
24.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 preliminare 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
24. Esempi
Festo GDCP-CMXR-SW-IT it Version 1.0 243
24.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 gene-rato 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
24. Esempi
244 Festo GDCP-CMXR-SW-IT it Version 1.0
24.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 espulsione 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
24. Esempi
Festo GDCP-CMXR-SW-IT it Version 1.0 245
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 pos4. 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.
24. Esempi
246 Festo GDCP-CMXR-SW-IT it Version 1.0
Profilo di movimento:
Comportamento temporale:
Tempo
pos1 pos3
Tempo di attesa
pos4
pos3
pos2
pos1
pos2 pos4
pos3 pos1
Area di approssimazione
Velocità
24. Esempi
Festo GDCP-CMXR-SW-IT it Version 1.0 247
24.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 integrati sotto forma di moduli nella programmazione FTL.
pos2 pos4
pos3 pos1
24. Esempi
248 Festo GDCP-CMXR-SW-IT it Version 1.0
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)
outGripperClose.Reset()
outGripperOpen.Set() // apertura pinza
inGripperOpen.Wait(TRUE) // attesa fino all'apertura
Lin(pos2) // posizione di presa
outGripperOpen.Reset()
outGripperClose.Set() // chiusura pinza
inGripperClosed.Wait() // attesa fino alla chiusura
Lin(pos1)
Lin(pos3)
Lin(pos4) // posizione di deposizione
outGripperClose.Reset()
outGripperOpen.Set() // apertura pinza
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.
24. Esempi
Festo GDCP-CMXR-SW-IT it Version 1.0 249
Profilo di movimento:
Comportamento temporale:
Tempo pos3
pos4
pos3
pos2
pos1
Tempo di attesa fino al segnale di feed-back per
pinza aperta
Velocità
pos1
Tempo di attesa fino al segnale di feed-back per
pinza chiusa
pos2 pos4
pos3 pos1
Area di approssimazione
24. Esempi
250 Festo GDCP-CMXR-SW-IT it Version 1.0
24.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
24. Esempi
Festo GDCP-CMXR-SW-IT it Version 1.0 251
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
outGripperOpen.Reset()
outGripperClose.Set() // chiusura pinza
inGripperClose.Wait() // attesa fino alla chiusura della
pinza
Lin(pos1)
outPos0Degree.Reset() // rotazione a 90 gradi
outPos90Degree.Set()
Lin(pos3)
inPos90Degree.Wait(TRUE) // attesa 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)
24. Esempi
252 Festo GDCP-CMXR-SW-IT it Version 1.0
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'ap-prossimazione. 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
24. Esempi
Festo GDCP-CMXR-SW-IT it Version 1.0 253
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
24. Esempi
254 Festo GDCP-CMXR-SW-IT it Version 1.0
24.5 Utilizzo dell'interfaccia PLC
24.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 posizione 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 “waitPos” finché il PLC non è pronto.
24.5.2 Interfaccia PLC
Lo scambio dei dati tra il controller CMXR e il PLC viene realizzato con due bit di sincronizzazione. 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
24. Esempi
Festo GDCP-CMXR-SW-IT it Version 1.0 255
24.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)
24. Esempi
256 Festo GDCP-CMXR-SW-IT it Version 1.0
Lin(depositPos)
// deposizione
gripper.Reset()
WaitTime(200)
// accostamento della posizione di attesa
Lin(aboveDepositPos)
Lin(waitPos)
END_WHILE
A. Elenco di istruzioni FTL
Festo GDCP-CMXR-SW-IT it Version 1.0 257
A. Elenco di istruzioni FTL La seguente tabella contiene le macro FTL disponibili nei singoli sistemi, in combinazione con la rispettiva versione di sistema operativo.
CMXR – C1 CMXR-C2
Istruzioni FTL Versione 1.06 Versione 1.25 Versione 1.0
Tipi di dati
BOOL √ √ √
REAL √ √ √
DINT √ √ √
DWORD √ √ √
STRING √ √ √
( ) - √ √
ARRAY - √ √
Funzioni, istruzioni
LOW - √ √
HIGH - √ √
MAPTO - √ √
MAP - √ √
IS_MAPPED - √ √
Comando a programma, cicli di istruzioni
IF … THEN, ELSIF…. THEN, ELSE √ √ √
LABEL √ √ √
IF … GOTO √ √ √
GOTO √ √ √
WHILE …. DO √ √ √
LOOP √ √ √
CALL √ √ √
RUN √ √ √
RETURN √ √ √
KILL √ √ √
WaitTime √ √ √
WAIT √ √ √
WaitOnPath - √ √
WaitOnPos - √ √
WaitOnMainRun - - √
Comandi di traslazione
Ptp √ √ √
PtpRel √ √ √
A. Elenco di istruzioni FTL
258 Festo GDCP-CMXR-SW-IT it Version 1.0
MoveAxisPtp √ √ √
Lin √ √ √
LinRel √ √ √
MoveAxisCart √ √ √
CircIp √ √ √
PtpToCircIp √ √ √
LinToCircIP √ √ √
StopMove √ √ √
StopProgram √ √ √
Istruzioni dinamiche
Vel √ √ √
Acc √ √ √
Jerk √ √ √
Ovr √ √ √
DynOvr √ √ √
Ramp √ √ √
VconstOn √ √ √
VconstOff √ √ √
Istruzioni di approssimazione
OvlVel √ √ √
OvlCart √ √ √
Sistemi di riferimento
SetRefSys √ √ √
SetRefSys3P √ √ √
SetRefSysWorld √ √ √
SetRefSysDyn - - √
Corsa di riferimento
RefAxis √ √ √
RefAxisAsync √ √ √
WaitRefFinished √ √ √
IsAxisReferenced √ √ √
Utensili
Tool √ √ √
Interfaccia Profibus, variabili di sistema, funzioni
plc_InBool : ARRAY[16] OF BOOL √ √ -
plc_OutBool : ARRAY[16] OF BOOL √ √ -
plc_Dint : ARRAY[256] OF DINT √ √ -
plc_AxisPos : ARRAY[256] OF AXISPOS √ √ -
plc_CartPos : ARRAY[256] OF CARTPOS √ √ -
plc_RefSys : ARRAY[16] OF REFSYSDATA √ √ -
A. Elenco di istruzioni FTL
Festo GDCP-CMXR-SW-IT it Version 1.0 259
ProgHold √ √ √
Interfaccia a variabili per il PLC interno (CoDeSys)
plc_InBool : ARRAY[256] OF BOOL - - √
plc_OutBool : ARRAY[256] OF BOOL - - √
plc_InDword : ARRAY[256] OF DWORD - - √
plc_OutDword : ARRAY[256] OF DWORD - - √
plc_InDint : ARRAY[256] OF DINT - - √
plc_OutDint : ARRAY[256] OF DINT - - √
plc_InReal : ARRAY[256] OF Real - - √
plc_OutReal : ARRAY[256] OF Real - - √
plc_InAxisPos : ARRAY[256] OF AXISPOS - - √
plc_OutAxisPos : ARRAY[256] OF AXISPOS - - √
plc_InCartPos : ARRAY[256] OF CARTPOS - - √
plc_OutCartPos : ARRAY[256] OF CARTPOS - - √
Sistema di segnalazione
SetInfo √ √ √
SetWarning √ √ √
SetError √ √ √
Funzioni
ReadActualPos √ √ √
ReadTargetPos √ √ √
SavePosition √ √ √
Time √ √ √
TimeToStr √ √ √
SIN, ASIN √ √ √
COS, ACOS √ √ √
TAN, ATAN √ √ √
COT, ACOT √ √ √
ATAN2 √ √ √
LN √ √ √
EXP √ √ √
ABS √ √ √
SQRT √ √ √
SHR, SHL √ √ √
ROR, ROL √ √ √
STR √ √ √
CHR √ √ √
ORD √ √ √
SetBit - - √
ResetBit - - √
A. Elenco di istruzioni FTL
260 Festo GDCP-CMXR-SW-IT it Version 1.0
CheckBit - - √
Moduli e metodi
Ingresso digitale, DIN √ √ √
Wait, WaitN √ √ √
Read √ √ √
RisingEdge √ √ √
ResetRisingEdge √ √ √
Uscita digitale, DOUT √ √ √
Wait, WaitN √ √ √
Read √ √ √
RisingEdge √ √ √
ResetRisingEdge √ √ √
Set, Reset √ √ √
Write √ √ √
Pulse - √ √
Ingresso analogico, AIN √ √ √
WaitLss, WaitGrt √ √ √
WaitIns, WaitOuts √ √ √
Read √ √ √
Uscita analogica, AOUT √ √ √
Write √ √ √
WaitLss, WaitGrt √ √ √
WaitIns, WaitOuts √ √ √
Read √ √ √
Timer, CLOCK √ √ √
Start √ √ √
Stop √ √ √
Reset √ √ √
Read √ √ √
ToStr √ √ √
Encoder, ENCODER √ √ √
Set √ √ √
Read √ √ √
CANOpen, COPDEVICE √ √ √
WriteSDO √ √ √
ReadSDOSigned √ √ √
ReadSDOUnsigned √ √ √
Eventi
onstartup - - √
onprogload - - √
A. Elenco di istruzioni FTL
Festo GDCP-CMXR-SW-IT it Version 1.0 261
onproginterrupt - - √
onprogcontinue - - √
onprogend - - √
onf1keypressed - - √
onf1keyreleased - - √
onf2keypressed - - √
onf2keyreleased - - √
GetAutoModeActive - - √
GetManualModeActive - - √
LoadProgram - - √
Punti di commutazione
DO - √ √
OnPosition - - √
OnParameter - - √
OnDistance - - √
OnPlane - - √
B. Struttura a menu delle istruzioni FTL
262 Festo GDCP-CMXR-SW-IT it Version 1.0
B. 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:
Interfaccia PLC
ProgHold
Funzioni
ABS
ACOS
ACOT
ASIN
ATAN
ATAN2
COS
COT
CheckBit
EXP
LN
B. Struttura a menu delle istruzioni FTL
Festo GDCP-CMXR-SW-IT it Version 1.0 263
Funzioni di posizione
o ReadActualPos
o ReadTargetPos
o SavePosition
ResetBit
SIN
SQRT
SetBit
TAN
Time
TimeToStr
Referenziamento
IsAxisReferenced
RefAxis
RefAxisAsync
WaitRefFinished
Comandi di traslazione
CircIp
Lin
LinRel
LinToCircIp
MoveAxisCart
MoveAxisPtp
Ptp
PtpRel
PtpToCircIp
StopMove
Istruzioni dinamiche
Acc
DynOvr
Jerk
OvlCart
OvlVel
OvlWrist
B. Struttura a menu delle istruzioni FTL
264 Festo GDCP-CMXR-SW-IT it Version 1.0
Ovr
Ramp
VconstOff
VconstOn
Vel
Istruzioni
… := …
CALL…
//
ELSE
ELSIF … THEN
GOTO…
IF … GOTO
IF … THEN … END_IF
KILL…
LABEL…
LOOP … DO … END_LOOP
RETURN
RUN…
StopProgram
WAIT…
WHILE … DO … END_WHILE
WaitOnMainRun
WaitOnPath
WaitOnPos
WaitTime
Comandi robot
Sistemi di riferimento
o SetRefSys
o SetRefSys3P
o SetRefSysDyn
o SetRefSysWorld
Tool
B. Struttura a menu delle istruzioni FTL
Festo GDCP-CMXR-SW-IT it Version 1.0 265
Funzioni di sistema
Misurazione del tempo
o CLOCK.Read
o CLOCK.Reset
o CLOCK.Start
o CLOCK.Stop
o CLOCK.ToStr
Manipolazione bit
o CHR
o ORD
o ROL
o ROR
o SHL
o SHR
o STR
Sistema di segnalazione
SetError
SetInfo
SetWarning
Moduli I/O
Ingressi analogici
o AIN.Read
o AIN.WaitGrt
o AIN.WaitIns
o AIN.WaitLss
o AIN.WaitOuts
Uscite analogiche
o AOUT.Read
o AOUT.WaitGrt
o AOUT.WaitIns
o AOUT.WaitLss
o AOUT.WaitOuts
o AOUT.Write
B. Struttura a menu delle istruzioni FTL
266 Festo GDCP-CMXR-SW-IT it Version 1.0
Unità CANopen
o COPDEVICE.ReadSDOSigned
o COPDEVICE.ReadSDOUnsigned
o COPDEVICE.WriteSDO
Ingressi digitali
o DIN.Read
o DIN.ResetRisingEdge
o DIN.RisingEdge
o DIN.Wait
o DIN.WaitN
Uscite digitali
o DOUT.Pulse
o DOUT.Read
o DOUT.Reset
o DOUT.ResetRisingEdge
o DOUT.RisingEdge
o DOUT.Set
o DOUT.Wait
o DOUT.WaitN
o DOUT.Write
Trasduttore incrementale
o ENCODER.Read
o ENCODER.Set
Funzioni tecnologiche
Inseguimento
o CONVEYOR.Begin
o CONVEYOR.End
o CONVEYOR.Done
o CONVEYOR.Wait
o CONVEYOR.WaitReachable
Punti di commutazione traiettoria
o OnDistance
o OnParameter
o OnPlane
C. Termini utilizzati
Festo GDCP-CMXR-SW-IT it Version 1.0 267
C. Termini utilizzati La seguente tabella contiene una spiegazione dei termini utilizzati in questo documento:
Termine Significato C
CDSA Codice del tipo Festo per l'unità di comando manuale
CF card Compact Flash Card, utilizzata come supporto per memorizzazione dati nel
CMXR.
CMXR-C1 Codice del tipo Festo per il modello base C1 del CMXR
CMXR-C2 Codice del tipo Festo per il modello CMXR della classe di prestazione
superiore
CoDeSys Nome del comando PLC integrato, programmabile secondo IEC 61131-3,
che gira insieme alla robotica su un processore.
F
FCT Festo Configuration Tool, software di base per la configurazione dei
controller CMXR e di altri prodotti Festo come ad es. gli attuatori elettrici.
FTL Festo Teach Language, linguaggio di programmazione testuale dei
programmi di movimenti.
P
PlugIn FCT Modulo software per il software di base FCT. Per singoli prodotti Festo è
possibile installare dei PlugIn, disponibili nell'area di download della
homepage Festo www.festo.com.
T
Tracking Tracciamento di oggetti in movimento, ad es. i pezzi su un nastro
trasportatore.
D. Indice
268 Festo GDCP-CMXR-SW-IT it Version 1.0
D. Indice
_
_global.tt ............................................. 20
A
ABS ................................................... 161 Acc ...................................................... 94 ACOS ................................................. 156 ACOT ................................................. 159
AIN .................................................... 182 AOUT ................................................. 187 Array ................................................... 32 ASIN .................................................. 155 ATAN ................................................. 158 ATAN2 ............................................... 160 AXISPOS .............................................. 62
C
Calcolo preliminare dei record ........................... 52, 53, 241
CALL .................................................... 48 CARTPOS ............................................. 62 CheckBit ............................................ 167 CHR ................................................... 164 CircIp ................................................... 83 CLOCK ............................................... 192 Commento ........................................... 60 Conversioni del tipo ............................. 31
COPDEVICE ........................................ 200 COS ................................................... 156
COT ................................................... 159
D
DIN .................................................... 171 DO ....................................................... 58 DOUT ................................................. 175 DynOvr ................................................ 99
E
ENCODER .......................................... 196 Error .................................................. 204
Esempio
Arresto di movimenti ...................... 237 Controllo del calcolo preliminare
dei record .................................... 241
Utilizzo dei moduli di ingresso e di uscita .......................................... 240
Utilizzo delle pinze ......................... 242 Utilizzo dell'interfaccia PLC ............ 253 WAIT con ingresso digitale ............... 54
EXP ................................................... 160
F
FTL ........................................... 13, 17, 20
G
GOTO .................................................. 45
I
IF … GOTO ........................................... 44 IF…THEN ............................................. 42 Interfaccia Profibus ........................... 135 IS_MAPPED ......................................... 37 IsReferenced ..................................... 126
J
Jerk ..................................................... 95
K
KILL ..................................................... 51
L
LABEL ................................................. 44
Lin....................................................... 76 LinRel .................................................. 78 LN ..................................................... 160
LOOP .................................................. 46 LOW, HIGH .......................................... 34
M
MAP .................................................... 37 MAPTO ................................................ 37 MoveAxisCart ...................................... 72 MoveAxisPtp ....................................... 72
O
ORD .................................................. 164
OvlCart .............................................. 110 OvlVel ............................................... 108 Ovr .............................................. 97, 234
D. Indice
Festo GDCP-CMXR-SW-IT it Version 1.0 269
P
Parole chiave ....................................... 25 plc_AxisPos ....................................... 138 plc_CartPos ....................................... 138 plc_RefSys ......................................... 139 plc_VarDint ........................................ 137 Posizione cartesiana ............................ 65 Posizione dell'asse .............................. 63 ProgHold ........................................... 140 Ptp ...................................................... 67
PtpRel ................................................. 70 PtpToCircIp .................................... 85, 87
R
Ramp ................................................. 101 Read .................................................. 199 ReadActualPos .................................. 151
ReadSDOSigned ................................ 202 ReadSDOUnsigned ............................ 203 ReadTargetPos .................................. 152 Record di programma disattivato ......... 60
RefAxis .............................................. 121 RefAxisAsync ..................................... 123 ResetBit ............................................. 166 RETURN ............................................... 49 ROL ................................................... 163 ROR ................................................... 163 RUN ..................................................... 51
S
SavePosition ..................................... 153
Segmento nullo ................................. 106 Set .................................................... 198 SetBit ................................................ 165 SetError ............................................. 149 SetInfo .............................................. 147 SetRefSys .......................................... 114 SetRefSys3P ...................................... 115 SetRefSysDyn .................................... 118
SetRefSysWorld ................................ 118 SetWarning ....................................... 148 SHL ................................................... 162 SHR ................................................... 162 SIN .................................................... 155 SQRT ................................................. 161 State ................................................. 204 StopMove ........................................... 89 StopProg ............................................. 90 STR ................................................... 164
T
TAN ................................................... 158 TCP ................................................... 127 Tempo di attesa .................................. 52 Tid ................................................ 20, 21 Time .................................................. 153
TimeToStr ......................................... 154 Tip ...................................................... 20 Tipi di dati ........................................... 29 Tool .................................................. 130
U
Utensili ............................................. 127
V
Value ................................................ 204 VconstOff .......................................... 104 VconstOn .......................................... 102 Vel ...................................................... 93
W
WAIT ................................................... 53 WaitOnMainRun .................................. 57 WaitOnPath ......................................... 55 WaitOnPos .......................................... 56 WaitRefFinished ................................ 125 WaitTime............................................. 52 WHILE ................................................. 45 WriteSDO .......................................... 201