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.

http://www.festo.com/

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


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


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


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


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


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


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


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


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


A. Elenco di istruzioni FTL ..................................................................................... 256

B. Struttura a menu delle istruzioni FTL ................................................................ 261

C. Termini utilizzati ............................................................................................... 266

D. Indice ................................................................................................................ 267

1. Introduzione


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



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.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.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



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.



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.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”



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.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



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.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.



Nota

Per memorizzare in modo permanente i valori di posizione sulla scheda di memoria, utilizzare l'istruzione FTL “SavePosition”.

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.



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.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.


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


< Minore

<= Minore o uguale

= Uguale

<> Non uguale

>= Maggiore o uguale

> Maggiore

Tabella 4.3 Operatori di comparazione



4.6.4 Altri operatori


. 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


:= 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


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



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.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


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.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


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



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.



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> )



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



Terza dimensione da 10 a 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)


Index := HIGH(Matrix1)


Index := LOW(Matrix2)


Index := HIGH(Matrix2)


Index := LOW(Matrix2[0])


Index := HIGH(Matrix2[0])



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.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



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


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


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



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



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.



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.



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



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.



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



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.



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



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.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



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.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

:



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)



Lin(pos1)

Lin(pos2)

Lin(pos3)

Lin(pos4)

Lin(pos5)

Wait sensor

Lin(pos6)

Lin(pos7)

Lin(pos8)

Lin(pos9)



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.



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



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



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 )


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


pos1

pos1

printPos



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


WaitOnMainRun() // attesa dell'elaborazione principale

del programma

Pos2

Pos1

80%



plc_InBool[3] := TRUE // segnale al PLC


:

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


pos3

pos1

pos2

Esecuzione di WaitOnMainRun prima del

raggiungimento della posizione pos2

Ejecución principal

Avance



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.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.



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


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.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






a7 : REAL Posizione asse ausiliario 1



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

:



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





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



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



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.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



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)


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



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


Andamento approssimativo della traiettoria su TCP

Andamento della traiettoria sull'asse Z




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)


Dist Distanza relativa da percorrere AXISDIST o CARTDIST

Tabella 9.2 Parametri dell'istruzione PtpRel

1. cliccare sul campo parametri

che diventa blu




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



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)


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




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



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.


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



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.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)


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



:

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




Andamento della traiettoria su TCP Andamento approssimativo

della traiettoria sull'asse Z



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.



programmazione mediante “teach-in” avviene sempre su una variabile di posizione.

Nota


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)


Dist Posizione di arrivo relativa AXISDIST o CARTDIST

Tabella 9.6 Parametri dell'istruzione LinRel


che diventa blu




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



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.



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



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.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)


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.



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.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,



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.



Esempio:


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 finale EndPos

Posizione Pos1

Asse X

Asse Y

300

400

500

1050

950

455



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,



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:


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 finale EndPos

Posizione Pos1

Asse X

Asse Y

300

400

500

1050

950

455



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.


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.


che diventa blu




Nota


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.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


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.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.


Limite dell'asse

Riduzione della velocità di avanzamento

Limite del singolo asse

raggiunto



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)


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.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)


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




dynCart cartesiano mm/sec²

Tabella 10.4 Unità dei parametri ValueAcc, ValueDec

Nota

Se il parametro opzionale ValueDec (per la rampa di decelerazione) non viene specificato, per la rampa di decelerazione verrà utilizzato il valore del parametro ValueAcc (per l'accelerazione). Il profilo sarà quindi simmetrico.

Esempio:

Variabile:

:

pos0 : AXISPOS := (-60, -60, 0, 0, 0, 0, 0, 0, 0)

pos1 : AXISPOS := (60, 60, 0, 0, 0, 0, 0, 0, 0)

pos2 : AXISPOS := (100, 60, 0, 0, 0, 0, 0, 0, 0)

:



Programma:

:

Ptp(pos0)

Acc(dynPtp, 30, 30) // accelerazione per PTP al 30 %

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)


Mode Tipo di movimento Enumerazione: dynPtp, dynCart

Value Valore dello strappo Dipendente dal tipo (Mode)

selezionato

Tabella 10.5 Parametri dell'istruzione Jerk




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)

:



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.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.



Sintassi

Ovr ( <Value> : REAL)


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)


Ovr(60)

Lin(pos3)

Lin(pos4)



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)


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.


pos4

pos3

pos2

pos1

60%

100%

Tempo



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



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)


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



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)


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.



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.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


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



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.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.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)


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.



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


3) Sovrapposizione completa

2) Sovrapposizione parziale

Direzione X

Tempo di ciclo

Tempo di ciclo

Direzione Y

1) Senza sovrapposizione

0 %

50 %

100 %



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




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)



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



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.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)


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




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.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)


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.



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




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.


che diventa blu


1. Selezione sistema di riferimento in cui si

attua il “teach-in”.



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)


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.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



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



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)


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.



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



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)




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.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.4 Interrogazione dello stato di un asse <IsAxisReferenced>

Interrogazione per sapere se un determinato asse è stato referenziato.

Sintassi

IsAxisReferenced(axis : AXIS ) : BOOL


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


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




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


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


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


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.


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


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


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


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


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


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.



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.



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.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.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.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à:



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)



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.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].

:


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.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:

:


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


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



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


SetInfo(“Sensor %1, pressure %2 bar”, param1, param2)

Viene visualizzato il seguente testo informativo: “Sensor 7, pressure 3,48 bar”.



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)


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.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)


text Testo del messaggio di

avvertimento

STRING



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:


pressione


SetWarning(“Cycle %1 finished, Value %2”,cycle, pressure)




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)


Testo Testo del messaggio di errore STRING



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:


pressione


SetError(“Cycle %1 error, pressure %2”, cycle, pressure)




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


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.


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


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.


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


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.


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


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:


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


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>)


18. Funzioni


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


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


Sintassi

(<angolo in gradi> : REAL) := ACOS(<valore coseno>)

L'angolo viene restituito in gradi.

Esempio:

b := 30 // cateto adiacente


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


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


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>)


Esempio:



b := a / TAN(alpha) // calcolo del cateto adiacente

a := 45.89 // cateto opposto

18. Funzioni



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


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>)


18. Funzioni


Esempio:



b := a * COT(alpha) // calcolo del cateto adiacente

a := 45.89 // cateto opposto


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


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


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”.


1001 1111 0000 1100 1111 1111 1001 1100


0001 0011 1110 0001 1001 1111 1111 0011

18. Funzioni


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.


1011 1111 0110 1001 0011 000 1001 1010


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.


1011 1111 0110 1001 0011 000 1001 1010


1010 1011 1111 0110 1001 0011 000 1001

18. Funzioni


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


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


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.



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


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.



Esempio

IF CheckBit(mask, 1) THEN

// Stato TRUE

SetInfo(“Bit 1 è impostato")

ELSE

// Stato FALSE

SetInfo(“Bit 1 non è impostato")

END_IF

19. Moduli


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


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


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


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


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


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


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


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


Sintassi

<nome istanza>.RisingEdge (OPT ovlEnable: BOOL) : BOOL


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.


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



Esempio:

Un cilindro viene impostato come istanza di un modulo:


cylinder : DOUT := (-1,FALSE, MAP(Output3))


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.


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


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

RisingEdge BOOL Stato del fronte ascendente FALSE

Output DOUTPORT Rimando all'uscita hardware ---

Tabella 19.3 Variabili del modulo di uscita digitale

Timeout



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.


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


19.5.3 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


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)


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


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


19. Moduli


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


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)


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


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.


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



temperature : AIN := (-1, MAP(Sensor1))


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.


L'istanziazione del modulo di ingresso analogico mediante l'unità di comando manuale avviene nella maschera delle variabili selezionando il tipo di dati AIN.


19. Moduli


19.6.2 Variabili Il modulo di ingresso analogico possiede le seguenti variabili:


Timeout REAL Timeout di attesa con le istruzioni WaitLss, WaitGrt,

WaitIns e Waitouts.




-1

Input AINPORT Rimando all'ingresso hardware ---

Tabella 19.6 Variabili del modulo di ingresso analogico

Timeout



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.



Input

La variabile Input descrive il rimando all'ingresso hardware del modulo.

19.6.3 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



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)



value REAL Valore limite

Tabella 19.8 Parametri dei metodi WaitLss, WaitGrt

Esempio:

Lin(pos1)

temperature.WaitLss(65.0, TRUE)

Lin(pos2)

19. Moduli


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)



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)


19. Moduli


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.


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))


Esempio:

Una quantità prestabilita viene impostata come istanza di un modulo:


quantity : AOUT := (-1, MAP(SetValue))


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



L'istanziazione del modulo di uscita analogico mediante l'unità di comando manuale avviene nella maschera delle variabili selezionando il tipo di dati AOUT.


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

Output AOUTPORT Rimando all'uscita hardware ---

Tabella 19.10 Variabili del modulo di uscita analogico

Timeout



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.



19. Moduli


Output

La variabile Output descrive il rimando all'uscita hardware del modulo.

19.7.3 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


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


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)


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)



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


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)



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)


Esempio

Lin(pos1)

// lettura della quantità senza arresto sulla traiettoria

value := quantity.Read(TRUE)

Lin(pos2)

19. Moduli


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.


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


L'istanziazione avviene nella finestra di dialogo per la creazione di variabili, selezionando il tipo (<Type:>) CLOCK e impostando l'identificatore (<Identifier:>) clkTimer.


L'istanziazione del modulo orologio mediante l'unità di comando manuale avviene nella maschera delle variabili selezionando il tipo di dati CLOCK.

19. Moduli


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


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


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


Sintassi

<nome istanza>.Read(OPT ovlEnable : BOOL) : DINT


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


Valore di ritorno: stringa con l'informazione di tempo formattata gg hh:mm:ss:ms.

Esempio:

Dati:

time : STRING

19. Moduli


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.


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))


Esempio:

Un encoder viene impostato come istanza di un modulo:


enc0 : ENCODER := (-1, MAP(Encoder_0))

19. Moduli



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.


L'istanziazione del modulo encoder mediante l'unità di comando manuale avviene nella maschera delle variabili selezionando il tipo di dati ENCODER.


19. Moduli


19.9.2 Variabili

Il modulo encoder possiede le seguenti variabili:


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


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


Sintassi:

<ENCODER>.Set ( OPT <count> : DINT, OPT <mode> : SETCOUNTMODE)


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


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


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.


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



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


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



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




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


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




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



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.



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


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.



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,



- 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.



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.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



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


ProgCode := 1

:



Programma FTL Feeding


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.



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.



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



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



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


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.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.



Testo del messaggio Programma non valido per l'istruzione 'LoadProgram'. <Nome


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.



Testo del messaggio Istruzione robot nell'evento: <nome evento> non è ammesso. <Nome


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.





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


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



:

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.



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


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



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


programmato, spostato da P2

Punto di

commutazione

proiettato ed eseguito



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


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.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 >


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.



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



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


Fine segmento

Offset = 30 mm

Inizio segmento

P1 P2 P3


Fine segmento Offset = 30 mm

Inizio segmento



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 >


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.



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.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



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)

:



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.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.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:

:


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.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.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


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


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


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


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


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)


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)



24. Esempi


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)



count := 0

Lin(Pos1)

Lin(Pos2)

LOOP 10 DO

Lin(Pos3)

WaitTime (1)

count:=count + 1

Lin(Pos4)

END_LOOP

Lin(Pos5)


Calcolo

preliminare dei record

24. Esempi


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


Variabili:

vacuum : DOUT := (...) // modulo di uscita digitale

Programma:

Vel(dynCart, 1500) // velocità di avanzamento = 1500 mm/sec


= 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


Profilo di movimento:

Comportamento temporale:

Tempo

pos1 pos3

Tempo di attesa

pos4

pos3

pos2

pos1

pos2 pos4

pos3 pos1


Velocità

24. Esempi


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


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:


Acc(dynCart, 5000) // accelerazione lungo la traiettoria =

5000 mm/sec²


Lin(pos1)

outGripperClose.Reset()

outGripperOpen.Set() // apertura pinza

inGripperOpen.Wait(TRUE) // attesa fino all'apertura


outGripperOpen.Reset()

outGripperClose.Set() // chiusura pinza

inGripperClosed.Wait() // attesa fino alla chiusura

Lin(pos1)

Lin(pos3)


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




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


24. Esempi


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


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:



= 5000 mm/sec²


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


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


outGripperClose.Reset() // apertura pinza

outGripperOpen.Set()

inGripperOpen.Wait() // attesa fino all'apertura della

pinza

Lin(pos3)

24. Esempi


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.


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


pos2 pos4

pos3 pos1


24. Esempi



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


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


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


Lin(depositPos)

// deposizione

gripper.Reset()

WaitTime(200)

// accostamento della posizione di attesa

Lin(aboveDepositPos)

Lin(waitPos)

END_WHILE

A. Elenco di istruzioni FTL


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 √ √ √



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 √ √ -



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 - - √



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 - - √



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


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



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



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



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



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


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.

http://www.festo.com/

D. Indice


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


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

festo€¦ · festo gdcp-cmxr-sw-it it version 1.0 3 edizione...

Documents