Festo€¦ · Festo GDCP-CMXR-SW-IT it 0909a 3 Edizione...

Rifilato: in alto: 61,5 mm in basso: 61,5 mm a sinistra: 43,5 mm a destra: 43,5 mm

Controller

Descrizione Istruzioni di programmazione CMXR FTL di base

Descrizione 560 319 it 0909a [748 989]

Festo GDCP-CMXR-SW-IT it 0909a 3

Edizione _____________________________________________________ 0909a

Definizione _________________________________________ GDCP-CMXR-SW-IT

Numero di ordinazione ________________________________________ 560 319

Festo AG & Co KG., D-73734 Esslingen, 2009

Internet: http://www.festo.com

E-Mail: [email protected]

È vietata la riproduzione, distribuzione e diffusione a terzi, nonché l'uso arbitrario, totale o parziale del contenuto della presente documentazione senza la preventiva autorizzazione scritta della Festo. Qualsiasi infrazione comporta il risarcimento di danni. Tutti i diritti riservati, ivi compreso il diritto di deposito brevetti, modelli registrati o di design.

http://www.festo.com/

4 Festo GDCP-CMXR-SW-IT it 0909a

Indice delle revisioni

Autore:

Titolo del manuale: GDCP-CMXR-SW-DE

Nome del file:

Luogo di memorizzazione del file:

N. prog. Descrizione Indice di revisione Data della modifica

001 Stesura 0805NH 25.06.2008

002 Adattamento alla versione 1.20 0909a 25.08.2009

INDICE


INDICE

1. Introduzione ........................................................................................................ 12

2. Avvertenze di sicurezza ....................................................................................... 13

2.1 Utilizzo della documentazione ........................................................................... 13

2.2 Impiego per gli usi consentiti ............................................................................. 13

2.3 Personale qualificato ......................................................................................... 14

2.4 Avvertenze di sicurezza per i prodotti ................................................................ 14

2.5 Avvertenze di sicurezza per questo manuale ...................................................... 14

2.6 Istruzioni di sicurezza per il prodotto descritto .................................................. 15

3. Elaborazione del programma .............................................................................. 16

3.1 Generalità .......................................................................................................... 16

3.2 Interprete .......................................................................................................... 16

3.3 Avvio del programma ......................................................................................... 16

3.4 Calcolo preliminare dei record ........................................................................... 16

3.5 Struttura dei programmi .................................................................................... 18

3.6 Progetti FTL ....................................................................................................... 18

3.6.1 Progetto FTL globale ........................................................................... 19

3.7 File di programma FTL “tip” ............................................................................... 19

3.7.1 Programmi globali del progetto .......................................................... 20

3.8 File di dati FTL “<Nome>.tid” ............................................................................... 20

3.8.1 Dati locali del programma .................................................................. 20

3.8.2 Dati globali del progetto ..................................................................... 21

3.8.3 Dati globali del sistema ...................................................................... 21

3.8.4 Istanziazione di variabili ..................................................................... 22

4. Struttura del linguaggio ...................................................................................... 24

4.1 Formattazione ................................................................................................... 24

4.2 Identificatori ...................................................................................................... 24

4.3 Parole chiave ..................................................................................................... 24

4.4 Costanti numeriche ............................................................................................ 25

4.5 Catene di caratteri ............................................................................................. 25

4.6 Operatori e separatori ....................................................................................... 26

4.6.1 Operatori aritmetici ............................................................................ 26

4.6.2 Operatori logici .................................................................................. 26

4.6.3 Operatori di comparazione ................................................................. 26

4.6.4 Altri operatori ..................................................................................... 27

4.6.5 Separatori .......................................................................................... 27

INDICE


5. Tipi di dati base ................................................................................................... 28

5.1 Tipo di dati booleano (BOOL) ............................................................................. 29

5.2 Tipi di numeri interi, tipo di dati REAL, tipi di schema di codifica a bit ................ 30

5.3 Parentesi ........................................................................................................... 30

5.4 Catene di caratteri (STRING) .............................................................................. 31

5.5 Tipi di dati strutturati ......................................................................................... 31

5.6 Array.................................................................................................................. 31

5.6.1 Inizializzazione degli array .................................................................. 34

5.6.2 Definizione dei limiti degli array con LOW e HIGH ............................... 34

5.7 Variabili di riferimento (mapping) ...................................................................... 36

5.7.1 Dichiarazione di variabili di riferimento, <MAPTO> ............................... 37

5.7.2 Collegamento di variabili di riferimento, <MAP> ................................... 37

5.7.3 Controllo delle variabili di riferimento, <IS_MAPPED> .......................... 37

5.8 Istruzione DO ..................................................................................................... 39

5.8.1 Comportamento nell'area di approssimazione .................................... 41

6. Dichiarazioni di variabili ..................................................................................... 42

6.1 Inizializzazione .................................................................................................. 42

7. Espressioni ......................................................................................................... 43

7.1 Sequenza di esecuzione nelle espressioni ......................................................... 43

8. Comando a programma ....................................................................................... 44

8.1 Istruzioni ........................................................................................................... 44

8.2 Assegnazione del valore <:=>............................................................................. 44

8.3 Condizioni ......................................................................................................... 44

8.4 Diramazione <IF…THEN> ..................................................................................... 45

8.5 Comandi di salto ................................................................................................ 46

8.5.1 Marcatura di salto <LABEL> ................................................................. 47

8.5.2 Salto condizionato <IF…GOTO> ............................................................ 47

8.5.3 Salto assoluto <GOTO> ........................................................................ 48

8.6 Cicli ................................................................................................................... 48

8.6.1 Istruzione WHILE <WHILE> ................................................................... 48

8.6.2 Istruzione LOOP <LOOP> ...................................................................... 49

8.7 Sottoprogrammi ................................................................................................ 50

8.7.1 Richiamo di un sottoprogramma <CALL> .............................................. 51

8.7.2 Ritorno al programma <RETURN> ......................................................... 52

8.8 Programmi paralleli ........................................................................................... 53

8.8.1 Avvio di un programma parallelo <RUN> .............................................. 54

8.8.2 Termine di un programma parallelo <KILL> .......................................... 54

8.9 Modifiche del calcolo preliminare dei record ...................................................... 54

INDICE


8.9.1 Istruzione WAIT con indicazione del tempo <WaitTime> ....................... 54

8.9.2 Istruzione WAIT con condizione <WAIT> ............................................... 56

8.9.3 Istruzione WaitOnPath con indicazione del tempo <WaitOnPath> ........ 58

8.9.4 Istruzione WaitOnPos con indicazione del tempo <WaitOnPos> ........... 60

8.10 Inserimento di commenti <//> ............................................................................. 61

8.11 Disattivazione di una riga di programma <##> .................................................... 61

9. Istruzioni di movimento ...................................................................................... 63

9.1 Descrizione della posizione ............................................................................... 63

9.1.1 Posizione dell'asse ............................................................................. 64

9.1.2 Posizione cartesiana .......................................................................... 66

9.2 Movimento point-to-point <Ptp> ......................................................................... 67

9.3 Movimento point-to-point relativo <PtpRel> ........................................................ 70

9.4 Movimento di un asse, <MoveAxisPtp>, <MoveAxisCart> ...................................... 72

9.5 Movimento lineare <Lin> ..................................................................................... 74

9.6 Movimento lineare relativo <LinRel> ................................................................... 76

9.7 Movimento circolare con punto di appoggio ...................................................... 78

9.7.1 Funzionamento .................................................................................. 78

9.7.2 Definizione del piano .......................................................................... 79

9.7.3 Istruzione circolare con punto di appoggio <CircIp> ............................. 81

9.7.4 Istruzione circolare con punto di appoggio, accostamento PTP <PtpToCircIp> ...................................................................................... 83

9.7.5 Istruzione circolare con punto di appoggio, accostamento Lin <LinToCircIp> ....................................................................................... 85

9.8 Arresto del movimento <StopMove> ................................................................... 86

9.9 Arresto del programma <StopProgram> .............................................................. 87

10. Istruzioni dinamiche ........................................................................................... 88

10.1 Limitazione autom. della dinamica, limitatore dinamico ..................................... 89

10.2 Velocità <Vel> ..................................................................................................... 90

10.3 Accelerazione <Acc> ............................................................................................ 91

10.4 Strappo <Jerk> .................................................................................................... 92

10.5 Override ............................................................................................................ 94

10.5.1 Override dall'unità di comando manuale <Ovr>.................................... 94

10.5.2 Override dinamico <DynOvr> ............................................................... 96

10.6 Rampe di accelerazione ..................................................................................... 97

10.6.1 Impostazione delle forme di rampa <Ramp> ........................................ 98

10.7 Attivazione della velocità di avanzamento costante <VconstOn> ........................ 99

10.8 Disattivazione della velocità di avanzamento costante <VconstOff> .................. 101

INDICE


11. Istruzioni di approssimazione ........................................................................... 102

11.1 Segmenti nulli ................................................................................................. 103

11.2 Campo limite ................................................................................................... 104

11.3 Approssimazione della velocità ....................................................................... 105

11.3.1 Con fattore percentuale <OvlVel> ....................................................... 105

11.4 Approssimazione geometrica ........................................................................... 107

11.4.1 Approssimazione degli assi X, Y e Z <OvlCart> ................................... 107

12. Sistemi di riferimento (spostamento del punto zero) ........................................ 109

12.1 Riferimento del sistema di riferimento ............................................................. 109

12.2 Dati del sistema di riferimento ......................................................................... 110

12.3 Sistema di riferimento con valori diretti <SetRefSys> ........................................ 111

12.4 Sistema di riferimento con 3 punti <SetRefSys3P> ............................................ 112

12.5 Sistema di riferimento globale <SetRefSysWorld> ............................................. 114

12.6 Esempio .......................................................................................................... 114

13. Definizione del riferimento di una cinematica ................................................... 116

13.1 Corsa di riferimento <RefAxis> .......................................................................... 116

13.2 Corsa di riferimento asincrona <RefAxisAsync> ................................................. 118

13.3 Attesa della fine della corsa di riferimento <WaitRefFinished> .......................... 120

13.4 Interrogazione dello stato di un asse <IsAxisReferenced> ................................. 121

14. Utensili ............................................................................................................. 122

14.1 Dati dell'utensile ............................................................................................. 122

14.1.1 Dati del vettore TCP .......................................................................... 122

14.2 Attivazione dei dati dell'utensile <Tool> ............................................................ 125

14.2.1 Effetti dei dati TCP ............................................................................ 125

15. Interfaccia PROFIBUS ........................................................................................ 130

15.1 Indicazioni per l'elaborazione dei segnali ........................................................ 131

15.2 Ingressi e uscite booleani ................................................................................ 131

15.3 Variabili intere a 32 bit..................................................................................... 132

15.4 Posizioni .......................................................................................................... 133

15.5 Sistemi di riferimento ...................................................................................... 134

15.6 Arresto programmato <ProgHold> ..................................................................... 135

16. Sistema di segnalazione ................................................................................... 137

16.1 Testi dei messaggi ........................................................................................... 137

16.2 Informazione <SetInfo> ..................................................................................... 139

16.3 Avvertenza <SetWarning> ................................................................................. 140

INDICE


16.4 Messaggio di errore <SetError> ......................................................................... 141

17. Funzioni ............................................................................................................ 142

17.1 Lettura della posizione corrente <ReadActualPos> ............................................ 142

17.2 Lettura della posizione di arrivo <ReadTargetPos> ............................................ 143

17.3 Salvataggio permanente di un valore di posizione <SavePosition> .................... 144

17.4 Lettura dell'ora del sistema <Time> ................................................................... 144

17.5 Conversione dell'ora in testo <TimeToStr> ........................................................ 145

17.6 Seno <SIN>, <ASIN> ........................................................................................... 146

17.7 Coseno <COS>, <ACOS> ..................................................................................... 147

17.8 Tangente <TAN>, <ATAN> ................................................................................... 149

17.9 Cotangente <COT>, <ACOT> ................................................................................ 150

17.10 Arcotangente2 <ATAN2> ................................................................................... 151

17.11 Logaritmo <LN> ................................................................................................. 151

17.12 Esponente <EXP> .............................................................................................. 151

17.13 Valore assoluto <ABS> ...................................................................................... 152

17.14 Radice quadrata <SQRT> ................................................................................... 152

17.15 Spostamento dei bit <SHR>, <SHL> .................................................................... 153

17.16 Rotazione dei bit <ROR>, <ROL> ......................................................................... 154

17.17 Conversione di un valore in una stringa <STR> .................................................. 155

17.18 Conversione di un valore ASCII in un carattere <CHR> ....................................... 155

17.19 Conversione di un carattere in un valore ASCII <ORD> ....................................... 155

18. Moduli ............................................................................................................... 156

18.1 Funzioni ........................................................................................................... 157

18.2 Variabili ........................................................................................................... 157

18.3 Comportamento in fase di esecuzione ............................................................. 158

18.3.1 Parametro ovlEnable ........................................................................ 158

18.4 Modulo di ingresso digitale DIN ....................................................................... 159

18.4.1 Istanziazione .................................................................................... 159

18.4.2 Metodi ............................................................................................. 161

18.4.3 Attesa dello stato, metodo Wait / WaitN ........................................... 162

18.4.4 Lettura dello stato, metodo Read ..................................................... 162

18.4.5 Fronte ascendente, metodo RisingEdge ............................................ 162

18.4.6 Reset del fronte, metodo ResetRisingEdge ....................................... 163

18.5 Modulo di uscita digitale DOUT ........................................................................ 163

18.5.1 Istanziazione .................................................................................... 163

18.5.2 Variabili ............................................................................................ 165

18.5.3 Metodi ............................................................................................. 166

INDICE


18.5.4 Attesa dello stato, metodo Wait / WaitN ........................................... 167

18.5.5 Lettura dello stato, metodo Read ..................................................... 167

18.5.6 Fronte ascendente, metodo RisingEdge ............................................ 167

18.5.7 Reset del fronte, ResetRisingEdge .................................................... 168

18.5.8 Attivazione e reset, metodo Set / Reset ............................................ 168

18.5.9 Attivazione dell'uscita, metodo Write ............................................... 169

18.5.10 Impostazione dell'uscita per un determinato periodo, metodo Pulse ................................................................................... 169

18.6 Modulo di ingresso analogico AIN .................................................................... 170

18.6.1 Istanziazione .................................................................................... 170

18.6.2 Variabili ............................................................................................ 172

18.6.3 Metodi ............................................................................................. 172

18.6.4 Attesa finché il valore non è inferiore/superiore, metodo WaitLss, WaitGrt .................................................................. 173

18.6.5 Attesa finché il valore non è dentro/fuori dall'intervallo, metodo WaitIns, WaitOuts ................................................................ 174

18.6.6 Lettura del valore, metodo Read ....................................................... 174

18.7 Modulo di uscita analogico AOUT .................................................................... 175

18.7.1 Istanziazione .................................................................................... 175

18.7.2 Variabili ............................................................................................ 176

18.7.3 Metodi ............................................................................................. 177

18.7.4 Scrittura del valore di uscita, metodo Write ...................................... 178

18.7.5 Attesa finché il valore non è superiore/inferiore, metodo WaitLss, WaitGrt ............................................................................... 178

18.7.6 Attesa finché il valore non è dentro/fuori dall'intervallo, metodo WaitIns, WaitOuts ................................................................... 179

18.7.7 Lettura del valore di uscita, metodo Read ......................................... 179

18.8 Modulo orologio CLOCK ................................................................................... 180

18.8.1 Istanziazione .................................................................................... 180

18.8.2 Metodi ............................................................................................. 181

18.8.3 Avvio dell'orologio, metodo Start ..................................................... 182

18.8.4 Arresto dell'orologio, metodo Stop ................................................... 182

18.8.5 Reset dell'orologio, metodo Reset .................................................... 182

18.8.6 Lettura dell'orologio, metodo Read .................................................. 182

18.8.7 Conversione del valore di tempo in una stringa ................................ 183

18.9 Modulo encoder ENCODER .............................................................................. 184

18.9.1 Istanziazione .................................................................................... 184

18.9.2 Variabili ............................................................................................ 185

18.9.3 Metodi ............................................................................................. 185

18.9.4 Impostazione dell'encoder, metodo Set ........................................... 186

18.9.5 Lettura dell'encoder, metodo Read ................................................... 187

18.10 Modulo CANopen COPDEVICE .......................................................................... 187

18.10.1 Istanziazione .................................................................................... 188

INDICE


18.10.2 Metodi ............................................................................................. 188

18.10.3 Scrittura di SDO, metodo WriteSDO .................................................. 189

18.10.4 Lettura di SDO, metodo ReadSDOSigned .......................................... 189

18.10.5 Lettura di SDO, metodo ReadSDOUnsigned ...................................... 191

19. Segnali delle periferiche ................................................................................... 192

19.1 Utilizzo di ingressi e uscite digitali ................................................................... 192

19.2 Utilizzo di ingressi e uscite analogici ................................................................ 192

20. Esempi .............................................................................................................. 194

20.1 Arresto di movimenti ....................................................................................... 194

20.2 Utilizzo dei moduli di ingresso e di uscita ........................................................ 197

20.3 Controllo del calcolo preliminare dei record ..................................................... 198

20.4 Utilizzo delle pinze ........................................................................................... 199

20.4.1 Ventose ............................................................................................ 200

20.4.2 Pinze parallele pneumatiche ............................................................ 203

20.4.3 Unità oscillante di presa pneumatica ................................................ 206

20.5 Utilizzo dell'interfaccia PLC .............................................................................. 210

20.5.1 Definizione del compito .................................................................... 210

20.5.2 Interfaccia PLC.................................................................................. 210

20.5.3 Programma sequenziale ................................................................... 211

21. Struttura a menu delle istruzioni FTL ................................................................ 213

1. Introduzione


1. Introduzione Nel presente documento viene descritto il set di istruzioni FTL (Festo Teach Language) del

controller multiassiale CMXR di Festo con versione del software 1.20 o superiore. La pro-grammazione del controller CMXR avviene con l'unità di comando manuale CDSA-D1-VX o tramite il PlugIn CMXR nel Festo Configuration Tool (FCT).

Fig. 1.1 Controller multiassiale CMXR-C1 Festo Unità di comando manuale CDSA-D1-VX Festo

FTL è un linguaggio di programmazione con un set di istruzioni concepito per la stesura di programmi utente da parte dell'utilizzatore della macchina. La struttura semplificata di questo linguaggio consente di creare cicli di funzionamento della macchina semplici senza

che siano necessarie conoscenze approfondite di programmazione.

Il presente manuale è valido a partire dalla versione software 1.20 del CMXR. Questa è compatibile con la Software-Release 1.

2. Avvertenze di sicurezza



2.1 Utilizzo della documentazione

Il presente documento è concepito per gli operatori e i programmatori di robot che lavorano con il sistema CMXR della Festo. È disponibile un'introduzione all'uso e alla programmazione. Si presuppone un addestramento corrispondente del personale.

2.2 Impiego per gli usi consentiti

Avvertenza

Il sistema CMXR Festo non è previsto per compiti di automazione rilevanti per la sicurezza (ad es.: arresto in caso di emergenza o monitoraggio di velocità ridotte).

Ai sensi della normativa EN-13849-1, il sistema CMXR Festo è conforme solo alla categoria B e non è quindi sufficiente per la realizzazione di funzioni di sicurezza per la protezione delle persone. Per compiti di automazione rilevanti per la sicurezza o per la sicurezza delle persone è necessario adottare ulteriori misure di sicurezza esterne in grado di garantire uno stato di esercizio sicuro del sistema intero anche in caso di errore.

La Festo non assume alcuna responsabilità per danni imputabili alla non osservanza delle indicazioni di pericolo riportate nelle presenti istruzioni d'uso.

Nota

Prima della messa in funzione è necessario leggere completamente le avvertenze di sicurezza riportate al capitolo 2.3 ss.

Nel caso in cui la documentazione in questa lingua non sia perfettamente comprensibile, contattare il fornitore e informarlo al riguardo.

Il funzionamento sicuro e a regola d'arte del sistema di comando presuppone un corretto

trasporto, magazzinaggio, assemblaggio e installazione come pure un comando e una manutenzione accurati.



2.3 Personale qualificato

Nota

Per gli interventi sugli impianti elettrici impiegare solo personale addestrato e qualificato.

2.4 Avvertenze di sicurezza per i prodotti

Avvertenza

PERICOLO !

Smaltire le batterie nel rispetto delle normative per i rifiuti speciali.

Sebbene le batterie abbiano una tensione bassa, in caso di corto-circuito possono rilasciare una corrente sufficiente per causare l'accensione di materiali infiammabili. Per tale motivo non devono essere smaltite insieme a materiali conduttivi (come ad es. trucioli metallici, lana di acciaio imbrattata con olio, ecc.).

ESD

Componenti sensibili alle correnti elettrostatiche: la manipolazione impropria di tali componenti ne può causare il danneggiamento.

Avvertenza

PERICOLO !

Movimenti pericolosi!

Pericolo di morte, gravi lesioni personali o danni materiali dovuti ai movimenti accidentali degli assi!

2.5 Avvertenze di sicurezza per questo manuale

Avvertenza

PERICOLO !

La non osservanza può comportare gravi danni alle cose e alle persone.

Attenzione

La non osservanza può comportare gravi danni materiali.



2.6 Istruzioni di sicurezza per il prodotto descritto

Avvertenza

Pericolo!

Pericolo di morte a causa dei circuiti di arresto d'emergenza insufficienti!

I circuiti di arresto d'emergenza devono essere attivi e raggiungibili in tutti i modi operativi dell'impianto. Lo sblocco del circuito di arresto d'emergenza non deve provocare un riavvio incontrollato dell'impianto!

Controllare il circuito di emergenza prima dell'inserimento!

Avvertenza

PERICOLO !

Pericolo per le persone e le cose!

Testare ogni nuovo programma prima di mettere in funzione l'impianto!

Avvertenza

PERICOLO !

Eventuali trasformazioni e modifiche possono pregiudicare la sicurezza del sistema!

Ne possono conseguire gravi danni alle persone, alle cose o all'ambiente. Eventuali trasformazioni o modifiche dell'impianto con componenti di equipaggiamento di altri produttori devono pertanto essere approvate dalla Festo.

Avvertenza

PERICOLO !

Tensione elettrica pericolosa!

Salvo diversamente indicato, i lavori di manutenzione vanno ese-guiti esclusivamente ad impianto disattivato! L'impianto deve essere protetto contro una riaccensione non autorizzata o accidentale.

Gli interventi di misurazione o verifica sull'impianto eventualmente necessari devono essere eseguiti da elettricisti specializzati.

Attenzione

Utilizzare solo parti di ricambio approvate dalla Festo.

3. Elaborazione del programma



3.1 Generalità

FTL è l'acronimo di Festo Teach Language. FTL è un linguaggio di programmazione

orientato al movimento e serve per la programmazione dei controller CMXR.

Come linguaggio di programmazione per robotica e sistemi di manipolazione, FTL dispone di potenti funzionalità che sono tuttavia semplici da imparare e utilizzare. Ciò permette all'utilizzatore di eseguire una programmazione specifica per la propria applicazione. Le istruzioni sono basate sulla lingua inglese.

3.2 Interprete

I programmi FTL non vengono compilati, bensì elaborati da un interprete. L'interprete carica in memoria i programmi in maniera strutturata all'inizio del lavoro, per poterli poi elaborare in modo ottimale. Questa procedura richiede un breve tempo di reazione, che

varia in base alla lunghezza del programma. Per tale motivo è consigliabile caricare il programma prima dell'avvio in modo da velocizzare la fase di avvio del programma.

3.3 Avvio del programma

Per avviare un programma è necessario caricarlo nel progetto corrispondente. Il carica-mento può avvenire con l'unità di comando manuale o tramite un'unità di comando esterna attraverso un'interfaccia di controllo.

Nota

È possibile caricare solo un progetto dell'utente. Inoltre è sempre caricato il progetto di sistema globale.

L'esecuzione del programma ha inizio dopo il segnale di start, sempre nella posizione attuale del puntatore del programma.

Quando il puntatore raggiunge l'ultima riga del programma sequenziale, il programma viene terminato ma rimane caricato. Se durante la sequenza sono stati avviati programmi paralleli, il programma principale rimane attivo finché questi programmi non sono terminati.

3.4 Calcolo preliminare dei record

Per ottenere una rapida elaborazione del programma, l'interprete calcola anticipatamente un certo numero di istruzioni di movimento. Il calcolo preliminare avviene durante l'esercizio, simultaneamente all'esecuzione del programma, e viene gestito a livello del sistema. Le dimensioni del calcolo preliminare dei record, cioè il numero di istruzioni di movimento che vengono calcolate in anticipo, sono memorizzate nel sistema.



Nota

Il calcolo preliminare dei record fa riferimento alle istruzioni di movimento. Altre istruzioni che si trovano tra le istruzioni di movimento, come ad es. la modifica di valori dinamici o l'elaborazione di variabili, non vengono considerate.

In questo calcolo preliminare dei record, le istruzioni FTL vengono decodificate e messe a disposizione per l'ulteriore calcolazione. Inoltre, in questo calcolo preliminare dei record avviene anche la pianificazione della traiettoria del movimento, che viene calcolata in funzione dei valori dinamici impostati.

Con alcune istruzioni FTL è possibile influire sul calcolo preliminare dei record, che in determinate circostanze può essere ad esempio arrestato. Ciò può risultare utile ad es. nel caso di una diramazione del programma in cui occorre decidere quali segnali di ingresso di una periferica utilizzare. Se il calcolo preliminare dei record si arresta, l'intero set di istruzioni pre-calcolato viene elaborato e la cinematica arresta il movimento. Dopodiché viene ad es. calcolata la decisione adottata per la diramazione del programma e vengono eseguite le istruzioni di movimento seguenti.

Nota

L'interruzione del calcolo preliminare dei record mediante un'istruzione corrispondente può provocare arresti indesiderati sulla traiettoria. Per le istruzioni di questo tipo non è possibile un'approssimazione dei movimenti.

La figura mostra un estratto di un programma FTL. La freccia superiore indica l'istruzione corrente, eseguita in quel momento. La freccia inferiore indica l'istruzione attiva del calcolo preliminare dei record. La distanza tra le due frecce rappresenta il contenuto del calcolo preliminare dei record.

Ulteriori informazioni ed esempi sul calcolo preliminare dei record sono riportati nel capitolo 20.3 Controllo del calcolo preliminare dei record.

Lin(Pos1)

Lin(Pos2)

Lin(Pos3)

Lin(Pos4)

Lin(Pos5)

Lin(Pos6)

Lin(Pos7)

Lin(Pos8)

Lin(Pos9)

Elaborazione

principale dei record

Calcolo preliminare

dei record



3.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 File di programma FTL “tip”

Tutti i programmi FTL appartenenti ad un progetto vengono memorizzati nella relativa directory progetti. Un programma è composto dal codice di programma e dai relativi dati.

Questi vengono memorizzati in file separati, che hanno lo stesso nome ma un'estensione (file extension) differente:

<Nome>.tip Estensione del file per il codice del programma

<Nome>.tid Estensione del file per i dati del programma

Esempio:

Per un programma con il nome “Load” viene creato il file “Load.tip”. Il file con i dati locali del programma si chiamerà “Load.tid”.

Se il programma viene creato con l'unità di comando manuale CDSA o tramite l'editor di programma Festo (nel Festo Configuration Tool), il file per i dati locali del programma viene generato automaticamente. In caso di generazione del programma mediante un software

differente, assicurarsi che per ogni programma venga creato il file di dati corrispondente.

Nota

Se il programma viene generato mediante un software di terze parti, assicurarsi che vengano rispettate le convenzioni per il nome dei file.



3.7.1 Programmi globali del progetto

Il progetto globale di sistema “_global” può contenere, oltre ai dati, anche dei programmi. Questi programmi possono essere utilizzati da tutti i programmi in tutti i progetti.

I programmi globali del sistema offrono una grande comodità d'uso. I programmi che dipendono dalla cinematica utilizzata possono essere definiti e memorizzati in modo autonomo rispetto ai progetti dell'applicazione. Se una cinematica include posizioni fisse, come ad es. una posizione di sicurezza, la sequenza di accostamento a questa posizione può essere memorizzata una sola volta nel progetto globale.

3.8 File di dati FTL “<Nome>.tid”

Nel sistema di comando CMXR i dati servono come variabile e per la comunicazione. La struttura del progetto offre la possibilità di memorizzare i dati in maniera chiara e di limitare l'accesso ai dati. Un file di dati viene contrassegnato con l'estensione "tid" e, così come il file di programma, è basato sul testo. Nel sistema sono possibili:

dati locali di programma all'interno dei singoli programmi,

dati globali di progetto per ogni progetto e

dati globali di sistema per tutti i progetti.

Questa suddivisione permette di scegliere chi può avere accesso ai dati. Anche la comunicazione tra programmi o progetti può essere gestita in questo modo. Con i dati globali di progetto si può comunicare tra i programmi, con i dati globali di sistema si può comunicare tra i progetti.

3.8.1 Dati locali del programma

I dati locali del programma sono noti solo all'interno del programma. Altri programmi o

progetti non hanno accesso a questi dati.

Nota

I dati locali del programma sono noti e validi solo all'interno del rispettivo programma. Altri programmi e progetti non hanno accesso a questi dati.

La figura seguente mostra i programmi “Fill” e “Sort”. Ognuno di questi programmi dispone di dati locali e dati di programma che sono memorizzati nei rispettivi file.



3.8.2 Dati globali del progetto

I dati globali del progetto servono per la comunicazione tra i singoli programmi all'interno di un progetto. I programmi esterni ad un progetto non hanno accesso ai suoi dati.

I dati globali del progetto vengono memorizzati in un apposito file dal nome “_globalvars.tid”. Se un progetto viene creato mediante l'unità di comando manuale CDSA o l'editor di programma FTL, questo file di dati globali del progetto viene generato automaticamente. In caso di creazione del progetto mediante un altro software, ad es. un software di programmazione del cliente, occorre accertarsi che questo file di dati venga creato.

Nota

Se un programma viene generato mediante un software di terze parti, assicurarsi che venga creato il file “_globalvars.tid” nella directory del progetto.

La figura seguente mostra i progetti “FillPalett” e “FeedParts”. Ognuno di questi progetti dispone di dati globali del progetto, che sono memorizzati nel file “_globalvars.tid” presente nella directory del progetto.

3.8.3 Dati globali del sistema

I dati globali del sistema sono noti a tutti i programmi di tutti i progetti a livello di sistema. Questi dati globali del sistema sono assegnati al progetto globale “_global” e memorizzati nel suo file di dati “_globalvars.tid”.

Nota

Poiché tutti i programmi hanno accesso ai dati globali del sistema, questi dati vanno utilizzati con particolare attenzione. L'accesso simultaneo di più programmi a questi dati deve essere monitorato ed eventualmente bloccato nell'applicazione mediante misure corrispondenti.



La figura seguente mostra il progetto globale “_global” in combinazione con dati globali

del progetto e dati locali. Nell'area globale del sistema sono inoltre visualizzati anche programmi globali del sistema.

3.8.4 Istanziazione di variabili

Le variabili vengono create nel file di dati “<Nome>.tid” nella forma seguente:

Sintassi

<nome della variabile> : <tipo di variabile> := <valore>

Il nome delle variabili è liberamente assegnabile. Per ogni riga si può creare una sola variabile.

Esempio:

cpos1 : CARTPOS := (100, 50, 100, 0, 0, 0)

cpos2 : CARTPOS := (600, 550, 100, 180, 0, 0)

index : DINT := 17

I possibili tipi di variabili sono descritti nei capitoli seguenti.



Attenzione

I valori delle variabili che vengono modificati nel programma in fase di esecuzione non vengono registrati nel file di dati sulla scheda di memoria. I valori così modificati rimangono validi fino a quando è caricato il progetto / programma. Con la chiusura del progetto / programma, o in caso di caduta della tensione di alimentazione, i dati modificati nel programma vanno persi.

Nota

Per memorizzare in modo permanente i valori di posizione sulla scheda di memoria, utilizzare la macro “SavePosition”.

4. Struttura del linguaggio



4.1 Formattazione

I file FTL sono file di testo leggibili. Le istruzioni o le dichiarazioni vengono separate mediante interruzioni di riga. In generale si distingue tra lettere maiuscole e minuscole.

4.2 Identificatori

Gli identificatori servono per l'identificazione di progetti, programmi, moduli, variabili, costanti e tipi. Un identificatore consiste in una sequenza di lettere, cifre e del carattere di sottolineatura “_”.

Nota

Sono ammessi i caratteri a…z, A…Z, 0…9 e _ (carattere di sottolineatura). Tutti gli altri caratteri non sono ammessi.

Per gli identificatori si distingue tra lettere maiuscole e minuscole, per cui bisogna fare attenzione che ad es. una variabile venga scritta sempre con le stesse lettere maiuscole e minuscole.

Esempio:

Una variabile con l'identificatore “Indice” è diversa dalla variabile con l'identificatore

“INDICE”. Si tratta di 2 variabili differenti.

Nota

Diversamente dagli identificatori, per i nomi dei programmi e dei progetti non si distingue tra lettere maiuscole e minuscole.

4.3 Parole chiave

Le parole chiave fanno parte del linguaggio FTL. Tutte le parole chiave in FTL vengono scritte in maiuscolo e non devono essere utilizzate come nomi per programmi, variabili o tipi.

Lista di tutte le parole chiave:

CALL IF THEN END_IF ELSIF ELSE

GOTO LABEL WHILE DO END_WHILE LOOP

END_LOOP RETURN RUN KILL OR XOR

MOD AND NOT MAP MAPTO WAIT

BOOL DINT DWORD REAL STRING ARRAY

Allo stesso modo, tutti gli altri tipi di dati derivati sono parole chiave.



Lista di tutte le funzioni:

SIN COS TAN COT LN ABS

SQRT EXP ASIN ACOS ATAN ATAN2

ACOT SHR SHL ROR ROL STR

CHR ORD LOW HIGH

Le limitazioni menzionate valgono inoltre per tutti i nomi di istruzioni come ad es. Lin, Vel, SetError ecc.

4.4 Costanti numeriche

Si distingue tra numeri interi e numeri reali. I numeri interi possono essere scritti in

rappresentazione decimale, duale o esadecimale.

Esempi di numeri interi validi:

Modo di scrittura decimale 100 -100

Modo di scrittura duale 2#1010 -2#1010

Modo di scrittura esadecimale 16#1ABF -16#1ABF

I numeri reali (valori a virgola mobile) possono essere rappresentati con punto decimale o nel modo di scrittura esponenziale. I valori con punto decimale devono avere almeno una

posizione dopo la virgola.

Esempi di numeri reali validi:

Modo di scrittura decimale: 1.01 178.473

Modo di scrittura esponenziale: 1.99E4 1.99e+8 1e-8

4.5 Catene di caratteri

Le catene di caratteri, le cosiddette stringhe, vengono iniziate e terminate con il carattere ". Possono contenere tutti i caratteri stampabili. La lunghezza di una catena di caratteri è limitata a 255 caratteri. Sono ammessi tutti i caratteri del set di caratteri ASCII.

Esempio di una catena di caratteri valida:

“Controller multiassiale CMXR-C1”



4.6 Operatori e separatori

Gli operatori vengono utilizzati nelle espressioni e descrivono il modo in cui i valori delle variabili e le costanti numeriche vengono collegati tra loro. Gli operatori vengono rappresentati prevalentemente tramite caratteri speciali e parole chiave.

4.6.1 Operatori aritmetici

Operatore Significato

+ Addizione

- Sottrazione

* Moltiplicazione

/ Divisione

MOD Operatore modulo

Tabella 4.1 Operatori aritmetici

4.6.2 Operatori logici

Questi operatori possono essere utilizzati su valori logici e su numeri interi. Con i numeri interi funzionano a bit.


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


< Inferiore

<= Inferiore 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 di parametri

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 macro

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

Tipo di dati

Interpretazione Capacità di memoria

Intervallo di valori

BOOL Bit 8 bit TRUE o FALSE

DINT Numero intero 32 bit -2.147.483.648 … +2.147.483.647

DWORD Schema di

codifica a bit

32 bit 32 bit

REAL Numero a virgola

mobile

32 bit sec. IEEE

STRING Catena di

caratteri

max. 255 byte max. 255 caratteri

Tabella 5.1 Tipi di dati base

A seconda del tipo di dati sono possibili diverse operazioni.

Tipo di dati Operazioni

BOOL Operazioni logiche AND, OR, XOR, NOT

DINT Operazioni aritmetiche, operazioni di comparazione

DWORD Operazioni a bit AND, OR, XOR, NOT, SHL, SHR, ROL, ROR, =, <>

REAL Operazioni aritmetiche, operazioni di comparazione

STRING Operazioni di comparazione, +

Tabella 5.2 Operazioni possibili



In linea di principio, un valore può essere assegnato solo a tipi di dati dello stesso tipo.

Tuttavia FTL supporta in parte anche l'assegnazione a tipi di dati diversi. In tal caso viene eseguita una conversione automatica del tipo. Per l'assegnazione a determinati tipi di dati è necessario utilizzare le funzioni integrate STR, CHR e ORD.

Da \ a BOOL Numeri interi Schema di codifica a bit

REAL STRING

BOOL sì --- --- --- STR

Numeri interi --- sì sì sì STR, CHR

Schema di

codifica a bit

--- sì sì --- STR, CHR

REAL --- sì --- sì STR

STRING --- ORD ORD --- sì

Tabella 5.3 Assegnazioni possibili

A seconda del tipo di dati sono possibili le seguenti assegnazioni:

Funzione Operazione

STR Converte un tipo di dati qualsiasi in una stringa.

CHR Converte un valore ASCII in un singolo carattere.

ORD Converte un singolo carattere nel valore ASCII.

Tabella 5.4 Funzioni integrate

5.1 Tipo di dati booleano (BOOL)

Il tipo di dati booleano può assumere i valori TRUE (vero) o FALSE (falso). Viene utilizzato soprattutto per operazioni logiche, anche in combinazione con segnali di periferiche come ad es. ingressi di sensori e uscite di attuatori.

Esempio:

Variabili:

pos1 : BOOL

pos2 : BOOL

pos3 : BOOL

min1PosValid : BOOL

allPosValid : BOOL

Codice del programma:

allPosValid := NOT pos1 AND NOT pos2 AND NOT pos3

min1PosValid := pos1 XOR pos2 XOR pos3



5.2 Tipi di numeri interi, tipo di dati REAL, tipi di schema di codifica a bit

Il linguaggio di programmazione FTL supporta tipi di dati interi (denominati anche tipi Integer), a virgola mobile e a schema di codifica a bit. A seconda dei casi, questi tipi di dati possono essere assegnati l'uno all'altro (vedi capitolo 5 Tipi di dati base a pagina 28). Per queste assegnazioni il sistema esegue automaticamente la conversione interna del tipo.

A seconda della conversione del tipo utilizzata possono verificarsi perdite di precisione. Ad es. durante una conversione da REAL a DINT il sistema elimina le posizioni dopo la virgola.

Esempi di conversioni del tipo:

Variabili:

pressure : REAL

index : DINT


pressure := 1.53

index := pressure // Conversione REAL->DINT

Dopo la conversione, la variabile “index” contiene il valore “1”.

Nota

La funzione di conversione del tipo deve essere utilizzata solo se si conoscono tutte le possibili conseguenze (vedi esempio sopra).

5.3 Parentesi

Con le parentesi vengono raggruppate le calcolazioni in base alla sequenza di elaborazione. L'elaborazione delle parentesi avviene dall'interno all'esterno.

Esempio:

:

IF (Index < 10) AND (Index > 5) THEN

:

END_IF

:

Distance := (xRow + 10) * Index

:



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

5.6 Array

Gli array vengono utilizzati per raggruppare tipi di dati uguali in un'unità ordinata. L'accesso ai singoli elementi dell'array avviene per mezzo di un indice. I limiti dell'array vengono controllati. Ciò significa che se un'operazione da eseguire supera le dimensioni dell'array, viene emesso un messaggio corrispondente.

Dichiarazione degli array:

Sintassi

VAR

<nome> : ARRAY [ <dimensioni array> ] OF <tipo di dati> :=

( <inizializzazione>)

END_VAR



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

sionali. L'esempio seguente mostra un array con 3 x 3 elementi e indice del campo rispettivamente diverso:

Matrix3 : ARRAY [1..3, 5..7, 0..2] OF DINT

5.6.1 Inizializzazione degli array

Il sistema inizializza gli array con il valore 0. Se si desidera un'inizializzazione con un valore diverso è possibile indicarla dopo il tipo di array all'interno delle parentesi tonde.

Esempio:

Matrix1 : ARRAY [7] OF DINT := (0, 1, 2, 3, , , )

Matrix2 : ARRAY [3, 3] OF DINT := ((1, , 9), (3, , 7), (, , 6))

Ogni campo dell'array viene introdotto da una virgola. I campi da non inizializzare non vanno indicati. La virgola è però indispensabile affinché gli altri elementi vengano inizializzati correttamente.

5.6.2 Definizione dei limiti degli array con LOW e HIGH

Con la parola chiave LOW viene definito l'indice del campo inferiore, con HIGH l'indice del

campo superiore di un array.

Sintassi

<variabile : DINT> := LOW( <variabile array> )

<variabile : DINT> := HIGH( <variabile array> )

Alle funzioni LOW ed HIGH viene trasferita una variabile dell'array. Per definire i limiti di un array monodimensionale viene trasferito solo il nome dell'array. Per gli array multidimensionali bisogna sempre specificare la dimensione a cui devono riferirsi i limiti.

Matrix : ARRAY [5, 19, 10..34] OF REAL

I limiti del campo dell'array sono:

Prima dimensione da 0 a 4

o Il richiamo di LOW fornisce 0

o Il richiamo di HIGH fornisce 4

Seconda dimensione da 0 a 18





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

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

Esempio:

IF IS_MAPPED(Level) THEN

:

:

ELSIF

SetError(“Not mapped”)

END_IF



5.8 Istruzione DO

Con l'istruzione DO è possibile eseguire delle istruzioni durante l'elaborazione principale del programma. L'istruzione presenta la seguente sintassi:

Sintassi

<FTL Macro> DO < Macro o istruzione >

L'istruzione specificata dopo DO viene eseguita durante l'elaborazione principale del programma. Il calcolo preliminare del programma non viene influenzato dall'istruzione DO.

Dopo un'istruzione DO può essere indicata una macro o un'istruzione. Non sono ammesse macro o istruzioni riferite ad una cinematica, come ad es. un'indicazione di dinamicità o

una traslazione in posizione. Istruzioni di questo tipo sono ammesse solo prima dell'istru-zione DO, dato che la pianificazione della traiettoria non può gestire le istruzioni che vengono dopo l'istruzione DO.

Nota

L'istruzione DO viene eseguita dopo che è stata eseguita l'istruzione precedente nell'elaborazione principale. L'esecuzione avviene incondizionatamente.

Con l'istruzione DO è possibile ad es. descrivere variabili o settare delle uscite durante

l'elaborazione principale del programma FTL. L'istruzione DO può essere utilizzata in combinazione con tutte le istruzioni di movimento, ad es. Ptp o Lin.

Esempio di attivazione di un'uscita:

Al raggiungimento di pos2 viene attivata l'uscita del modulo Vuoto.

:

Lin(pos1)

Lin(pos2) DO Vacuum.Set()

Lin(pos3)

:



Esempio di descrizione di variabili al PLC:

:

Lin(pos1)

Lin(pos2) DO plc_Dint[3] := 5

Lin(pos3)

:

Con l'istruzione DO si possono impostare procedimenti di commutazione semplici, che vengono poi eseguiti durante l'elaborazione principale del programma FTL. In tal caso non è possibile una compensazione dei tempi di commutazione. Non si ha nessun accoppia-

mento con la velocità di avanzamento lungo la traiettoria. Ciò significa che il comporta-mento di commutazione riferito alla traiettoria può cambiare in caso di modifica della dinamica della traiettoria.

Esempio

Sul contorno seguente si vuole attivare un'uscita digitale sui percorsi diritti e disattivarla negli archi di cerchio.

:

Lin(Pos1) DO Applicator.Set()

Lin(Pos2) DO Applicator.Reset()

CircIp(Ipos1,Pos3) DO Applicator.Set()

Lin(Pos4) DO Applicator.Reset()

CircIp(Ipos2,Pos1)

:

Pos2 Pos1

Pos3 Pos4

Ipos1

Ipos2



1

1 P1

1

1 P1´

1

1 P2

1

1 P0

L'istruzione Do viene eseguita qui.

5.8.1 Comportamento nell'area di approssimazione

Con la funzione di approssimazione attivata, l'istruzione DO non può essere eseguita al raggiungimento del punto programmato poiché questo non viene raggiunto a causa dell'approssimazione. In questo caso viene proiettato ed eseguito il punto di commu-tazione sulla traiettoria dell'area di approssimazione.

Nota

Se i segmenti di movimento convergono tangenzialmente, l'appros-simazione non ha alcun effetto sull'esecuzione dell'istruzione DO.

6. Dichiarazioni di variabili


6. Dichiarazioni di variabili Le dichiarazioni di variabili avvengono nei rispettivi file con l'estensione “tid”, dove vengono definiti il nome della variabile e il tipo di dati. Il nome e il tipo di dati vengono separati tra loro mediante due punti.

Sintassi

<nome> : <tipo>

Esempi di dichiarazioni di variabili valide:

offset : REAL

flag : BOOL

index : DINT

name : STRING

6.1 Inizializzazione

Tutte le variabili FTL vengono inizializzate automaticamente. Le variabili Integer e Real vengono inizializzate con 0, le catene di caratteri (stringhe) con una catena di caratteri vuota (“ ”) e le variabili booleane con FALSE.

Oltre a questa inizializzazione automatica vi è anche la possibilità di inizializzare le

variabili con un determinato valore. In tal caso si parla di inizializzazione esplicita. Il valore iniziale viene specificato dopo l'indicazione del tipo, sotto forma di assegnazione nel file di dati. Le variabili reali possono essere inizializzate anche con valori interi.

Esempi di inizializzazioni valide:

index : DINT := 1

pi : REAL := 3.1415

radius : REAL := 10

flag : BOOL := TRUE

message : STRING := “Hello"

7. Espressioni


7. Espressioni Un'espressione descrive un valore assegnato a un determinato tipo di dati. Un'espres-sione può contenere variabili e funzioni. I componenti di un'espressione vengono collegati mediante operatori.

valore := SQRT(a) – 2*a*b + SQRT(b)

7.1 Sequenza di esecuzione nelle espressioni

Gli operatori in un'espressione vengono elaborati in una determinata sequenza:

1. ( ) (parentesi)

2. [] (indice array)

3. NOT (negazione)

4. * / MOD AND (moltiplicazione, divisione, modulo, logico AND)

5. + - OR XOR (addizione, sottrazione, logico OR /EXOR)

6. < <= = <> >= > (operazioni di comparazione)

8. Comando a programma



8.1 Istruzioni

I programmi FTL sono composti da una successione di istruzioni separate da interruzioni di riga. FTL conosce le istruzioni seguenti:

1. Assegnazione del valore

2. Diramazioni: IF, IF .. GOTO, GOTO .. LABEL, RETURN

3. Cicli di istruzioni: WHILE, LOOP

4. Elaborazione di routine: CALL, richiamo di macro, RUN, KILL

5. Istruzione di sincronizzazione: WAIT

8.2 Assegnazione del valore <:=>

Un'assegnazione del valore è costituita da una definizione di variabile sul lato sinistro, dall'operatore di assegnazione := e da un'espressione sul lato destro. Il tipo di dati

dell'espressione deve poter essere assegnato al tipo di dati della variabile.

Sintassi

<variabile > := <espressione>

Esempi:

i := 1

x := a + b * 2

8.3 Condizioni

All'interno di istruzioni, diramazioni o cicli è possibile formulare delle condizioni. Le con-dizioni possono contenere operandi booleani (ad es. AND, OR) oppure un operando di confronto (ad es. >, <=,=). Il collegamento di più confronti viene strutturato mediante livelli

di parentesi corrispondenti.

Per i seguenti esempi vengono utilizzate le variabili seguenti:

Marker : BOOL

Flag1 : BOOL

Flag2 : BOOL

Flag3 : BOOL

Index : DINT



Esempi di condizioni:

Marker := Index < 10

Marker := Flag1 AND Flag2 OR Flag3

IF Index < 10 THEN

:

END_IF

WHILE Index < 5 DO

:

END_WHILE

WHILE NOT Flag1 AND Flag3 OR Flag2 DO

:

END_WHILE

Esempi di condizioni con parentesi:

Marker := (Index < 10) AND (Index < 0)

Marker := Flag1 AND (Index < 7)

IF (Index < 10) AND (Index > 5) THEN

:

END_IF

8.4 Diramazione <IF…THEN>

L'istruzione IF consente di impostare diramazioni dipendenti da una condizione nell'ese-cuzione del programma. La condizione deve essere del tipo di dati BOOL e può essere composta da più operandi. Con l'istruzione ELSIF si possono formulare più condizioni. Con

l'istruzione ELSE si possono definire istruzioni che verranno saltate nel caso in cui nessuna delle condizioni venga soddisfatta. L'istruzione IF viene terminata con l'istruzione END_IF.



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 dirama-zione del programma IF…THEN, questa istruzione necessita di una condizione che fornisca un risultato del tipo di dati BOOL.

:

Lin(pos15)

Lin(pos16)

Lin(pos5)

Lin(pos6)

:

IF teilOk GOTO lblHome

LABEL lblHome

Decisione di salto

Destinazione di salto



Sintassi

IF <condizione> GOTO <marcatura di salto>

Se la condizione è soddisfatta, cioè il risultato è TRUE (vero), il salto viene eseguito. Se la condizione non è soddisfatta, cioè il risultato è FALSE (falso), i comandi vengono eseguiti nelle righe di programma successive.

8.5.3 Salto assoluto <GOTO>

Diversamente dall'istruzione di salto condizionato IF…GOTO, l'istruzione GOTO è assoluta. Ciò significa che non c'è nessuna istruzione condizionale.

Sintassi

GOTO <marcatura di salto>

L'istruzione GOTO consente di saltare parti di programma con grande facilità. È anche indicata per uscire da cicli di istruzioni del programma.

Nota

In caso di programmazione con l'unità CDSA occorre innanzitutto definire la destinazione di salto (LABEL). Dopodiché si può programmare l'istruzione GOTO.

8.6 Cicli

I cicli sono istruzioni di programma che ripetono un sottoprogramma definito in maniera condizionata o assoluta. In questo modo, a seconda della funzione, è possibile realizzare programmi molto concisi, ad es. per il prelievo di pezzi da un pallet le cui posizioni sono calcolabili grazie alla disposizione nota.

Attenzione

La programmazione di cicli di istruzioni infiniti può pregiudicare il comportamento in fase di esecuzione del controller CMXR. All'interno dei cicli di istruzioni infiniti devono esserci delle istruzioni quali Wait o WaitTime, in modo che il controller CMXR non venga bloccato da un ciclo di istruzioni infinito.

8.6.1 Istruzione WHILE <WHILE>

L'istruzione WHILE serve per ripetere una sequenza di istruzioni finché viene soddisfatta una condizione. Il risultato della condizione deve essere del tipo di dati BOOL. Il ciclo può contenere un numero a piacere di istruzioni. L'istruzione WHILE viene terminata con la parola chiave END_WHILE.



Nota

Un ciclo di istruzioni che viene eseguito molto spesso e non contiene alcuna istruzione WAIT può pregiudicare l'esecuzione di altri programmi FTL. In genere il sistema di comando viene configurato in modo tale che, in un caso simile, venga emessa un'avvertenza e il programma in questione venga interrotto entro breve tempo.

Sintassi

WHILE <condizione> DO

<istruzioni>

END_WHILE

Esempio:

WHILE index < 5 DO

Lin(pos1)

Lin(pos2)

Lin(pos3)

index := index + 1

END_WHILE

8.6.2 Istruzione LOOP <LOOP>

L'istruzione LOOP serve per ripetere una sequenza di istruzioni. Si può specificare diret-tamente quante volte dovranno essere ripetute le istruzioni. Per ogni istruzione LOOP viene automaticamente generata una variabile di ciclo interna, che all'avvio del ciclo viene inizializzata su 1. Il ciclo di istruzioni viene eseguito fino a quando il valore della variabile di ciclo interna supera il valore finale. Se il valore finale è inferiore a 1, il ciclo di istruzioni non viene eseguito ma direttamente saltato. Dopo ogni esecuzione, il valore della variabile di ciclo viene aumentato di uno e il valore finale viene ricalcolato.

Il ciclo può contenere un numero a piacere di istruzioni.

Sintassi

LOOP <numero> DO

<istruzioni>

END_LOOP

Esempi:

LOOP 10 DO // 10 ripetizioni

index := index + 13



END_LOOP

j := 0

...

LOOP j DO // viene saltato poiché j = 0

index := index + 13

END_LOOP

:

8.7 Sottoprogrammi

In un programma si possono richiamare altri programmi, che devono trovarsi nello stesso

progetto del programma attivo o nel progetto globale (_global, vedi capitolo 3.6.1 Progetto FTL globale a pagina 19). Questi programmi richiamati vengono definiti sottoprogrammi.

Nota

Un sottoprogramma non necessita di un identificativo particolare. Esso viene creato esattamente come ogni altro programma e memorizzato in un progetto. Un programma viene classificato come sottoprogramma solamente quando viene richiamato da un programma e non direttamente dal progetto.

Elaborazione:

Mentre il sottoprogramma viene eseguito, il programma dal quale è stato richiamato attende che esso venga terminato. Una volta terminato il sottoprogramma si ritorna automaticamente al programma principale, che viene proseguito.



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 tramite l'istruzione RETURN non è

possibile. In caso di necessità, per questo trasferimento di informazioni si possono utilizzare le variabili corrispondenti.

Nota

Se l'istruzione RETURN viene eseguita nel programma principale, questo viene arrestato e terminato.

Richiamando l'istruzione RETURN in un programma parallelo o in un sottoprogramma, esso verrà terminato. Il programma principale viene proseguito.

Esempio:

:

CALL CheckPart() // richiamo del sottoprogramma CheckPart

IF NOT partOk THEN

partStatus := 10 // variabile globale per il valore di

ritorno

RETURN // fine anticipata del programma

END_IF

Lin(pos3)

:



8.8 Programmi paralleli

Un programma del progetto attivo o del progetto globale può anche essere avviato come processo parallelo. Il sistema operativo del CMXR assicura l'elaborazione parallela di questi programmi. Ciò viene garantito dal sistema multitasking interno.

Nota

Le istruzioni di traslazione ad una cinematica da un programma parallelo sono possibili solo se, in precedenza, non è stata im-partita alcuna istruzione di traslazione dal programma principale. Se viene impartita un'istruzione di traslazione dal programma principale e da un programma parallelo, il sistema emette un errore.

Utilizzo:

I programmi paralleli consentono di creare processi che operano in modo asincrono o solo parzialmente sincronizzato con il programma principale. Un esempio al riguardo è l'azio-namento di un'unità di alimentazione o espulsione che viene comandata con ingressi e uscite. In questo caso l'elaborazione può essere descritta con istruzioni logiche e con l'elaborazione degli ingressi/uscite. A seconda delle esigenze si può eseguire una sincronizzazione con il programma principale mediante le variabili globali.

Schema sequenziale:

In questo esempio il programma “feed” richiama un programma parallelo “calculate”. Il programma richiamato “calculate” attende prima un segnale e incrementa un contatore. Nel frattempo il programma principale “feed” continua a lavorare.

Programma parallelo

Programma principale

Sprungziel



Nota

Se in un programma parallelo viene programmato un ciclo di istruzioni infinito, assicurarsi che tale ciclo non blocchi l'esecuzione degli altri programmi. Con un'istruzione Wait o WaitTime si ha la garanzia che la capacità di calcolo venga ripartita tra gli altri programmi.

8.8.1 Avvio di un programma parallelo <RUN>

Un programma parallelo viene avviato con l'istruzione RUN. Un trasferimento dei parametri al programma da avviare non è possibile. Per trasferire i dati si possono utilizzare le variabili globali.

Sintassi

RUN <nome programma>

Un programma già in esecuzione non può essere contemporaneamente avviato come programma parallelo.

8.8.2 Termine di un programma parallelo <KILL>

Un programma parallelo attivo può essere terminato con l'istruzione “KILL” dal programma principale. Prima vengono arrestati il programma e la cinematica, quindi viene

terminato il programma.

Sintassi

KILL <nome programma>

Anche l'istruzione RETURN provoca il termine di un programma parallelo attivo.

8.9 Modifiche del calcolo preliminare dei record

8.9.1 Istruzione WAIT con indicazione del tempo <WaitTime>

L'istruzione WAIT con indicazione del tempo consente di programmare un tempo di attesa. Questo tempo di attesa influisce sul comportamento di movimento. Provoca un arresto del calcolo preliminare dei record, con il conseguente arresto del movimento. Il tempo di attesa inizia a decorrere dopo che è stata eseguita l'istruzione precedente. Al termine di questo tempo il programma viene proseguito.



Sintassi

WaitTime (<timeMS >: DINT)

Il tempo viene indicato in millisecondi e può essere specificato mediante un valore o una variabile.

Nota

Per sincronizzare il calcolo preliminare dei record con l'elabora-zione effettiva dei record si può utilizzare l'istruzione WaitTime 0.

Esempio:

Un sistema di manipolazione equipaggiato con una pinza preleva i pezzi da un pallet. Per

garantire una presa sicura dei pezzi è necessario un certo tempo di attesa.

Estratto dal programma di movimenti:

:

Lin(pos1) // traslazione sopra posizione di

presa

Lin(pos2) // traslazione verso posizione pinza

Gripper.Set() // chiusura pinza

WaitTime(70) // attesa del tempo di presa di

70 msec

Lin(pos1) // traslazione sopra posizione

di presa

:



Sequenza di movimento:

8.9.2 Istruzione WAIT con condizione <WAIT>

L'istruzione WAIT con condizione permette l'interrogazione di stati binari. Questi stati possono consistere in una singola variabile booleana, in una combinazione di più variabili o in un'interrogazione.

L'istruzione WAIT viene elaborata nel calcolo preliminare dei record, cioè nella fase di calcolo preliminare del controller CMXR. Se la condizione non è soddisfatta, il calcolo preliminare dei record viene arrestato finché non viene soddisfatta la condizione dell'istruzione WAIT.

Se il ritardo temporale è talmente elevato che persino l'esecuzione principale del programma di movimenti raggiunge l'istruzione WAIT, anch'essa viene arrestata, provocando un arresto del movimento. L'esecuzione del programma e il calcolo preliminare vengono proseguiti solamente dopo che la condizione dell'istruzione WAIT è stata soddisfatta.

Tempo di attesa

di 70 msec

Tempo

Velocità di avanzamento

pos1

pos1

pos2

Lin(pos1)

Lin(pos2)

Lin(pos3)

Lin(pos4)

Lin(pos5)

Wait sensor

Lin(pos6)

Lin(pos7)

Lin(pos8)

Lin(pos9)

Elaborazione

principale dei

record

Calcolo

preliminare dei

record

Lin(pos1)

Lin(pos2)

Lin(pos3)

Lin(pos4)

Lin(pos5)

Wait sensor

Lin(pos6)

Lin(pos7)

Lin(pos8)

Lin(pos9)

Elaborazione

principale dei

record

Calcolo

preliminare dei

record

Condizione per WAIT soddisfatta, il calcolo

preliminare dei record viene proseguito.

Condizione per WAIT non soddisfatta, il

calcolo preliminare dei record si arresta

finché la condizione non viene soddisfatta.



Nota

Poiché l'interrogazione della condizione avviene durante il calcolo preliminare dei record, un'eventuale modifica eseguita dopo il calcolo preliminare non viene più registrata. Se lo si desidera, anteponendo l'istruzione WaitTime (vedi capitolo 8.9.1 Istruzione WAIT con indicazione del tempo a pagina 54) è possibile forzare una sincronizzazione con l'elaborazione effettiva dei record.

Nella condizione dell'istruzione WAIT si possono utilizzare i tipi di dati base BOOL, REAL e DINT con operatori logici e operatori di comparazione. Non è consentito utilizzare opera-tori aritmetici e operatori di bit.

Sintassi

WAIT <condizione>

Esempio:

Mediante un piano inclinato i pezzi vengono alimentati in un sistema di manipolazione. Un pezzo presente viene rilevato da un sensore digitale e può quindi essere prelevato dal sistema di manipolazione.

Il sensore rileva se un pezzo si trova sul vassoio. Se il pezzo è presente, viene prelevato dal sistema di manipolazione.

Estratto dal programma di movimenti:

:

Sensore

X

Z

Ventosa

Pezzo

Vassoio

Pos2

Pos1

Pos3

Pos4



Lin(pos2) // traslazione sopra il pezzo

Vacuum.Set() // vuoto inserito

WAIT sensor // attesa del pezzo

Lin(pos1) // traslazione verso il pezzo

Lin(pos2) // traslazione sopra il pezzo

Lin(pos3) // traslazione sopra vassoio

Lin(pos4) // deposizione del pezzo

WaitTime(0) // attesa dell'elaborazione principale

dei record

Vacuum.Reset() // vuoto disinserito

Lin(pos3) // traslazione sopra vassoio

:

Se nel vassoio non c'è nessun pezzo, il sistema di manipolazione rimane in attesa sopra il pezzo, il movimento è arrestato. Appena il sensore segnala “Pezzo presente”, il programma viene proseguito. Se all'avviamento è già presente un pezzo, il sistema di manipolazione si porta subito sull'oggetto senza che il movimento venga interrotto.

8.9.3 Istruzione WaitOnPath con indicazione del tempo <WaitOnPath>

La macro WaitOnPath genera un tempo di attesa che influisce solo sul movimento. Questo tempo di attesa viene registrato direttamente nella pianificazione della traiettoria e gli assi vengono rallentati con la dinamica programmata. Al termine del tempo di attesa viene proseguita la traiettoria successiva. Il calcolo preliminare dei record del programma FTL non viene fermato.

Nota

La macro WaitOnPath non è indicata per sincronizzare istruzioni quali ad es. la commutazione di un'uscita o la descrizione di una variabile con l'esecuzione principale del programma.

Sintassi

WaitOnPath ( <timeMS> : DINT )

Parametro Significato Unità

time Tempo di attesa msec

Tabella 8.1 Parametri dell'istruzione WaitOnPath



Esempio:

Con un punzone viene impressa una marcatura su un pezzo. Al raggiungimento della posizione di stampa è necessario osservare un tempo di attesa di 150 msec per la trasmissione del colore. Il calcolo preliminare dei record non deve tuttavia fermarsi.

:

Lin(pos1) // corsa su posizione di sicurezza

Lin(printPos) // corsa su posizione di stampa

WaitOnPath(150) // attesa di 150 msec

Lin(pos1) // corsa su posizione di sicurezza

:

Tempo di attesa

di 150 msec

Tempo


pos1

pos1

printPos



8.9.4 Istruzione WaitOnPos con indicazione del tempo <WaitOnPos>

La macro WaitOnPos arresta il calcolo preliminare dei record finché il segmento attuale non viene elaborato per il valore percentuale indicato. Dopodiché il programma viene proseguito.

Sintassi

WaitOnPos ( OPT <pos> : REAL )


Pos Valore percentuale per la lunghezza del

segmento di traiettoria

percentuale

Tabella 8.2 Parametri dell'istruzione WaitOnPos

Se è attivata la funzione di approssimazione e la distanza dal punto di destinazione per

l'approssimazione è sufficientemente grande, l'approssimazione viene eseguita. Il parametro del valore percentuale è opzionale. Se non viene indicato, corrisponde al valore 100 %. La conseguenza è un arresto sulla traiettoria.

Nell'esempio seguente viene accostata una posizione e il calcolo preliminare dei record

viene arrestato finché non viene percorso l'80 % del segmento di traiettoria. Dopodiché la variabile Index nell'esempio viene impostata su 10.

Lin(Pos1)

Lin(Pos2)

WaitOnPos(80)

Index := 10

Pos2

Pos1

80 %



8.10 Inserimento di commenti <//>

Un commento viene iniziato con la sequenza di caratteri “//”. Può trovarsi da solo all'inizio di una riga o dopo un'istruzione FTL e termina alla fine della riga.

Sintassi

// <testo a piacere>

Un'istruzione FTL può essere “commentata” con caratteri di commento. Questa istruzione non avrà poi alcun effetto sull'elaborazione del programma.

La figura seguente mostra la maschera di programma dell'unità di comando manuale con un commento e un'istruzione di programma commentata:

8.11 Disattivazione di una riga di programma <##>

Con la sequenza di caratteri “##” vengono disattivate righe di programma per l'elaborazione del programma, ma il controllo della sintassi rimane attivo.

Nota

## <istruzione di programma>

In altre parole:

Un'istruzione FTL disattivata non viene elaborata nel programma, cioè i suoi contenuti non hanno alcun effetto.

I contenuti dell'istruzione di programma vengono sottoposti al controllo della sintassi dal compilatore. Se ad es. viene cancellata una variabile utilizzata, all'avvio del programma viene emesso un errore.



Nota

Per le istruzioni di programma composte da più righe, come ad es. IF..THEN…ELSE, occorre disattivare tutte le relative righe di programma.

La figura seguente mostra la maschera di programma dell'unità di comando manuale con istruzioni di programma disattivate nelle righe 8 ... 10:

9. Istruzioni di movimento


9. Istruzioni di movimento I movimenti di una cinematica vengono attivati con le istruzioni di movimento, che descrivono il movimento dalla posizione attuale al punto di destinazione specificato. Per il movimento vengono considerati i valori impostati in precedenza, come ad es. velocità, accelerazione o orientamento.

I movimenti possono essere di vario tipo. Esistono movimenti con interpolazione degli assi (movimenti point-to-point) e movimenti in uno spazio cartesiano. I movimenti cartesiani fanno riferimento ad una trasformazione interna della cinematica.

9.1 Descrizione della posizione

Tutte le posizioni vengono memorizzate nelle cosiddette variabili di posizione. Queste

variabili di posizione sono necessarie per l'indicazione della posizione nelle istruzioni di movimento. Un'indicazione diretta con le costanti non è possibili. Tutte le variabili di posizione vengono memorizzate nel file di dati corrispondente (vedi capitolo 3.8 File di dati FTL a pagina 20).

Una posizione può essere specificata nel sistema di coordinate degli assi o in un sistema di coordinate cartesiano. Poiché queste indicazioni di posizione hanno un'origine diversa, esistono 2 tipi di dati corrispondenti:

1. AXISPOS per l'indicazione nel sistema di coordinate degli assi,

2. CARTPOS per l'indicazione nel sistema di coordinate cartesiano

Il numero di assi nel CMXR è limitato a 6. Questi assi possono essere suddivisi in assi

cinematici e assi ausiliari. Le posizioni di tutti gli assi vengono memorizzate in una variabile di posizione.

In questo modo il tipo di dati AXISPOS include 9 valori di coordinate. A causa del numero massimo di 6 gradi di libertà, anche il tipo di dati CARTPOS include 9 valori di coordinate, che tuttavia si dividono in 3 indicazioni di posizione, 3 indicazioni di orientamento e 3 assi ausiliari.

Nell'ambiente di programmazione del PlugIn FCT, il numero dei valori di coordinate è limitato al numero degli assi configurati, il resto è bloccato.

Nota

Entrambi i tipi di dati AXISPOS e CARTPOS possono essere utilizzati per istruzioni di movimento. Il controller CMXR esegue automati-camente le conversioni (trasformazioni delle coordinate) in caso di necessità. Informazioni al riguardo sono riportate nella descrizione dell'istruzione.

I tipi di dati AXISPOS e CARTPOS sono del tipo strutturato (vedi capitolo 5.5 Tipi di dati strutturati a pagina 31).



9.1.1 Posizione dell'asse

Una posizione dell'asse viene descritta con il tipo di dati strutturato AXISPOS (vedi capitolo 5.5 Tipi di dati strutturati a pagina 31). Esso comprende 9 posizioni di 9 assi singoli, il cui valore di posizione viene indicato con il tipo di dati REAL. A seconda del modello cinematico selezionato può trattarsi di una selezione o una combinazione di assi lineari o rotativi. L'unità di una posizione viene quindi espressa ad es. in mm o gradi.

Struttura:

A causa del numero massimo di 9 assi di una cinematica, il tipo di dati comprende 9 posizioni di assi. Questi singoli valori di posizione sono memorizzati in 9 singole variabili REAL.

Tipo di dati AXISPOS:

a1 : REAL Posizione asse cinematica 1






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 di rotazione pinza

Gli assi 5 e 6 non sono presenti, nessun asse ausiliario.

Analogamente a questa numerazione viene eseguita l'assegnazione nel tipo di dati Axispos:

a1 : REAL Posizione Asse 1 = Asse X

a2 : REAL Posizione Asse 2 = Asse Y

a3 : REAL Posizione Asse 3 = Asse Z

a4 : REAL Posizione Asse 4 = Asse di rotazione pinza

a5 : REAL Posizione Asse 5, non presente

a6 : REAL Posizione Asse 6, non presente

a7 : REAL Posizione Asse ausiliario 1, non presente





9.1.2 Posizione cartesiana

A differenza della posizione dell'asse del tipo di dati AXISPOS, il tipo di posizione cartesiano CARTPOS descrive una posizione in un sistema di coordinate cartesiano.

Un corpo possiede al massimo 6 gradi di libertà. Mediante questi valori è possibile determinare la posizione e l'orientamento del corpo nello spazio. Questi 6 gradi di libertà vengono descritti con 6 indicazioni nel tipo di dati CARTPOS. Inoltre viene indicata la posizione dei 3 assi ausiliari. Questa indicazione avviene però in una posizione dell'asse, in quanto con gli assi ausiliari non si possono eseguire movimenti cartesiani. Vengono interpolati sulla posizione di arrivo insieme agli assi della cinematica, tuttavia gli assi ausiliari eseguono un'interpolazione point-to-point (Ptp).

Struttura:

Tipo di dati CARTPOS

x : REAL Scostamento lungo l'asse X

y : REAL Scostamento lungo l'asse Y

z : REAL Scostamento lungo l'asse Z

a : REAL Indicazione di orientamento, rotazione intorno all'asse Z

b : REAL Indicazione di orientamento, rotazione intorno all'asse Y ruotato

c : REAL Indicazione di orientamento, rotazione intorno all'asse Z ruotato

aux1 : REAL Posizione asse ausiliario 1



A seconda della cinematica selezionata e del relativo grado di libertà, alcune indicazioni non sono possibili in una posizione cartesiana. Le singole indicazioni di posizione nel tipo di dati CARTPOS non sono correlate agli assi fisici della cinematica, bensì al loro grado di libertà.

La posizione cartesiana comprende le indicazioni per un massimo di 6 gradi di libertà. X, Y e Z sono le posizioni traslatorie, mentre A, B e C descrivono gli orientamenti della posizione. L'orientamento, come nell'intero sistema, viene indicato secondo la convenzione di Eulero ZYZ.

Il tipo di dati CARTPOS è strutturato come il tipo di dati AXISPOS (vedi capitolo 5.5 Tipi di dati strutturati a pagina 31). L'accesso a singoli valori di posizione avviene mediante il

nome dei singoli valori del tipo di dati.

Esempio:

Variabile:

startPos : CARTPOS := (1050, 130, 30, 0, 0, 0, 0, 0, 0)

newPos : CARTPOS := (0, 0, 0, 0, 0, 0, 0, 0, 0)

posX : REAL

posY : REAL



Programma:

:

Lin(startPos) // corsa su StartPos

newPos := startPos // copia di StartPos

newPos.x := newPos.x + 10 // calcolazione di X

newPos.y := newPos.y + 35.7 // calcolazione di Y

Lin(newPos) // corsa sulla posizione

calcolata

:

L'effetto delle singole indicazioni di posizione e di orientamento cartesiane dipende dai gradi di libertà della cinematica.

Esempio:

È data una cinematica parallela (tripode) con 3 assi principali, senza polsi. Con i 3 assi principali presenti vengono coperti i 3 gradi di libertà traslatori X, Y e Z. Poiché non è presente alcun polso, non è possibile eseguire l'orientamento dell'utensile. Una programmazione delle variabili a, b, c, aux1, aux2 o aux3 nell'indicazione di posizione del tipo di dati CARTPOS non ha alcun effetto.

9.2 Movimento point-to-point <Ptp>

Il movimento point-to-point (PTP) è la possibilità più rapida per traslare la punta

dell'utensile (TCP) nella posizione desiderata. Il movimento PTP è un'istruzione di traslazione punto a punto sincrona con posizione di arrivo. Con questa istruzione tutti gli assi vengono avviati contemporaneamente e raggiungono contemporaneamente la posizione di arrivo programmata. Per il movimento vengono utilizzati i valori dinamici attivi in quel momento, ad es. velocità e accelerazione. La dinamica effettiva risulta dalla combinazione delle dinamiche di tutti gli assi interessati al movimento. L'asse più lento determina la dinamica. Il movimento della punta (TCP) risulta in questo caso dalla combinazione del movimento dei singoli assi. Il movimento sulla TCP è indefinito.



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 0 gradi

Asse rotativo a 90 gradi

Andamento approssimativo della traiettoria su TCP

Andamento della traiettoria sull'asse Z




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

L'indicazione della distanza può avvenire nel sistema cartesiano o nel sistema di coordinate degli assi. Il controller CMXR trasforma poi le posizioni in maniera corrispondente.

Esempio:

In un'applicazione di manipolazione un pezzo viene accostato ad un'unità di misurazione in 4 posizioni.

pos2

X-Achse

Asse Z

300

850

207

100

pos3

pos1

150

110

225

1

2

3

4



Variabile:

:

pos1 : CARTPOS := (100, 0, 300, 0, 0, 0, 0, 0, 0)

pos2 : CARTPOS := (207, 0, 225, 0, 0, 0, 0, 0, 0)

pos3 : CARTPOS := (850, 0, 300, 0, 0, 0, 0, 0, 0)

distX : CARTDIST := (110, 0, 0, 0, 0, 0, 0, 0, 0)

distZpos : CARTDIST := (0, 0, 150, 0, 0, 0, 0, 0, 0)

distZneg : CARTDIST := (0, 0, -150, 0, 0, 0, 0, 0, 0)

:

Programma:

:

Ptp(pos1)

Ptp(pos2)

LOOP 3 DO

PtpRel(distZneg)

CALL Check() // richiamo ciclo di prova

PtpRel(distZpos)

PtpRel(distX)

END_LOOP

PtpRel(distZneg)

CALL Check() // richiamo ciclo di prova

PtpRel(distZpos)

PtpRel(distX)

Ptp(pos3)

:

Il ciclo di misura per il pezzo e l'analisi vengono elaborati nel sottoprogramma “Verifica”. A scopo di semplificazione, il contenuto del sottoprogramma non è visualizzato.



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

:

Programma con movimenti PTP:

:

Ptp(pos1) // accostamento

Ptp(takeAbove) // prelievo in alto

MoveAxisPtp(A4, takePos) // rotazione pinza

MoveAxisPtp(A3, 50) // verso il basso

Gripper.Set() // chiusura pinza

MoveAxisPtp(A3, 145) // verso l'alto

MoveAxisPtp(A1, 450) // deposizione in alto

MoveAxisPtp(A4, 180) // rotazione su vassoio

MoveAxisPtp(A3, 50) // deposizione in basso

Gripper.Reset() // apertura pinza

MoveAxisPtp(A3, 145) // deposizione in alto

Ptp(pos2) // allontanamento

:

pos2

X-Achse

Asse Z

50

575

450

145

pos1

prelievo in alto

prelievo in basso

deposizione in alto

deposizione in basso

250

350

300



9.5 Movimento lineare <Lin>

Per un movimento lineare il controller multiassiale CMXR calcola una linea retta che si estende dalla posizione corrente (posizione di partenza) alla posizione programmata (posizione di arrivo). Questo movimento viene calcolato ed eseguito tenendo in considerazione i valori impostati per la traiettoria, come ad es. accelerazione lungo la traiettoria, velocità di avanzamento, orientamenti e dati dell'utensile. Se nell'indicazione della posizione di arrivo viene specificata una modifica dell'orientamento, la traslazione su questa traiettoria avverrà in modo continuo dall'orientamento iniziale sul punto di partenza fino all'orientamento finale.

Il movimento lineare è un movimento cartesiano, ossia il movimento viene calcolato per la cinematica corrente con l'ausilio della trasformazione delle coordinate eseguita internamente. Viene sempre programmata la posizione sulla punta dell'utensile (TCP).

Anche tutti i valori dinamici, quali accelerazione e velocità di avanzamento lungo la traiettoria, vengono ottenuti direttamente sul TCP. Ciò presenta il vantaggio che i valori dinamici per l'utensile sono limitati e noti. Sull'unità pinza agiscono quindi delle forze riproducibili.

Sintassi

Lin (<Pos> : AXISPOS o CARTPOS)


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

Variabile:

:

pos1 : CARTPOS := (100, 50, 100, 0, 0, 0, 0, 0, 0)

pos2 : CARTPOS := (600, 550, 100, 180, 0, 0, 0, 0, 0)

gripper : TCPTOOL := (-100, 0, 97, 0, 0, 0,)

:

Programma:

:

Tool(gripper)

Lin(pos1)

Lin(pos2)

:

Asse X

Asse Y

Asse Z

Asse rotativo con pinza

Vettore su TCP



Come raffigurato, con un movimento lineare il TCP (punta dell'utensile) viene condotto lungo la traiettoria. Tutte le indicazioni di velocità si riferiscono sempre al TCP, e in questo modo viene definito l'andamento della traiettoria. Non è invece prevedibile l'andamento della traiettoria della flangia dell'utensile nel piano X-Y. L'andamento di questa traiettoria risulta dalla costellazione della cinematica e del vettore rispetto al TCP e viene calcolato mediante la trasformazione interna delle coordinate.

9.6 Movimento lineare relativo <LinRel>

L'istruzione Lin relativo funziona in modo analogo alla funzione Lin. In questo caso l'indicazione della posizione viene sommata alla posizione di partenza.

Una possibile applicazione sarebbe ad es. un posizionamento relativo all'interno di una griglia, come nel caso di un pallet.

Sintassi

LinRel (<Dist> : AXISDIST o CARTDIST)


Dist Posizione di arrivo relativa AXISDIST o CARTDIST

Tabella 9.6 Parametri dell'istruzione LinRel

La distanza può essere specificata nel sistema cartesiano o nel sistema di coordinate degli assi. Il controller multiassiale CMXR trasforma poi le posizioni in maniera corrispondente.

X

Y

Asse rotativo

a 0 gradi



Andamento

della traiettoria

su TCP Andamento approssimativo

della traiettoria sull'asse Z



Esempio:

Un contorno contiene tratti di traiettoria che si ripetono. Questi tratti possono essere descritti in modo relativo. Mediante una programmazione a cicli è possibile risolvere facilmente una simile applicazione.

Variabile:

:

pos1 : CARTPOS := (98.5, 100, 0, 0, 0, 0, 0, 0, 0)

pos2 : CARTPOS := (387, 100, 0, 0, 0, 0, 0, 0, 0)

distX : CARTDIST := (57, 0, 0, 0, 0, 0, 0, 0, 0)

distYpos : CARTDIST := (0, 112, 0, 0, 0, 0, 0, 0, 0)

distYneg : CARTDIST := (0, -112, 0, 0, 0, 0, 0, 0, 0)

pos3 : CARTPOS := (1050, 45, 0, 0, 0, 0, 0, 0, 0)

direction : BOOL

:

pos2

X-Achse

Y-Achse

100

1050

387

98.5

45

pos3

pos1

57

112



Programma:

:

Lin(pos1)

Lin(pos2)

direction := TRUE

LOOP 5 DO

IF direction = TRUE THEN

LinRel(distYpos)

ELSE

LinRel(distYneg)

END_IF

LinRel(distX)

direction := NOT direction

END_LOOP

LinRel(distYneg)

Lin(pos3)

:

Con la variabile “direction” viene definita la direzione del movimento relativo dell'asse Y. In questo modo è possibile programmare il movimento con un ciclo di istruzioni.

9.7 Movimento circolare con punto di appoggio

L'interpolazione circolare si differenzia dall'interpolazione lineare non solo per la forma geometrica ma anche per il fatto che, oltre al punto di partenza e al punto finale, occorre indicare anche un punto di appoggio per poter definire il cerchio in modo univoco.

9.7.1 Funzionamento

La definizione del cerchio si effettua con un punto di appoggio, che si deve trovare

sull'orbita circolare, e il punto finale dell'orbita stessa. In caso d'orbita circolare viene accostato prima il punto di appoggio e poi il punto finale. Il raggio dell'orbita circolare risulta da un calcolo interno comprendente punto di partenza, punto di appoggio e punto finale dell'orbita stessa.



La figura seguente mostra un movimento circolare con l'uso di un punto di appoggio:

Il cerchio viene sempre percorso in modo tale che il TCP si sposti dal punto di partenza al

punto finale passando per il punto di appoggio. Il punto di appoggio si trova sempre, per definizione, tra il punto di partenza e il punto finale.

Limitazioni:

Viene emesso un messaggio d'errore se almeno due delle posizioni che definiscono il cerchio occupano la stessa posizione o se tutti i punti si trovano su una linea retta. In questi casi non è possibile calcolare matematicamente l'orbita circolare.

Con questo metodo non può essere descritto un cerchio completo (360°). Perciò un cerchio completo deve essere suddiviso in 2 semicerchi.

L'orientamento del punto di appoggio non viene considerato ai fini dell'interpolazione dell'arco di cerchio. L'interpolazione viene eseguita esclusivamente tra il punto di partenza e il punto finale. Se occorre modificare gli orientamenti all'interno di un arco di cerchio, è possibile scomporre un arco di cerchio in più parti e poi impostare gli orientamenti desiderati sul punto di partenza e sul punto finale.

9.7.2 Definizione del piano

L'orbita circolare viene percorsa su un piano definito sulla scorta dei 3 punti, punto

iniziale, punto di appoggio e punto finale. Il piano sul quale viene percorsa l'orbita circolare si estende nello spazio in base a questa definizione.

Punto di appoggio

Punto iniziale

Punto finale

Punto di appoggio

Punto iniziale

Punto finale



La figura mostra un'orbita circolare con i suoi 3 punti di appoggio che definiscono, nello spazio, il piano su cui si trova l'orbita stessa.

Nota

L'orbita circolare si trova sempre su un piano, non è possibile un'interpolazione a vite che richiede un'interpolazione supplementare perpendicolare al piano.

Punto di appoggio

Punto iniziale

Punto finale

Piano definito da 3 punti



9.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 terminale dell'arco di

cerchio

AXISPOS o CARTPOS

Tabella 9.7 Parametri dell'istruzione CircIp

L'indicazione delle posizioni può avvenire nel sistema cartesiano o nel sistema di coordinate degli assi. Il controller multiassiale CMXR trasforma poi le posizioni in maniera corrispondente.

Avvertenza

L'istruzione circolare richiede l'indicazione del punto di appoggio e del punto finale. Il punto di partenza viene formato dal punto finale del movimento precedente. Se tale punto viene spostato, si ha una variazione dell'orbita circolare. Questa variazione potrebbe essere indesiderata e provocare una collisione. La variazione del punto di partenza non deve provocare messaggi di errore perché il risultato è matematicamente corretto.



Esempio:

Con una cinematica si deve percorrere il contorno seguente:

L'asse Z rimane sulla coordinata 0. Il punto di partenza dell'arco di cerchio viene accostato mediante un'istruzione di traslazione separata, ad es. Ptp o Lin.

Variabili:

:

pos1 : CARTPOS := (950, 500, 0, 0, 0, 0, 0, 0, 0)

pos2 : CARTPOS := (455, 300, 0, 0, 0, 0, 0, 0, 0)

IpPos : CARTPOS := (1050, 400, 0, 0, 0, 0, 0, 0, 0)

EndPos : CARTPOS := (950, 300, 0, 0, 0, 0, 0, 0, 0)

:

Programma:

:

Lin(pos1) // accostamento punto di partenza

CircIp(IpPos, EndPos) // movimento circolare su punto

finale

Lin(pos2) // allontanamento

:

Posizione pos1

Punto di appoggio IpPos

Punto finale EndPos

Posizione pos2

Asse X

Asse Y

300

400

500

1050

950

455



9.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 piano per l'asse Z è pari a 0. Il punto di partenza dell'arco di cerchio viene accostato con un movimento PTP (Point-To-Point). Il punto di partenza viene trasferito all'istruzione PtpToCircIp.

Variabili:

:

StartPos : CARTPOS := (950, 500, 0, 0, 0, 0, 0, 0, 0)

IpPos : CARTPOS := (1050, 400, 0, 0, 0, 0, 0, 0, 0)

EndPos : CARTPOS := (950, 300, 0, 0, 0, 0, 0, 0, 0)

Pos1 : CARTPOS := (455, 300, 0, 0, 0, 0, 0, 0, 0)

:

Programma:

:

// accostamento PTP, movimento circolare cartesiano

PtpToCircIp(StartPos, IpPos, EndPos)

Lin(Pos1) // allontanamento

:

Posizione di partenza StartPos


Punto 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 par-

tenza dell'orbita. L'avvicinamento all'orbita circolare avviene ora in modo cartesiano. Ciò significa che il movimento sul punto di partenza e l'orbita circolare in caso di approssi-mazione possono realizzarsi geometricamente. È possibile anche una velocità di avanzamento costante lungo la traiettoria.

Sintassi

LinToCircIp (<StartPos> : AXISPOS o CARTPOS,

<IpPos> : AXISPOS o CARTPOS,



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 piano per l'asse Z è pari a 0. Il punto di partenza dell'arco di cerchio viene accostato con un movimento lineare. Il punto di partenza viene trasferito all'istruzione LinToCirc.

Posizione di partenza StartPos


Punto 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.8 Arresto del movimento <StopMove>

Con l'istruzione StopMove viene arrestata la cinematica e tutti i dati calcolati per la

traiettoria vengono annullati. L'istruzione ha effetto sul calcolo preliminare dei record.

L'arresto della cinematica viene eseguito con la rampa di decelerazione massima definita

per questa evenienza. Eventuali riduzioni della dinamica mediante un comando di override non hanno alcun effetto in caso di arresto.

Sintassi

StopMove()

Una possibile applicazione per questo arresto è ad es. la corsa contro un ostacolo rilevata da un sensore. Una volta rilevato questo stato, il movimento viene arrestato con l'istruzione StopMove. Nel capitolo 20.1 Arresto di movimenti a pagina 194 è descritto un esempio di utilizzo dell'istruzione StopMove.



9.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 l'impostazione dei valori dinamici nel Festo Configuration Tool:



10.1 Limitazione autom. della dinamica, limitatore dinamico

Per garantire la fedeltà alla traiettoria è necessario confrontare i valori dinamici nominali con i possibili valori dinamici fisici, in modo da escludere un superamento dei valori mas-simi possibili dei singoli assi. I valori in questione riguardano la velocità, l'accelerazione e lo strappo. Questi valori massimi sono memorizzati nella configurazione dei singoli assi.

Il controller CMXR dispone di un limitatore dei valori dinamici, denominato limitatore dinamico. Il limitatore opera nel calcolo preliminare del programma FTL e confronta costantemente i valori dinamici di traslazione con i valori dinamici massimi possibili dei singoli assi.

Nota

Il limitatore dinamico è costantemente attivo e non deve essere attivato.

Un intervento del limitatore dinamico dipende da:

dimensioni della dinamica programmata

costellazione della traiettoria del movimento, dalla quale risultano i valori dinamici per i singoli assi.

Se a causa della dinamica programmata o in seguito alla modifica della traiettoria del movimento viene superato il valore massimo di almeno un asse, la dinamica della traiettoria viene ridotta in modo tale che l'asse venga traslato entro i suoi limiti. La traiet-toria non viene abbandonata. Quando la cinematica esce da una traiettoria di movimento critica ed è possibile un valore dinamico più alto, ciò viene riconosciuto dal sistema che provoca un'accelerazione fino al valore programmato.

Nell'esempio seguente viene raggiunto il limite di un asse, per cui la velocità di avanza-mento viene automaticamente ridotta per garantire la fedeltà alla traiettoria. Appena l'asse abbandona l'area critica, il movimento viene nuovamente accelerato fino al valore programmato.

Velocità di

avanzamento

Limite dell'asse

Riduzione della velocità di

avanzamento

Limite del singolo asse

raggiunto



10.2 Velocità <Vel>

Con l'istruzione Vel è possibile indicare la velocità per un movimento cartesiano e un

movimento PTP. L'unità di comando riduce i valori indicati, adattandoli alle velocità massime possibili dei singoli assi interessati al movimento. Se si verifica una limitazione a causa delle velocità massima possibili degli assi, viene emesso un messaggio corrispondente.

Sintassi

Vel (<Mode> : ENUM, <Value> : REAL)


Mode Tipo di velocità Enumerazione: dynPtp, dynCart

Value Valore di velocità Indicazione della velocità

Tabella 10.1 Parametri dell'istruzione Vel

Enumerazione parametro Mode

Tipo di movimento Unità

dynPtp Point-To-Point %

dynCart cartesiano mm/sec

Tabella 10.2 Unità del parametro Value

Esempio:

Variabile:

:

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

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

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

:

Programma:

:

Vel(dynPtp, 30) // velocità per PTP al 30 %

Ptp(axis0)

Vel(dynCart, 500) // velocità di avanzamento a

500 mm/sec

Lin(axis1)

speed := 85

Vel(dynPtp, speed) // velocità per PTP all'85 %

Ptp(axis3)

:



10.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 mm/sec² o gradi/sec²

ValueDec Valore per la decelerazione

(indicazione opzionale)

mm/sec² o gradi/sec²

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

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 imposta-zione è possibile variare con semplicità i valori di accelerazione, velocità e strappo. La traiettoria programmata non viene influenzata.

Nota

Se si desidera ridurre solo la velocità è consigliabile modificare direttamente il valore della velocità. Una riduzione mediante l'override influisce anche sull'accelerazione e sullo strappo. La dinamica degli assi non viene così completamente sfruttata e il movimento finale risulta più lento.

Esistono 2 tipi di override: override dinamico, che influisce sui valori impostati per velocità, accelerazione e

strappo override dall'unità di comando manuale

Funzionamento dell'override

Dinamica = dinamica programmata * override dinamico

10.5.1 Override dall'unità di comando manuale <Ovr>

L'override corrisponde all'impostazione sull'unità di comando manuale CDSA-D1-VX tramite i tasti V+ e V-. L'override viene specificato nell'unità percentuale, dove 100 % corrisponde al valore dinamico massimo programmato. Una diminuzione dell'override provoca un rallentamento della dinamica, senza però che la traiettoria venga modificata.

La figura mostra i tasti V- e V+ per l'impostazione dell'override sull'unità di comando manuale CDSA-D1-VX.

L'override è particolarmente utile durante la messa in servizio. Nell'esercizio automatico deve però trovarsi al 100 % per consentire un pieno utilizzo della capacità dinamica. I relativi adattamenti dei valori dinamici vanno eseguiti direttamente con le istruzioni per la velocità e l'accelerazione.

Con l'istruzione Ovr si può impostare un valore di override direttamente nel programma.

Ciò ha lo stesso effetto di una modifica tramite i tasti dell'unità di comando manuale.



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 la macro Ovr. L'utilizzo di Ovr provoca un arresto del calcolo preliminare, con un conseguente arresto sulla traiettoria.

Un'approssimazione verso il segmento di traiettoria successivo non è possibile.

Esempio:

// impostazione dell'override al 100%

Ovr(100)

Lin(pos1)

Lin(pos2)

// impostazione dell'override al 60%

Ovr(60)

Lin(pos3)

Lin(pos4)



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

Tempo


pos4

pos3

pos2

pos1

60 %

100 %



10.6 Rampe di accelerazione

Con l'istruzione Ramp è possibile impostare una forma di rampa per l'accelerazione o la

decelerazione. Sono disponibili quattro forme di rampa. Dopo l'avvio è attivata la rampa sinusoidale.

Illustrazione delle 4 forme di rampa:

Rampa trapezoidale

La rampa trapezoidale provoca un andamento trapezoidale dell'accelerazione. Lo strappo assume quindi un andamento di forma rettangolare. Con la rampa trapezoidale si possono realizzare i tempi di esecuzione più rapidi della traiettoria.

Con un parametro opzionale è possibile modificare la forma della rampa. Questo parametro può assumere valori > 0 e <= 0,5. Con un valore pari a 0,5 si ottiene un triangolo di accelerazione, con un valore ad es. di 0,1 la forma della rampa si avvicina a quella di un profilo rettangolare.

Se il parametro opzionale non viene specificato, il sistema imposta automaticamente il fattore 0,5. Ne risulta il triangolo di accelerazione.

Rampa di forma trapezoidale con un fattore di ca. 0,1

Rampa di forma trapezoidale con un fattore 0,5

Tempo

Accelerazione

0

0,2

0,4

0,6

0,8

1

1,2

0,000 0,333 0,667 1,000

Besch

leu

nig

un

g

Zeit

TrapezTrapezoid Sine

JMin. jerk Sine square

Acc

eler

atio

n

Acc

eler

atio

n

Acc

eler

atio

n

Acc

eler

atio

n



Rampa sinusoidale

La rampa sinusoidale presenta il vantaggio che non solo l'accelerazione ma anche lo strappo assume un andamento sinusoidale. Ciò provoca un andamento dell'accelerazione più morbido rispetto a quello della rampa trapezoidale. Tuttavia, il tempo d'esecuzione per il raggiungimento della velocità è leggermente più lungo.

Rampa quadra sinusoidale

La rampa quadra sinusoidale ha l'andamento della traiettoria più morbido, ma richiede anche il tempo d'esecuzione più lungo per percorrere la traiettoria.

Rampa MinimumJerk

La rampa Minimumjerk è una forma di rampa speciale, che rappresenta un compromesso

tra tempo d'esecuzione e morbidezza del movimento. L'andamento dell'accelerazione è simile a quello di un profilo sinusoidale, mentre l'andamento dello strappo non è sinusoidale ma a dente di sega. Si ottiene quindi un movimento morbido con un tempo d'esecuzione più veloce.

Nota

Il tipo di rampa da utilizzare dipende dalla cinematica utilizzata e dall'applicazione. Una volta selezionata la forma della rampa è necessario testarla nel movimento.

10.6.1 Impostazione delle forme di rampa <Ramp>

Con l'istruzione Ramp si può selezionare una forma di rampa, che verrà utilizzata con tutte

le istruzioni di movimento successive.

Sintassi

Ramp( <Ramptype> : ENUM, OPT <Param> : REAL)


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 VconstOn

Nota

Qualora sia necessaria una velocità di avanzamento costante, assicurarsi che per l'area di approssimazione sia impostata un'approssimazione geometrica (vedi capitolo 11.4 Approssimazione geometrica a pagina 107). Un'approssimazione basata sulla velocità percentuale provoca una modifica della velocità di avanzamento nell'area di approssimazione.

Il controller multiassiale calcola la velocità di avanzamento possibile in base alla traiettoria e ai valori dinamici massimi dei componenti meccanici. Il limite della velocità di avanza-mento possibile viene determinato dalla dinamica dei componenti meccanici. Se vengono programmati segmenti di traiettoria che non possono essere percorsi con una velocità



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 precisione. Per utilizzare la funzione di approssimazione è neces-sario attivarla con le funzioni corrispondenti.

L'approssimazione può essere di due tipi:

1. Approssimazione della velocità in base alla velocità

2. Approssimazione della posizione in base a una distanza prestabilita

Questi due tipi di approssimazione vengono descritti nelle pagine seguenti.

Aree di approssimazione,

curve polinomiali

Posizione 1 Posizione 2

Traiettoria della cinematica



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 automaticamente l'area di approssimazione massima possibile, rappresentata dai cerchi pieni di colore grigio.

Nota

L'approssimazione è limitata al 50 % della lunghezza del segmento della traiettoria. Se l'area di approssimazione è maggiore del valore massimo possibile, il controller multiassiale CMXR la accorcia automaticamente al 50 % della lunghezza del segmento della traiettoria.

Nota

Lunghezze dei segmenti di traiettoria troppo piccole possono portare a cali indesiderati della dinamicità in caso di riduzione dell'area di approssimazione definita. Per ovviare a tale incon-veniente è necessario adattare la traiettoria o l'area di approssi-mazione.

Campo di raccordo programmato Campo di raccordo sovrapposto

Campo di raccordo generato dal sistema di comando

Traiettoria percorsa



11.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 approssimazione più grande

I valori inferiori al 100 % forniscono tolleranze di posizionamento più ridotte, ma allungano la durata del movimento in quanto la velocità deve essere ridotta. Con un valore del 100 % vengono utilizzate tutte le riserve di accelerazione degli assi con una tolleranza di posizionamento possibilmente bassa. Con valori compresi tra 100 % e 200 % vengono aumentate le tolleranze di posizionamento (errori di posizionamento), mentre le accelerazioni degli assi vengono ridotte rispetto ad un'impostazione al 100 %.

La figura seguente mostra i profili di velocità per una corsa sulla posizione 1 e la posizione 2. Per l'area di approssimazione sono definiti valori differenti.



La grafica 1 mostra un profilo di velocità nel quale non si è verificata nessuna sovrappo-sizione. Gli assi rallentano sulla traiettoria e, in questo modo, le posizioni 1 e 2 vengono

raggiunte con precisione. Nella grafica centrale è raffigurata una sovrapposizione parziale, nella grafica in basso una sovrapposizione completa (100 %) dei profili di velocità.

Nota

Nell'area di approssimazione viene sfruttata la dinamica completa degli assi. Ciò significa che il tratto di traiettoria nell'area di approssimazione non è un raggio bensì una curva polinomiale derivata dagli attuali valori dinamici degli assi.

Esempio:

:

OvlVel(100) // approssimazione al 100 %

Lin(pos1)

Lin(pos2)

OvlVel(75) // approssimazione al 75 %

Lin(pos3)

:

0 %

50 %

100 %

1) Senza sovrapposizione

2) Sovrapposizione parziale

3) Sovrapposizione completa

Tempo ciclo

Tempo ciclo

Tempo ciclo

Direzione Y

Campo del raccordo

Direzione X



11.4 Approssimazione geometrica

Con l'approssimazione geometrica vengono definite le tolleranze dalla posizione terminale programmata. Rispetto all'approssimazione della velocità, lo spostamento viene indicato geometricamente, cioè in unità di lunghezza o angolari.

Nell'approssimazione geometrica si distingue tra un'approssimazione degli assi cartesiani X, Y e Z e degli assi di orientamento.

Nota

L'approssimazione geometrica può essere utilizzata solo per i movimenti cartesiani. I movimenti PTP non sono possibili con questo tipo di approssimazione.

Non è indicata per l'arrotondamento degli angoli, in quanto la forma geometrica nell'area di approssimazione non è un raggio bensì una curva polinomiale. Un raggio non è indicato per l'approssimazione in quanto provoca un brusco aumento dell'accelerazione.

11.4.1 Approssimazione degli assi X, Y e Z <OvlCart>

L'approssimazione di movimenti cartesiani con una definizione geometrica viene ottenuta indicando una distanza del TCP sulla traiettoria fino al punto di destinazione.

Il movimento di approssimazione viene iniziato all'ingresso nella sfera e terminato nel punto in cui la sfera interseca il segmento di traiettoria successivo. Questa curva si snoda in modo tangenziale rispetto ai 2 segmenti di traiettoria interessati. Il limite dell'area di approssimazione è formato dalla metà del più breve dei segmenti di traiettoria interessati.

La traiettoria nell'area di approssimazione non è un raggio ma un polinomio di quinto

ordine. Questo polinomio genera l'andamento più morbido possibile della traiettoria, che non sarebbe possibile con un arco di cerchio.

Sintassi

OvlCart (<Distance> : REAL)

Sfera con area di

approssimazione




Distance Area di approssimazione, distanza dal punto

finale

Unità di lunghezza impostata

Tabella 11.2 Parametri dell'istruzione OvlCart

Nota

Un'approssimazione geometrica è molto spesso necessaria in combinazione con una velocità di avanzamento costante. Questa viene impostata con l'istruzione VconstOn (vedi capitolo 10.7 Attivazione della velocità di avanzamento costante a pagina 99).

Esempio:

Un contorno deve essere percorso con velocità di avanzamento costante e con un'area di approssimazione di 5 mm.

Vel(dynCart, 300) // velocità di avanzamento a 300 mm/sec

VconstOn(25, TRUE) // attivazione velocità avanzamento

costante

OvlCart(5) // impostazione area di approssimazione

Lin(p1)

Lin(p2)

Lin(p3)

Lin(p4)

Lin(p5)

Lin(p6)

p6

p1 p2

p3 p4

p5

Area di approssimazione

12. Sistemi di riferimento (spostamento del punto zero)



I sistemi di riferimento sono sistemi di coordinate cartesiane con 3 gradi di libertà traslatori e 3 rotatori. La definizione dell'orientamento è basata sulla convenzione di Eulero ZYZ.

Nota

Essendo di tipo cartesiano, i sistemi di riferimento non hanno alcun effetto sullo zero di singoli assi nel sistema di coordinate degli assi. Essi hanno effetto solamente sul sistema di coordinate cartesiane.

All'avvio di un programma è attivo il sistema di coordinate globali.

12.1 Riferimento del sistema di riferimento

Un sistema di riferimento è riferito allo zero cartesiano di un sistema di coordinate già definito. I valori definiti del nuovo sistema di riferimento provocano uno scostamento nei 6 gradi di libertà.

Come visibile nella figura è possibile definire più sistemi di riferimento sullo zero cartesiano di un altro sistema di riferimento, mentre può essere attivo un solo riferimento.

Nota

Una nidificazione dei sistemi di riferimento va utilizzata con molta attenzione. Questo meccanismo può favorire una programmazione più efficiente in determinati casi, ma rende meno trasparente la lettura del programma. Inoltre una nidificazione non ottimale può provocare eventuali collisioni.

X

Y

Z X

Y

Z

X

Y

Z

Zero del sistema di

coordinate globali

Scostamento 1

Scostamento 2

X

Y

Z

Scostamento additivo

sullo scostamento 2



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 riferi-mento agisce in modo additivo. Per creare un rimando al sistema di coordinate globali della cinematica occorre definire il riferimento sulla variabile di sistema _system.world.

Esempio:

Dati:

refsysdata0 : REFSYSDATA := (MAPX("_system.world”),

100, 150, 0, 0, 0, 0)

Programma:

SetRefSys(refsysdata0)



12.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 Lunghezze e unità angolari

Tabella 12.2 Parametri dell'istruzione SetRefSys3P

Utilizzo:

Questo tipo di descrizione di un sistema di riferimento offre la possibilità di eseguire la programmazione mediante “teach-in” utilizzando 3 posizioni. Queste 3 posizioni sono di tipo cartesiano con 6 gradi di libertà.

Significato delle posizioni:

La prima posizione definisce l'origine del sistema di riferimento.

La seconda posizione definisce un punto attraverso il quale passa l'asse X cartesiano positivo del sistema di riferimento.

La terza posizione definisce un punto sul piano XY.

Nota

Gli orientamenti delle posizioni non sono importanti. Per le calcolazioni sono necessarie solo le posizioni cartesiane.

Struttura del tipo di dati REFSYS3P:

baseRs : REFSYS Riferimento ad un altro sistema di riferimento

p0 : CARTPOS Origine del sistema di riferimento da definire

px : CARTPOS Posizione lungo l'asse X

pxy : CARTPOS Posizione sul piano X-Y

Con il parametro baseRs si può indicare un altro riferimento sul quale il sistema di

riferimento agisce in modo additivo. Per creare un rimando al sistema di coordinate globali della cinematica occorre definire il riferimento sulla variabile di sistema _system.world.



Procedura per la programmazione mediante “teach-in”:

Attenzione

Il terzo punto determina il piano XY positivo. A seconda della posizione del terzo punto può verificarsi una rotazione del sistema di coordinate, ad es. una rotazione di 180 gradi dell'asse Z.

Esempio:

Dati:

refsys3p0 : REFSYS3P := (MAPX(“_system.world”),

(100, 100, 0, 0, 0, 0, 0, 0, 0),

(200, 100, 0, 0, 0, 0, 0, 0, 0),

(200, 200, 0, 0, 0, 0, 0, 0, 0))

Programma:

SetRefSys3P(refsys3p0)

Secondo punto = asse X positivo

Primo punto = origine

Terzo punto = piano XY positivo

Terzo punto = piano XY positivo



12.5 Sistema di riferimento globale <SetRefSysWorld>

Con questa istruzione viene attivato il sistema di riferimento globale, la cui origine è memorizzata nella configurazione della cinematica.

Sintassi

SetRefSysWorld()

Se è stato impostato (attivato) un sistema di riferimento con l'istruzione SetRefSys o SetRefsys3P e si desidera disattivare questo sistema di riferimento in un determinato punto del programma, utilizzare l'istruzione SetRefSysWorld.

12.6 Esempio

Nell'esempio seguente si devono svuotare 2 pallet e poi alimentare i pezzi in una macchina.

Entrambi i pallet hanno lo stesso contenuto e le stesse dimensioni. Per minimizzare il lavoro di programmazione viene impostato un sistema di riferimento specifico per ogni

pallet e il programma del pallet viene creato come sottoprogramma.

Per il sistema di riferimento del pallet 1 viene utilizzata la variabile RefPal1, per il pallet 2 la variabile RefPal2.

Dati:

:

refPal1 : REFSYSDATA := (MAPX(“_system.world”),

0, 0, 0, 0, 0, 0)

Alimentazione macchina

X

Y

Pallet 1 Pallet 2

Sensore per rilevare se

la posizione è libera

300

300 1500



refPal2 : REFSYSDATA := (MAPX(“_system.world”),

0, 0, 0, 0, 0, 0)

pos1 : CARTPOS := (100, 80, 70, 0, 0, 0, 0, 0, 0)

:

Programma:

:

refPal1.x := 300 // scostamento pallet 1 in X

refPal1.y := 300 // scostamento pallet 1 in Y

refPal2.x := 1500 // scostamento pallet 2 in X

refPal2.y := 300 // scostamento pallet 2 in Y

Lin(pos1) // corsa su pos. sicurezza nel sistema

globale

SetRefSys(refPal1) // attivazione scostamento pallet 1

CALL Feed() // richiamo sottoprogramma per

alimentazione pezzi

SetRefSys(refPal2) // attivazione scostamento pallet 2

CALL Feed() // richiamo sottoprogramma per

alimentazione pezzi

SetRefSysWorld() // attivazione sistema globale

Lin(pos1)

:

13. Definizione del riferimento di una cinematica



13.1 Corsa di riferimento <RefAxis>

L'istruzione RefAxis consente di definire i riferimenti degli assi. La corsa di riferimento

viene sempre eseguita con un solo asse.

Sintassi

RefAxis(<axis>:AXIS, OPT <refData>:REFDATA, OPT <timeout>:REAL)


Axis Asse selezionato per la definizione del riferimento. Enumerazione A1, A2, fino

ad A9

refData Record di dati della corsa di riferimento, ad es. su come viene

eseguita la definizione del riferimento.

nessuna

timeout Tempo per lo svolgimento dell'operazione (dopodiché viene

emesso un messaggio d'errore, la definizione del riferimento

viene interrotta).

Secondi

Tabella 13.1 Parametri dell'istruzione RefAxis

Durante l'esecuzione della corsa di riferimento assicurarsi che gli assi interessati non vengano ostacolati nei loro movimenti. Il movimento viene eseguito come movimento degli

assi. In base al tipo di cinematica possono verificarsi movimenti sconosciuti sull'utensile a causa della disposizione degli assi.

Nota

I parametri refData e timeout sono opzionali. Se non vengono specificati, il sistema utilizza l'attuale posizione effettiva come posizione di riferimento (DS 402 – metodo 35).

Attenzione

Assicurarsi che gli assi interessati possano traslare liberamente durante la corsa di riferimento. Per garantire una corretta esecuzione della corsa di riferimento occorre inoltre selezionare valori dinamici adeguati per questi movimenti. In questo caso non sono consigliabili valori dinamici elevati.



La definizione del riferimento necessita di alcuni dati per poter essere eseguita. Questi

dati vengono specificati in un record di dati di riferimento del tipo REFDATA.

Parametro Tipo Significato

method DINT Metodo di riferimento secondo CANOpen DS 402

offset REAL Offset della posizione di riferimento [mm]

velSwitch REAL Velocità di definizione del riferimento (accostamento

dell'interruttore)

velZero REAL Velocità lentissima (ricerca del fronte)

acc REAL Accelerazione corsa di riferimento

Tabella 13.2 Struttura del tipo di dati REFDATA

Nota

Specificando il metodo della corsa di riferimento 99 vengono utilizzati i parametri della corsa di riferimento programmati con il Festo Configuration Tool (FCT) nell'attuatore. La corsa di riferi-mento viene quindi eseguita come alla messa in servizio del singolo asse. Tutti gli altri parametri quali offset, velSwitch, zeroSwitch e acc sono irrilevanti in questo caso.

Metodo della corsa di riferimento

Il metodo della corsa di riferimento può avvenire in vari modi, ad es. finecorsa negativo con analisi dell'impulso zero, finecorsa positivo con analisi dell'impulso zero o corsa di riferimento verso un interruttore di finecorsa. Questi metodi sono tutti memorizzati nella documentazione CANopen del rispettivo regolatore dell'attuatore.

La tabella seguente mostra i metodi di definizione del riferimento per unità CANopen secondo DS 402.

Valore Direzione Destinazione Punto di riferimento per zero

-18 positiva Arresto meccanico Arresto meccanico

-17 negativa Arresto meccanico Arresto meccanico

-2 positiva Arresto meccanico Impulso zero

-1 negativa Arresto meccanico Impulso zero

1 negativa Finecorsa Impulso zero

2 positiva Finecorsa Impulso zero

7 positiva Interruttore di

riferimento Impulso zero

11 negativa Interruttore di

riferimento Impulso zero

17 negativa Finecorsa Finecorsa



Valore Direzione Destinazione Punto di riferimento per zero

18 positiva Finecorsa Finecorsa

23 positiva Interruttore di

riferimento Interruttore di riferimento

27 negativa Interruttore di

riferimento Interruttore di riferimento

33 negativa Impulso zero Impulso zero

34 positiva Impulso zero Impulso zero

35 - nessuna corsa Posizione effettiva corrente

99 - - Sequenza come definita nel progetto

FCT dell'asse

Tabella 13.3 Metodi della corsa di riferimento

Scostamento della posizione di riferimento

Mediante il parametro offset si può definire uno scostamento dello zero rispetto alla posizione di riferimento. Una volta definito il riferimento, questo valore di offset viene sommato al punto zero di riferimento. L'indicazione del valore effettivo dell'asse interes-sato viene aggiornata in maniera corrispondente.

Velocità di definizione del riferimento, velocità lentissima, accelerazione

Con la velocità di definizione del riferimento e l'accelerazione viene definita la dinamica dell'asse durante la definizione del riferimento, che sarà attiva dall'avvio della corsa di

riferimento fino al raggiungimento del fronte dell'interruttore corrispondente. Una volta rilevato il fronte, il sistema commuta sulla velocità lentissima e la corsa di riferimento viene conclusa secondo il metodo selezionato.

13.2 Corsa di riferimento asincrona <RefAxisAsync>

Con questa istruzione è possibile definire parallelamente il riferimento di più assi di robot. L'istruzione non attende che la corsa di riferimento sia conclusa, bensì lo svolgimento del programma viene proseguito una volta trasmesso il comando di definizione del riferimento. Per verificare se la definizione del riferimento è stata conclusa o per interrogare lo stato in cui si trova la definizione del riferimento sono disponibili le istruzioni WaitRefFinished e IsAxisReferenced.

Sintassi

RefAxisAsync(<axis>:AXIS, OPT <refData>:REFDATA, OPT <timeout>:REAL)




Axis Asse selezionato per la definizione del riferimento. Enumerazione A1, A2, fino

ad A9

refData Record di dati della corsa di riferimento, ad es. su come viene

eseguita la definizione del riferimento.

nessuna

timeout Tempo per lo svolgimento dell'operazione (dopodiché viene

emesso un messaggio d'errore, la definizione del riferimento

viene interrotta).

Secondi

Tabella 13.4 Parametri dell'istruzione RefAxisAsync

Durante l'esecuzione della corsa di riferimento assicurarsi che gli assi interessati possano traslare liberamente. Il movimento viene eseguito come movimento degli assi. In base al tipo di cinematica possono verificarsi movimenti sconosciuti sull'utensile a causa della

disposizione degli assi.

Nota

I parametri refData e timeout sono opzionali. Se non vengono specificati, il sistema utilizza l'attuale posizione effettiva come posizione di riferimento (DS 402 – metodo 35).

Attenzione

Assicurarsi che tutti gli assi possano traslare liberamente durante la corsa di riferimento. Per garantire una corretta esecuzione della corsa di riferimento occorre inoltre selezionare valori dinamici adeguati per questi movimenti. In questo caso non sono consigliabili valori dinamici elevati.

I parametri e il restante funzionamento sono uguali a quelli dell'istruzione RefAxis.

Nota

Specificando il metodo della corsa di riferimento 99 vengono utilizzati i parametri della corsa di riferimento programmati con il Festo Configuration Tool (FCT) nell'attuatore. La corsa di riferi-mento viene quindi eseguita come alla messa in servizio del singolo asse. Tutti gli altri parametri quali offset, velSwitch, zeroSwitch e acc sono irrilevanti in questo caso.



13.3 Attesa della fine della corsa di riferimento <WaitRefFinished>

Attendere fino a quando tutte le corse di riferimento avviate in modo asincrono sono concluse.

Sintassi

WaitRefFinished( ) : BOOL

L'istruzione attende fino a quando le corse di riferimento asincrone sono concluse (l'attesa avviene durante l'elaborazione principale del programma) o fino a quando si verifica un

errore durante una corsa di riferimento.

Se non si verifica nessun errore durante la corsa di riferimento viene restituito TRUE, altrimenti FALSE.

Programma:

: RefAxisAsync(A1, refdata0)

RefAxisAsync(A2, refdata0)

RefAxisAsync(A3, refdata0)

RefAxisAsync(A4)

boolReference := WaitRefFinished()

IF NOT boolReference THEN

SetError(“Error homing”)

END_IF

Attenzione

Durante l'esecuzione della macro RefAxisAsync è assolutamente necessario utilizzare la macro WaitRefFinished in modo da garan-tire l'ulteriore elaborazione del programma. Se non si attende la fine della corsa di riferimento, determinate istruzioni potrebbero generare errori correlati al calcolo preliminare del programma.



13.4 Interrogazione dello stato di un asse <IsAxisReferenced>

Interrogazione per sapere se il riferimento di un determinato asse è stato definito.

Sintassi

IsAxisReferenced(axis : AXIS ) : BOOL


Axis Asse selezionato da interrogare. Enumerazione A1,

A2, fino ad A9

Tabella 13.5 Parametri dell'istruzione IsAxisReferenced

Se il riferimento dell'asse specificato è definito viene restituito TRUE, altrimenti FALSE.

14. Utensili


14. Utensili Il controller multiassiale offre la possibilità di definire i dati di lunghezza di un utensile. Questi dati vengono descritti sotto forma di un vettore a 6 dimensioni. In tal modo è possibile assegnare all'utensile anche un orientamento, oltre alle dimensioni. Questo orientamento avviene in base alla convenzione di Eulero ZYZ. L'origine del vettore è lo zero nella flangia dell'utensile, mentre la fine è data dal punto finale dell'utensile, denominato TCP (Tool Center Point). Con i dati dell'utensile viene definito il sistema di coordinate

dell'utensile.

14.1 Dati dell'utensile

14.1.1 Dati del vettore TCP

I dati dell'utensile sono memorizzati nel tipo di dati strutturato TCPTOOL, che contiene i dati dei 6 gradi di libertà.

Struttura:

Tipo di dati TCPTOOL




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

zione dell'utensile ruotato. Per la rotazione viene utilizzata la convenzione di Eulero ZYZ.

Ne risultano i seguenti dati:

X = Lunghezza utensile x sin (30°)

Y = 0

Z= Lunghezza utensile x cos (30°)

A = 0

B = 30

C = 0

Queste descrizioni dell'utensile vengono memorizzate in variabili. Per un utensile è possi-bile definire un numero a piacere di variabili TCP, ma un solo record di dati può essere attivo. Le varie descrizioni vengono poi utilizzate quando un utensile ha diversi punti di riferimento e, durante l'esercizio, occorre cambiarli a seconda del rispettivo compito.

Poiché i dati utensile sono archiviati come variabile nella memoria, il loro numero è limitato dalle dimensioni della memoria.

La corretta attribuzione dei dati TCP all'utensile è compito del programmatore. Il controller multiassiale non conosce il riferimento esistente tra i dati dell'utensile e l'utensile fisico.

Attenzione

In caso di dati TCP inappropriati o errati sussiste il pericolo di collisione.

Spostamento

in Z

Z

X

Y

Asse Z

Asse X

Spostamento in X

Angelo

14. Utensili


14.2 Attivazione dei dati dell'utensile <Tool>

Con l'istruzione seguente è possibile impostare i dati di un Tool Center Point (TCP) all'interno di un programma FTL. L'istruzione Tool imposta nuovi dati TCP per la cinematica. In questo modo viene modificato il punto di lavoro della cinematica.

Sintassi

Tool (<ToolData> : TCPTOOL)

I dati per il TCP sono contenuti nella variabile da trasferire. Questi dati vengono letti du-rante il calcolo preliminare dei record dell'interprete FTL e da lì vengono inclusi nell'ul-teriore pianificazione della traiettoria del movimento. Per tutte le istruzioni seguenti

vengono ora considerati questi dati TCP.


ToolData Dati dell'utensile TCPTOOL

Tabella 14.1 Parametri dell'istruzione Tool

Il richiamo dell'istruzione Tool non provoca alcun movimento di traslazione, ma solo una

segnalazione che i dati TCP sono ora attivi. Nell'istruzione di traslazione cartesiana successiva, questi dati verranno elaborati e tenuti in considerazione per l'esecuzione del movimento.

Se nel programma FTL viene saltata un'istruzione Tool, o se sull'unità di comando manuale

il puntatore di frase per l'esecuzione del programma è posizionato in modo tale da impedire l'esecuzione di un'istruzione Tool, possono verificarsi pericoli per le persone e per la macchina. Il successivo orientamento dell'utensile potrebbe essere inappropriato rispetto al movimento, con un conseguente pericolo di collisione.

Avvertenza

In caso di modifica dell'istruzione Tool si verifica un salto nella traiettoria cartesiana del TCP. Se sull'unità di comando manuale il puntatore di programma viene impostato in modo tale da eludere un'istruzione Tool, possono verificarsi reazioni non desiderate nei movimenti cartesiani!

14.2.1 Effetti dei dati TCP

I dati TCP vengono attivati nel programma FTL mediante un'istruzione e letti nel calcolo preliminare dei record dell'interprete. Questi dati TCP ora attuali vengono poi elaborati nella pianificazione della traiettoria delle istruzioni di movimento successive. Nell'esempio seguente viene descritto il comportamento dei dati utensile in combinazione con l'utilizzo di un asse oscillante pneumatico.

14. Utensili


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 orienta-mento modificato.

La cinematica raffigurata è un sistema cartesiano nel quale la posizione del sistema di coordinate cartesiane degli assi di base X, Y e Z coincide con quella del sistema di coordinate cartesiane dell'utensile. Se ora si applica la regola della mano destra per determinare l'orientamento, ne risulta una rotazione dell'utensile intorno all'asse Y in direzione positiva.

Dati utensile per tool2:

X = Lunghezza x sin (30°) Scostamento lungo l'asse X

Y = 0 Scostamento lungo l'asse Y

Z = Lunghezza x cos (30°) Scostamento lungo l'asse Z

A = 0 Orientamento secondo Eulero, rotazione intorno all'asse Z

B = 30 Orientamento secondo Eulero, rotazione intorno all'asse Y ruotato

C = 0 Orientamento secondo Eulero, rotazione intorno all'asse Z ruotato

Esempio di programma:

La nostra cinematica cartesiana deve ora traslare con l'utensile verticale da una posizione 1 a una posizione 2. L'utensile viene poi ruotato mediante l'asse oscillante. L'utensile ruotato deve ora accostare la posizione 2.

Accostamento da pos1 a pos2:

Tool(tool1)

Lin(pos1)

Lin(pos2)

X

Z

Ventosa

Y

Lunghezza utensile

Asse rotativo

TCP

14. Utensili


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 max. tutti gli assi.

Nota

Se si utilizza un asse oscillante elettrico caricato come grado di libertà nella cinematica cartesiana, non è necessario modificare l'orientamento dell'utensile come nel caso dell'asse oscillante pneumatico.

Con l'asse oscillante elettrico, l'orientamento desiderato viene programmato in un'istruzione di traslazione.

Il controller CMXR calcola poi automaticamente la posizione degli assi tenendo in considerazione l'orientamento programmato.

X

Y

Pezzo

pos2

Z Z

Movimento di compensazione

15. Interfaccia PROFIBUS


15. Interfaccia PROFIBUS Il CMXR può essere gestito da un comando principale (PLC/PC industriale) tramite l'interfaccia PROFIBUS. Inoltre è possibile scrivere e leggere dati sotto forma di variabili. Tutti questi dati sono dati globali del sistema e sono a disposizione di tutti i programmi FTL. La comunicazione con il comando principale avviene ciclicamente nel ciclo di aggiornamento del PROFIBUS.

Al riavvio del sistema tutti i valori sono azzerati. Eventuali dati necessari per l'elaborazione dei programmi devono essere trasmessi dal comando principale primo dell'avvio del programma.

Nota

Se un programma richiede dati consistenti, prima di elaborarli è necessario copiarli ad es. sui dati locali.

Nota

I dati dell'interfaccia non vengono archiviati nella memoria tam-pone e perciò, dopo un riavvio del sistema, hanno tutti il valore zero. Eventuali dati necessari per l'elaborazione devono essere scritti primi dell'avvio.



15.1 Indicazioni per l'elaborazione dei segnali

Le variabili FTL dell'interfaccia PLC trattate nei capitoli seguenti vengono sempre calcolate, come altre variabili, nel calcolo preliminare dei record del programma FTL. Se determinate variabili devono essere eseguite durante l'esecuzione della riga di programma attiva (elaborazione principale del programma), è necessario adottare misure supplementari. A tale scopo si può utilizzare ad esempio l'istruzione DO.

Nella grafica seguente vengono spiegate le differenze dell'elaborazione dei segnali:

15.2 Ingressi e uscite booleani

L'interfaccia comprende 16 segnali d'ingresso e di uscita digitali, che di seguito verranno sempre considerati dal punto di vista del CMXR. Tali segnali sono disponibili sul controller

sotto forma di variabile booleana. Questi segnali booleani vengono ciclicamente scambiati con il comando principale.

Nota

Le variabili booleane vengono automaticamente trasmesse al comando principale, o lette dal medesimo, tramite il ciclo del PROFIBUS.

Le variabili booleane sono memorizzate in un array accessibile mediante gli indici da 0 a 15.

Lin(pos1)

Lin(pos2)

Lin(pos3)

Lin(pos4)

Lin(pos5)

plc_Dint[1] := 2

Lin(pos6)

Lin(pos7)

Lin(pos8)

Lin(pos9)

Elaborazione

principale

Calcolo

preliminare

Lin(pos1)

Lin(pos2)

Lin(pos3)

Lin(pos4)

Lin(pos5) DO plc_Dint[1] := 1

Lin(pos6)

Lin(pos7) DO plc_DInt[3] := 2

Lin(pos8)

Lin(pos9)

Lin(pos10)

Elaborazione

principale

Calcolo

preliminare

La variabile viene

elaborata nel calcolo

preliminare dei record.

Utilizzo dell'istruzione DO, la

variabile viene elaborata durante

l'elaborazione principale del

programma.



Sintassi

plc_InBool [ <indice array> ] : BOOL

plc_OutBool [ <indice array> ] : BOOL

Nella variabile dell'array plc_InBool sono memorizzati tutti i segnali di ingresso. La varia-bile dell'array plc_OutBool contiene tutti i dati di uscita.

Esempio:

:

plc_OutBool[9] := FALSE // bit 9 al PLC su FALSE

IF plc_InBool[5] THEN // controllo bit 5 dal PLC

Lin(pos1)

Lin(pos2)

END_IF

plc_OutBool[9] := TRUE // bit 9 al PLC su TRUE

:

Esempi con calcolo preliminare dei record e con l'istruzione DO

15.3 Variabili intere a 32 bit

L'interfaccia offre 256 variabili intere del tipo di dati DINT, che comprende 32 bit. Queste variabili non sono soggette allo scambio ciclico dei dati e, in caso di necessità, possono essere scritte e lette dall'unità di comando esterna.

Nota

Le variabili intere non vengono automaticamente lette dal comando principale o trasmesse al medesimo. Se necessario devono essere trasmesse o lette dal comando principale.

Le variabili intere sono memorizzate in un array accessibile mediante gli indici da 0 a 255.

Sintassi

plc_Dint [ <indice array> ] : DINT



Esempio:

:

IF plc_Dint[3] = 13 THEN

:

:

END_IF

15.4 Posizioni

L'interfaccia supporta due tipi di dati di posizione. Dall'unità di comando esterna al con-

troller multiassiale CMXR possono essere trasmesse le posizioni degli assi e le posizioni cartesiane. Il numero massimo di posizioni è pari a 256 posizioni degli assi e 256 posizioni cartesiane. Queste variabili non sono soggette allo scambio ciclico dei dati e, in caso di necessità, possono essere scritte e lette dall'unità di comando esterna.

Nota

Le variabili di posizione non vengono automaticamente lette dal comando principale o trasmesse al medesimo. Se necessario devono essere inviate o lette dall'unità di comando esterna.

Le variabili di posizione sono memorizzate in array accessibili mediante gli indici da

0 a 255.

Nota

plc_AxisPos [ <indice array> ] : AXISPOS

plc_CartPos [ <indice array> ] : CARTPOS

La variabile dell'interfaccia plc_AxisPos contiene 256 posizioni del tipo di dati AXISPOS, la variabile plc_CartPos contiene 256 posizioni del tipo di dati CARTPOS.

Esempio:

:

Ptp(plc_AxisPos[17])

Lin(plc_AxisPos[18])

Lin(plc_AxisPos[19])

Lin(plc_CartPos[1])

:



15.5 Sistemi di riferimento

Mediante l'interfaccia esterna è possibile preimpostare al massimo 16 sistemi di riferi-mento. Queste variabili sono del tipo di dati REFSYSDATA e possono essere utilizzate con l'istruzione SetRefSys. Queste variabili non sono soggette allo scambio ciclico dei dati e,

in caso di necessità, possono essere scritte e lette dall'unità di comando esterna.

Nota

I sistemi di riferimento non vengono automaticamente letti dal comando principale o trasmessi al medesimo. Se necessario devono essere inviati o letti dall'unità di comando esterna.

I sistemi di riferimento sono memorizzati in un array accessibile mediante gli indici da 0 a 15.

Sintassi

plc_RefSys [ <indice array> ] : REFSYSDATA

Il tipo di dati REFSYSDATA offre la possibilità di associare un sistema di riferimento ad un altro in modo additivo. L'interfaccia supporta questa funzionalità, ma solo se avviene nell'ambito dell'interfaccia stessa. Ciò significa che non è possibile creare un riferimento a sistemi di riferimento che si trovano nel sistema. Il riferimento a un altro sistema di riferi-

mento viene creato preimpostando un numero da 0 a 15 mediante l'unità di comando esterna. Preimpostando il valore -1 viene creato il riferimento al sistema di coordinate globali della cinematica.

Nota

I sistemi di riferimento preimpostati mediante l'interfaccia esterna possono essere associati solo ad altri sistemi di riferimento dell'in-terfaccia. Non è possibile creare un riferimento a sistemi che si trovano all'esterno dell'interfaccia.

Esempio:

:

Lin(pos2)

SetRefSys(plc_RefSys[3])

Lin(pos3)

Lin(pos4)

:



15.6 Arresto programmato <ProgHold>

Questa istruzione funziona in abbinamento al segnale HALTENA dell'interfaccia PLC. È indicata per scopi di test o per la messa in servizio e può essere inserita in qualsiasi riga di programma per provocare l'arresto del programma quando richiesto.

Quando il segnale HALTENA sull'interfaccia è attivato, cioè ha lo stato TRUE, richiamando la macro ProgHold viene arrestato il programma di movimenti. In questo caso viene arrestato solo il programma nel quale si trova la macro ProgHold. Altri programmi, ad es. i programmi paralleli, continuano ad essere elaborati. Quando il PLC imposta il segnale HALTENA su FALSE, il programma arrestato viene proseguito.

Nota

Se con la macro ProgHold vengono arrestati più programmi (ad es. programmi paralleli), essi verranno riavviati insieme non appena è disponibile lo stato di segnale FALSE. Un avvio selettivo di singoli programmi arrestati non è possibile.

Sintassi

ProgHold ( )

Per richiamare la macro non è necessario alcun parametro.

Esempio:

:

OvlVel(100) // approssimazione completa

Lin(pos1)

Lin(pos2)

ProgHold ( ) // arresto programmato

Lin(pos3)

Lin(pos4)

ProgHold ( ) // arresto programmato

Lin(pos5)

:

In questo esempio di programma vengono accostate diverse posizioni con un'approssimazione della velocità impostata al 100 %. Settando il segnale per l'arresto programmato, in queste posizioni si verifica un arresto. Ne risulta il seguente andamento della velocità:



Andamento con l'arresto programmato:

Andamento senza l'arresto programmato:

pos2 pos1 pos3 pos4 pos5

Velocità

Tempo

Intervallo di tempo tra l'arresto e il riavvio

pos2 pos1 pos3 pos4 pos5

Velocità

Tempo

16. Sistema di segnalazione


16. Sistema di segnalazione Il programma di movimenti può generare dei messaggi. Esistono i seguenti tipi di messaggio:

Informazione

Avvertenza

Errore

Questi messaggi vengono registrati nella memoria messaggi dell'unità di comando e archiviati in maniera corrispondente. I messaggi vengono resettati (cancellati) sull'unità di comando manuale o tramite un'unità di comando esterna.

Illustrazione della memoria errori sull'unità di comando manuale:

16.1 Testi dei messaggi

La programmazione in FTL (Festo Teach Language) consente la generazione di messaggi d'informazione, di avvertimento e d'errore dal programma di movimenti. I testi dei messaggi vengono definiti dall'utente stesso come catena di caratteri (stringa). Questa catena di caratteri può contenere anche registrazioni variabili sotto forma di un massimo di 2 parametri (ad es. DINT, REAL, String, BOOL). I 2 parametri opzionali vengono inseriti nel testo del messaggio mediante l'indicazione di un carattere percentuale e un numero.

%1 significa 1° parametro opzionale

%2 significa 2° parametro opzionale



Indicando tipi di dati quali le posizioni degli assi, nella stringa viene inserito solamente il

nome della variabile. I tipi di dati strutturati non possono essere rappresentati nel testo di un messaggio.

Nota

In caso di trasferimento di variabili del tipo DINT, REAL e String viene inserito il contenuto delle variabili nel testo del messaggio. Con variabili del tipo BOOL, nel testo del messaggio viene inserito il testo TRUE o FALSE a seconda dello stato.

Esempio:

In un programma vengono create due variabili, alle quali vengono poi assegnati dei valori. Questi valori vengono emessi con la macro SetInfo.

Variabili:

param1 : DINT := 7

param2 : REAL := 3.48


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

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



16.2 Informazione <SetInfo>

L'istruzione SetInfo genera un messaggio d'informazione nel sistema di segnalazione.

Sintassi

SetInfo( <text> : STRING,

OPT <param1> : ANY,

OPT <param2> : ANY)


text Testo del messaggio informativo STRING

param1 1° parametro possibile ANY


Tabella 16.1 Parametri dell'istruzione SetInfo

La composizione del testo del messaggio è descritta nel capitolo 16.1 Testi dei messaggi a pagina 137.

Un messaggio d'informazione viene contrassegnato con il simbolo nella memoria errori del controller multiassiale CMXR.

Nota

Un messaggio d'informazione non ha alcun effetto sul movimento. Serve unicamente come informazione.

Esempio:

pressure := Sensor.Read(); // lettura di un valore

di pressione

cycle := cycle + 1 // conteggio ciclo

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

Visualizzazione sull'unità di comando manuale:



16.3 Avvertenza <SetWarning>

L'istruzione SetWarning genera un messaggio di avvertimento nel sistema di

segnalazione.

Sintassi

SetWarning( <text> : STRING,

OPT <param1> : ANY,

OPT <param2> : ANY)


text Testo del messaggio di

avvertimento

STRING



Tabella 16.2 Parametri dell'istruzione SetWarning

La composizione del testo del messaggio è descritta nel capitolo 16.1 Testi dei messaggi a pagina 137.

Un messaggio di avvertimento viene contrassegnato con il simbolo nella memoria

errori del controller multiassiale CMXR.

Nota

Un messaggio di avvertimento non ha alcun effetto sul movimento. Serve unicamente come informazione.

Esempio:

pressure := Sensor.Read(); // lettura di un valore di pressione


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




16.4 Messaggio di errore <SetError>

L'istruzione SetError genera un messaggio d'errore nel sistema di segnalazione. Questa

istruzione influisce sull'elaborazione del programma, il quale viene arrestato. Eventuali movimenti in corso vengono arrestati, il programma / movimento viene proseguito solo dopo aver confermato il messaggio di errore.

Sintassi

SetError( <text> : STRING,

OPT <param1> : ANY,

OPT <param2> : ANY)


Testo Testo del messaggio di errore STRING



Tabella 16.3 Parametri dell'istruzione SetError

Un messaggio di errore viene contrassegnato con il simbolo nella memoria errori del controller multiassiale CMXR.

Nota

L'emissione di un messaggio di errore provoca un'interruzione del movimento. La cinematica può proseguire la lavorazione solo dopo la conferma del messaggio di errore.

Esempio:

pressure := Sensor.Read(); // lettura di un valore

di pressione


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.

17. Funzioni


17. Funzioni

17.1 Lettura della posizione corrente <ReadActualPos>

Lettura della posizione corrente della cinematica.

Sintassi

ReadActualPos (<Pos> : POSITION)

La posizione corrente del robot viene scritta nella variabile passata. Se la variabile passata

è del tipo CARTPOS, la posizione viene memorizzata come valore cartesiano. Se viene passata una variabile del tipo AXISPOS, la posizione viene memorizzata in coordinate degli assi.


Pos Variabile di arrivo della posizione letta AXISPOS o CARTPOS

Tabella 17.1 Parametri dell'istruzione ReadActualPos

Attenzione

Un valore di posizione memorizzato in una variabile viene conservato solamente finché il programma o il progetto è caricato. I valori delle variabili non vengono memorizzati nel file di dati sulla scheda di memoria. Alla chiusura del programma/progetto, i valori vanno persi. Per salvare la posizione si può utilizzare la macro SavePosition.

Esempio:

Il programma nell'esempio legge la posizione corrente, esegue le istruzioni di movimento programmate e alla fine ritorna nella posizione letta.

Variabile:

startPos : AXISPOS := (0, 0, 0, 0, 0, 0, 0, 0, 0)

axis0 : AXISPOS := (0, 0, 0, 0, 0, 0, 0, 0, 0)

axis1 : AXISPOS := (60, -120, 0, 0, 0, 0, 0, 0, 0)

axis2 : AXISPOS := (-120, -120, -250, 0, 0, 0, 0, 0, 0)

17. Funzioni


Programma:

ReadActualPos(startPos)

PTP(axis0)

PTP(axis1)

PTP(axis2)

PTP(startPos)

17.2 Lettura della posizione di arrivo <ReadTargetPos>

Lettura della posizione di arrivo programmata della cinematica.

Sintassi

ReadTargetPos (<Pos> : POSITION)

La posizione di arrivo attualmente programmata del robot viene scritta nella variabile passata. Se la variabile passata è del tipo CARTPOS, la posizione viene memorizzata come valore cartesiano. Se viene passata una variabile del tipo AXISPOS, la posizione viene memorizzata in coordinate degli assi.


Pos Variabile di arrivo della posizione letta AXISPOS o CARTPOS

Tabella 17.2 Parametri dell'istruzione ReadTargetPos

Attenzione

Un valore di posizione memorizzato in una variabile viene conservato solamente finché il programma o il progetto è caricato. I valori non vengono memorizzati nel file di dati sulla scheda di memoria. Alla chiusura del programma o del progetto, i valori vanno persi. Per salvare la posizione si può utilizzare la macro SavePosition.

17. Funzioni


17.3 Salvataggio permanente di un valore di posizione <SavePosition>

La macro memorizza un valore di posizione in modo permanente sulla scheda di memoria.

Sintassi

SavePosition (<Pos> : POSITION)

Con la macro SavePosition è possibile salvare i valori della variabile specificata <Pos> nel

file di dati sulla scheda di memoria. In tal modo è possibile ripristinare la posizione al

riavvio dell'unità di comando.


Pos Posizione da memorizzare AXISPOS o CARTPOS

Tabella 17.3 Parametri dell'istruzione SavePosition

Attenzione

Una riscrittura frequente di posizioni sulla scheda di memoria riduce la durata della scheda. La macro SavePosition non si può richiamare ciclicamente. Può essere utilizzata per l'impostazione occasionale dell'applicazione.

17.4 Lettura dell'ora del sistema <Time>

Lettura dell'ora del sistema in secondi a partire dal 01.01.1970 alle ore 00:00.

Sintassi

(<valore di tempo> : DINT) := Time ( )

Questa istruzione legge l'ora corrente del sistema dell'unità di comando e la restituisce come valore DINT.

Esempio:

value := Time() // lettura dell'ora corrente del sistema

17. Funzioni


17.5 Conversione dell'ora in testo <TimeToStr>

Conversione di un'indicazione dell'ora in un testo.

Sintassi

(<stringa dell'ora> : STRING) := TimeToStr (OPT sysTime : DINT)

Questa istruzione consente di convertire un'indicazione dell'ora (parametro sysTime) in un testo formattato con il formato “DDD mon dd hh:mm:ss yyyy”. Senza il parametro sysTime viene restituita l'ora corrente del sistema formattata.

Il parametro sysTime segnala l'ora in secondi a partire dal 01.01.1970 alle ore 00:00.

Parametri:


sysTime Indicazione opzionale, valore

temporale da convertire.

Secondi

Tabella 17.4 Parametri della funzione TimeStr

Esempio:

str_Time := TimeToStr() // lettura dell'ora corrente

del sistema

Valore restituito:

str_Time = “Mon Feb 13 11:23:44 2006”

17. Funzioni


17.6 Seno <SIN>, <ASIN>

La funzione seno crea la relazione matematica tra un angolo e i lati in un triangolo rettangolo.

Per il seno vale quanto segue:

sin (alpha) = cateto opposto / ipotenusa

sin (alpha) = a / c

L'angolo viene indicato in gradi.

Sintassi

(<valore seno> : REAL) := SIN(<angolo> : REAL)

Utilizzo:

La funzione seno serve per calcolare segmenti incogniti in un triangolo rettangolo. Se è

noto l'angolo e il cateto opposto oppure l'ipotenusa, è possibile calcolare il segmento incognito.

Se occorre invece calcolare l'angolo, il CMXR mette a disposizione la funzione arco seno. Questa funzione calcola l'angolo, ad es. alfa, in base al cateto opposto e all'ipotenusa.

Sintassi

(<angolo in gradi> : REAL) := ASIN(<valore seno>)


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

17.7 Coseno <COS>, <ACOS>

La funzione coseno crea la relazione matematica tra un angolo e i lati in un triangolo rettangolo.

Per il coseno vale quanto segue:

cos (alpha) = cateto adiacente / ipotenusa

cos (alpha) = b / c


Sintassi

(<valore coseno> : REAL) := COS(<angolo>)

Utilizzo:

La funzione coseno serve per calcolare segmenti incogniti in un triangolo rettangolo. Se è noto l'angolo e il cateto adiacente oppure l'ipotenusa, è possibile calcolare il segmento incognito.

Se occorre invece calcolare l'angolo, il CMXR mette a disposizione la funzione arco coseno. Questa funzione calcola l'angolo, ad es. alfa, in base al cateto adiacente e all'ipotenusa.

17. Funzioni


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

17. Funzioni


17.8 Tangente <TAN>, <ATAN>

La funzione tangente crea la relazione matematica tra un angolo e i lati in un triangolo rettangolo.

Per la tangente vale quanto segue:

tan (alpha) = cateto opposto / cateto adiacente

tan (alpha) = a / b


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

17. Funzioni


a := 45.89 // cateto opposto


value := a / b

alpha := ATAN(value) // calcolo dell'angolo incluso

17.9 Cotangente <COT>, <ACOT>

La funzione cotangente crea la relazione matematica tra un angolo e i lati in un triangolo rettangolo.

Per la cotangente vale quanto segue:

Cotan (alpha) = cateto adiacente / cateto opposto

cotan (alpha) = b / a


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


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

17.10 Arcotangente2 <ATAN2>

Calcola l'arcotangente con un aumento dell'intervallo di valori da + π a –π.

Sintassi

(<argomento> : REAL) := ATAN2 (<y> : REAL, <x> : REAL)

17.11 Logaritmo <LN>

La funzione logaritmo calcola il logaritmo naturale dell'argomento passato.

Sintassi

(<logaritmo naturale> : REAL) := LN (<valore> : REAL)

17.12 Esponente <EXP>

La funzione esponente calcola il valore e(x).

Sintassi

(<risultato> : REAL) := EXP (<valore>:REAL)

17. Funzioni


17.13 Valore assoluto <ABS>

La funzione di valore assoluto fornisce l'ammontare assoluto del valore REAL passato. Il valore restituito è quindi sempre positivo. I numeri negativi vengono restituiti come valore con segno positivo.

Sintassi

(<valore assoluto> : REAL) := ABS (<valore> : REAL)

Esempio

Level := 452.98

Level := ABS(Level) // Level ha il valore assoluto di 452.98

Level := -1056.61

Level := ABS(Level) // Level ha il valore assoluto di 1056.61

17.14 Radice quadrata <SQRT>

La funzione radice rileva il valore della radice quadrata di un'espressione.

Sintassi

(<valore radice> : REAL) := SQRT (<valore> : REAL)

Esempio:

Calcolo della lunghezza c in un triangolo rettangolo.

Secondo il teorema di Pitagora vale quanto segue:

C² = A² + B² oppure C = √(A² + B²)

Esempio di programma:

a := 152.67 // lunghezza del cateto A

b := 63.12 // lunghezza del cateto B

value := a * a + b * b

c := SQRT(value) // calcolo dell'ipotenusa

17. Funzioni


17.15 Spostamento dei bit <SHR>, <SHL>

Con le funzioni SHR e SHL è possibile spostare i bit di dati del tipo DWORD verso destra (funzione SHR) e verso sinistra (funzione SHL). I bit spostati “fuori” dalla variabile su un

lato vanno persi. Sull'altro lato vengono aggiunti bit con il valore “0”.

Sintassi

(<variabile> :DWORD) := SHR (<valore : DWORD>, <count> : DINT)

(<variabile> :DWORD) := SHL (<valore : DWORD>, <count> : DINT)

Esempio:

Con l'istruzione

Mask := SHL(Mask, 3)

il contenuto della variabile Mask viene spostato di 3 bit verso sinistra. Sul lato destro vengono inseriti 3 bit con il valore “0”.

Contenuto della variabile:

1001 1111 0000 1100 1111 1111 1001 1100

Si ottiene lo schema di codifica a bit seguente:

1111 1000 0110 0111 1111 1100 1110 0000

Con l'istruzione

Mask := SHR(Mask, 3)

il contenuto della variabile Mask viene spostato di 3 bit verso destra. Sul lato sinistro vengono inseriti 3 bit con il valore “0”.


1001 1111 0000 1100 1111 1111 1001 1100


0001 0011 1110 0001 1001 1111 1111 0011

17. Funzioni


17.16 Rotazione dei bit <ROR>, <ROL>

Con le funzioni ROR e ROL è possibile ruotare i bit di dati del tipo DWORD verso destra (funzione ROR) e verso sinistra (funzione ROL). Durante la rotazione dello schema di

codifica a bit, il bit eliminato viene reinserito sull'altro lato.

Sintassi

(<variabile> : DWORD) := ROR (<valore : DWORD>, <count> : DINT)

(<variabile> : DWORD) := ROL (<valore : DWORD>, <count> : DINT)

Esempio:

Con l'istruzione

Mask := ROL(Mask, 4)

il contenuto della variabile Mask viene ruotato di 4 bit verso sinistra. I 4 bit vengono reinseriti sul lato destro.


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

17. Funzioni


17.17 Conversione di un valore in una stringa <STR>

Converte un tipo di dati qualsiasi in una stringa.

Sintassi

(<variabile> : STRING) := STR (<valore> : ANY)

Esempio:

Con l'istruzione STR il valore della variabile Real1 viene convertito in una stringa.

Real1 := 25.5

String1 := STR(Real1)

String1 ha ora il valore “25.500000”.

17.18 Conversione di un valore ASCII in un carattere <CHR>

Converte un valore ASCII in un singolo carattere.

Sintassi

(<variabile> : STRING) := CHR (<valore> : DINT / DWORD)

Esempio:

Con l'istruzione seguente la variabile String1 riceve il valore “a”.

String1 := CHR(97)

17.19 Conversione di un carattere in un valore ASCII <ORD>

Converte un singolo carattere nel valore ASCII.

Sintassi

(<variabile> : DINT / DWORD) := ORD (<valore> : STRING)

Esempio:

Con l'istruzione seguente la variabile Dint1 riceve il valore 65.

Dint1 := ORD(“A”)

18. Moduli


18. Moduli Il linguaggio FTL offre la possibilità di utilizzare i moduli. I moduli contengono, oltre ai dati, anche componenti in forma di codice di programma per ottenere determinate funzionalità. Per poter comunicare in FTL, un modulo dispone di dati di ingresso e di uscita.

Rappresentazione grafica di un modulo:

Il numero di dati di ingresso / uscita di un modulo in FTL è prestabilito in un tipo di dati. Per poter utilizzare un modulo nell'applicazione è necessario dichiararlo. Nel caso di un modulo si parla di istanziazione. Dal nome liberamente selezionabile del modulo (identificatore) viene creata una copia della struttura del modulo, che comprende i dati di ingresso e di uscita e i dati di programma interni. Il codice di programma vero e proprio esiste solo una volta.

Dichiarazione di un'istanza di modulo

<nome istanza> : <tipo istanza> ( parametro )

Analogamente alle variabili, le istanze vengono memorizzate nel rispettivo file di dati.

Modulo: valore analogico

Codice di programma

interno

Dati di ingresso del

modulo

Dati di uscita del

modulo

Tipo di modulo

valore analogico

Sistema operativo Programma FTL

Pressione: tipo valore analogico

Peso: tipo valore analogico

Istanze di modulo nel programma applicativo

18. Moduli


Esempio di un'istanza

Sensor : AIN(…)

A seconda del tipo di modulo, durante la dichiarazione vengono assegnati dati al modulo, quali ad es. il nome di un segnale hardware. La documentazione dei moduli è riportata nei capitoli seguenti.

18.1 Funzioni

Per accedere ai dati o utilizzare le funzionalità di un modulo sono disponibili le funzioni di modulo corrispondenti. L'accesso alle funzioni del modulo avviene tramite il nome dell'istanza e l'operatore punto.

Accesso alle funzioni di un modulo

<nome istanza> . <nome funzione>

Nell'esempio è descritto l'accesso alla funzione di modulo Read dell'istanza Sensor:

merker := Sensor.Read()

Con alcune funzioni si possono passare dei parametri. Per maggiori dettagli consultare i capitoli seguenti dedicati ai singoli moduli.

18.2 Variabili

Oltre alle funzioni, i moduli possono contenere anche variabili. Con queste variabili è possibile accedere ai dati di un modulo. L'accesso alle variabili di un modulo avviene tramite il nome dell'istanza e l'operatore punto.

Accesso alla variabile di un modulo

<nome istanza> . <nome variabile>

In determinati moduli, l'accesso ai dati può avvenire sia con le variabili che con le funzioni. Il risultato è identico in entrambi i casi. Questi due tipi di accesso hanno tempi di

esecuzione diversi. Per maggiori dettagli consultare i capitoli dei singoli moduli.

Nell'esempio è descritto l'accesso alla variabile di modulo State dell'istanza Sensor:

IF Sensor.state THEN

Lin(pos1)

ELSE

Lin(pos2)

END_IF

18. Moduli


Consiglio:

Quando possibile è preferibile utilizzare l'accesso mediante una variabile, che richiede un minor tempo di esecuzione.

18.3 Comportamento in fase di esecuzione

Il programma FTL non viene elaborato ciclicamente bensì in modo sequenziale, istruzione dopo istruzione. Questo comportamento non è tuttavia sufficiente per determinate appli-cazioni. Se ad es. durante l'esecuzione di un programma di movimenti occorre verificare se su un ingresso si è verificata una variazione di fronte, è necessario creare un programma parallelo con un notevole dispendio di tempo. Per semplificare e ottimizzare il processo di elaborazione, alcuni moduli funzionano ciclicamente nel sistema operativo. L'utente può

così accedere ai risultati del modulo per mezzo di metodi o variabili.

18.3.1 Parametro ovlEnable

Alcuni metodi dei moduli seguenti dispongono di un parametro ovlEnable opzionale.

Questo parametro regola il momento di interrogazione del segnale di ingresso digitale. Il parametro è del tipo BOOL e può assumere lo stato TRUE o FALSE.

Stato FALSE

Il calcolo preliminare dei record viene arrestato in questo punto. Quando l'elaborazione principale dei record raggiunge questa istruzione di programma, il segnale viene letto e/o

eseguito. Il movimento viene arrestato e poi nuovamente accelerato dopo l'istruzione. Un'approssimazione per i movimenti successivi non è possibile.

Stato TRUE

Se al parametro ovlEnable viene passato lo stato TRUE, il segnale viene letto e/o eseguito nell'ultimo momento possibile per poter proseguire il movimento. Il movimento non viene arrestato bensì proseguito senza interruzioni. Un'approssimazione per i movimenti successivi è possibile.

Nota

Se il parametro non viene specificato, viene assunto lo stato FALSE.

18. Moduli


18.4 Modulo di ingresso digitale DIN

Il modulo DIN serve per l'interrogazione e la gestione di un ingresso digitale.

18.4.1 Istanziazione

Per l'istanziazione del modulo di ingresso digitale è necessario il riferimento hardware con l'ingresso digitale. Questo viene indicato tramite il parametro <input> in fase di istanzia-zione.

Sintassi

<nome istanza> .DIN( <Timeout> : DINT,

<RisingEdge> : BOOL,

MAPX(“< input>”))

È possibile specificare ulteriori parametri, ad es. per eseguire delle preimpostazioni. Ciò non è tuttavia necessario ai fini dell'istanziazione e può avvenire anche nel programma.

Esempio:

Un sensore viene impostato come istanza di un modulo:

Istanziazione nel file di dati:

Sensor : DIN := (-1, FALSE, MAPX(“_system.Input1”))

Istanziazione con l'editor FTL

L'istanziazione avviene nella finestra di dialogo per la creazione di variabili, selezionando il

tipo (<Type:>) DIN e impostando l'identificatore (<Identifier:>) Sensor. Nella riga <MAPTO DINPORT> viene creato il riferimento reale ad un ingresso digitale configurato.

18. Moduli


Istanziazione con l'unità di comando manuale

L'istanziazione del modulo di ingresso digitale mediante l'unità di comando manuale avviene nella maschera delle variabili selezionando il tipo di dati DIN. La registrazione viene automaticamente memorizzata nel file di dati.

Il modulo di ingresso digitale possiede le seguenti variabili:

Variabile Tipo Significato Stato alla creazione

Timeout REAL Timeout di attesa con le istruzioni Wait e WaitN.

-1 = nessun timeout (attesa infinita)

0 = controllo immediato

>0 = timeout in millisecondi

-1

RisingEdge BOOL Stato del fronte ascendente FALSE

Input DINPORT Rimando all'ingresso hardware ---

Tabella 18.1 Variabili del modulo di ingresso digitale

Timeout

Con il parametro Timeout si può definire un tempo di attesa. Il metodo del modulo attende lo stato del segnale richiesto per il tempo impostato.

Impostando il valore -1 si verifica un'attesa infinita.

Indicando un valore > 0 il programma attende al massimo per il tempo impostato. Se al termine del tempo di attesa non si è verificato lo stato di segnale desiderato, l'esecuzione del programma viene proseguita. Un messaggio d'errore deve essere

generato dal programma sequenziale stesso.

Indicando il valore 0 viene eseguito un controllo immediato. Se il segnale non ha il valore desiderato, il programma sequenziale deve generare un messaggio di errore.

Ulteriori informazioni e un esempio di creazione del messaggio di errore sono riportati nel capitolo 20.2 Utilizzo dei moduli di ingresso e di uscita.

18. Moduli


RisingEdge

Sebbene non venga richiamato, il modulo memorizza lo stato di un fronte ascendente. Questo stato può essere analizzato nel programma.

Input

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

18.4.2 Metodi

Il modulo dispone di più metodi:

Metodo Descrizione

Wait Attesa finché l'ingresso non assume lo stato TRUE

WaitN Attesa finché l'ingresso non assume lo stato FALSE

Read Lettura dello stato dell'ingresso

RisingEdge Lettura dello stato del fronte ascendente

ResetRisingEdge Reset dello stato del fronte ascendente

Tabella 18.2 Metodi del modulo di ingresso digitale DIN

Nell'editor FTL, dopo l'immissione del punto i metodi disponibili vengono automatica-mente visualizzati in una lista da dove possono essere selezionati.

Mediante l'unità di comando manuale si possono selezionare questi metodi dalla struttura a menu nella cartella “Digital Inputs”.

La figura mostra le selezione dei metodi del modulo DIN sull'unità di comando manuale.

18. Moduli


18.4.3 Attesa dello stato, metodo Wait / WaitN

Con i metodi Wait e WaitN si può fare attendere al programma FTL fino a quando l'ingresso assume il valore TRUE o FALSE. L'attesa tiene in considerazione il timeout eventualmente impostato.

Sintassi

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

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

Per la descrizione del parametro ovlEnable vedi capitolo 18.3.1 a pagina 158.

Esempio:

Ptp(pos0)

sensor.Wait() // attesa del segnale TRUE, movimento

arrestato

Ptp(pos1)

sensor.WaitN(TRUE) // attesa del segnale FALSE, nessun arresto

Ptp(pos2)

18.4.4 Lettura dello stato, metodo Read

Con il metodo Read si può leggere lo stato corrente dell'ingresso. Come valore di ritorno viene restituito lo stato TRUE o FALSE.

Sintassi

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


Esempio:

value := sensor.Read()

18.4.5 Fronte ascendente, metodo RisingEdge

Con il metodo RisingEdge si può controllare se sull'ingresso si è verificato un fronte ascendente e se questo è stato memorizzato. Il valore di ritorno può essere TRUE anche se l'ingresso nel frattempo ha assunto lo stato FALSE. Lo stato del fronte viene rilevato indipendentemente dal ciclo del programma FTL e si svolge in un ciclo proprio.

18. Moduli


Sintassi

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


Esempio:

value := sensor.RisingEdge()

18.4.6 Reset del fronte, metodo ResetRisingEdge

Questo metodo resetta il flag interno del fronte ascendente. Ciò si rende necessario quando si vuole controllare un fronte ascendente con il metodo RisingEdge.

Sintassi

<nome istanza>.ResetRisingEdge()

Nota

Se il valore dell'ingresso digitale è impostato nel momento in cui viene eseguita questa istruzione, lo stato di rilevamento del fronte viene resettato e non più reimpostato. Esso viene reimpostato solamente dopo che sull'ingresso si è verificato un fronte positivo (variazione di stato dell'ingresso da 0 a 1).

Esempio:

sensor.ResetRisingEdge()

value := sensor.RisingEgde()

18.5 Modulo di uscita digitale DOUT

Il modulo DOUT serve per l'interrogazione e la gestione di un'uscita digitale.


Per l'istanziazione del modulo di uscita digitale è necessario il riferimento hardware con l'uscita digitale. Questo viene indicato tramite il parametro <output> in fase di istanziazione.

Sintassi

<nome istanza> .DOUT( <Timeout> : DINT,

<RisingEdge> : BOOL,

MAPX(“< output>”))

18. Moduli


È possibile specificare ulteriori parametri, ad es. per eseguire delle preimpostazioni. Ciò

non è tuttavia necessario ai fini dell'istanziazione e può avvenire anche nel programma.

Esempio:

Un cilindro viene impostato come istanza di un modulo:


cylinder : DOUT := (-1,FALSE, MAPX(“_system.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.

18. Moduli


18.5.2 Variabili

Il modulo di uscita digitale possiede le seguenti variabili:

Variabile Tipo Significato Stato alla

creazione

Timeout REAL Timeout di attesa con le istruzioni Wait e WaitN.




-1

RisingEdge BOOL Stato del fronte ascendente FALSE

Output DOUTPORT Rimando all'uscita hardware ---

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



RisingEdge

Sebbene non venga richiamato, il modulo memorizza lo stato di un fronte ascendente. Questo stato può essere analizzato nel programma.

Output

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

18. Moduli


18.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 18.4 Metodi del modulo di uscita digitale DOUT

Mediante l'unità di comando manuale si possono selezionare questi metodi dalla struttura a menu nella cartella “Digital Outputs”.


La figura mostra le selezione dei metodi del modulo DOUT sull'unità di comando manuale.

18. Moduli


18.5.4 Attesa dello stato, metodo Wait / WaitN

Con i metodi Wait e WaitN si può fare attendere al programma FTL fino a quando l'uscita

assume il valore TRUE o FALSE. L'attesa tiene in considerazione il timeout eventualmente impostato.

Sintassi

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

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


Esempio:

Ptp(pos0)

cylinder.Wait() // attesa del segnale TRUE all'uscita,

movimento arrestato

Ptp(pos1)

cyinder.WaitN(TRUE) // attesa del segnale FALSE all'uscita,

nessun arresto

Ptp(pos2)

18.5.5 Lettura dello stato, metodo Read

Con il metodo Read si può leggere lo stato corrente dell'uscita. Come valore di ritorno

viene restituito lo stato TRUE o FALSE.

Sintassi

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


Esempio:

value := cylinder.Read()

18.5.6 Fronte ascendente, metodo RisingEdge

Con il metodo RisingEdge si può controllare se sull'uscita si è verificato un fronte ascen-

dente e se questo è stato memorizzato. Il valore di ritorno può essere TRUE anche se l'uscita nel frattempo ha assunto lo stato FALSE. Lo stato del fronte viene rilevato indipendentemente dal ciclo del programma FTL e si svolge in un ciclo proprio.

Sintassi

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

18. Moduli



Esempio:

value := cylinder.RisingEdge()

18.5.7 Reset del fronte, ResetRisingEdge

Questo metodo resetta il flag interno del fronte ascendente. Ciò si rende necessario quando si vuole controllare un fronte ascendente con il metodo RisingEdge.

Sintassi

<nome istanza>.ResetRisingEdge()

Nota

Se il valore dell'uscita digitale è impostato nel momento in cui viene eseguita questa istruzione, lo stato di rilevamento del fronte viene resettato e non più reimpostato. Esso viene reimpostato solamente dopo che sull'uscita si è verificato un fronte positivo (variazione di stato dell'uscita da 0 a 1).

Esempio:

cylinder.ResetRisingEdge()

value := cylinder.RisingEgde()

18.5.8 Attivazione e reset, metodo Set / Reset

Con il metodo Set viene attivata un'uscita (stato TRUE), con il metodo Reset viene

resettata un'uscita (stato FALSE).

Sintassi

<nome istanza>.Set ( )

<nome istanza>.Reset ( )

Set e Reset vengono eseguiti durante l'elaborazione principale del programma. La fun-zione di approssimazione NON viene influenzata dal modulo.

Esempio:

Lin(pos1)

Lin(pos2)

18. Moduli


cylinder.Set() // impostazione dell'uscita cylinder su

TRUE

Lin(pos3)

cylinder.Reset() // impostazione dell'uscita cylinder su

FALSE

Lin(pos4)

18.5.9 Attivazione dell'uscita, metodo Write

Con il metodo Write si può descrivere lo stato di un'uscita. Lo stato desiderato (TRUE o FALSE) viene passato come parametro. Il funzionamento di Write è identico a quello dei metodi Set e Reset.

Sintassi

<nome istanza>.Write (Value: BOOL)

Il metodo Write viene eseguito durante l'elaborazione principale del programma.

La funzione di approssimazione NON viene influenzata dal modulo.

Esempio:

cylinder.Write(TRUE) // impostazione dell'uscita cylinder

su TRUE

state := FALSE

cylinder.Write(state) // impostazione dell'uscita cylinder

su FALSE

18.5.10 Impostazione dell'uscita per un determinato periodo, metodo Pulse

Il metodo Pulse imposta un'uscita su TRUE per un determinato periodo di tempo. L'esecuzione di Pulse avviene durante l'elaborazione principale del programma e non

influenza l'approssimazione.

Sintassi

<nome istanza>.Pulse (timeMs :DINT;

OPT pauseAtInterrupt: BOOL)


timeMs DINT Tempo per la durata dell'impulso in msec

pauseAtInterrupt BOOL Arresto del tempo dell'impulso quando il

programma è arrestato

Tabella 18.5 Parametri del metodo Pulse

18. Moduli


Il metodo Pulse aziona un'uscita digitale con un impulso di durata determinata. La durata

dell'impulso viene indicata in millisecondi. L'uscita viene sempre impostata su TRUE all'inizio dell'impulso e sempre su FALSE alla fine dell'impulso. Se però l'uscita ha già lo stato TRUE, al termine del tempo dell'impulso viene resettata.

Con il parametro opzionale “pauseAtInterrupt” si può indicare quale dovrà essere la reazione nel caso di un arresto del programma FTL. Se questo parametro non viene specificato, il sistema imposta internamente lo stato FALSE.

pauseAtInterruppt = TRUE:

Con TRUE viene arrestato il tempo dell'impulso e l'uscita viene impostata sul valore FALSE. Quando il programma FTL viene proseguito, l'uscita viene reimpostata su TRUE per il restante periodo di tempo. Una volta trascorso il tempo dell'impulso viene ripristinato lo stato FALSE.

pauseAtInterruppt = FALSE:

Se il parametro opzionale non è specificato o è impostato su FALSE, l'impulso viene eseguito dall'inizio alla fine. Un arresto del programma FTL non ha alcun effetto.

Nota

Se un programma FTL arrestato viene scaricato, la funzione dell'impulso viene automaticamente terminata e l'uscita impostata su FALSE.

Esempio:

// impostazione dell'uscita cylinder per 200 msec su TRUE

cylinder.Pulse(200)

18.6 Modulo di ingresso analogico AIN

Il modulo AIN serve per l'interrogazione e la gestione di un ingresso analogico.


Per l'istanziazione del modulo di ingresso analogico è necessario il riferimento hardware con l'ingresso analogico. Questo viene indicato tramite il parametro Input in fase di istanziazione.

Sintassi

<nome istanza> .AIN( <Timeout> : DINT, MAPX(“< input>”))

18. Moduli


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:


temperature : AIN := (-1, MAPX(“_system.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.


18. Moduli


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

Variabile Tipo Significato Stato alla creazione

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

WaitIns e Waitouts.




-1

Input AINPORT Rimando all'ingresso hardware ---

Tabella 18.6 Variabili del modulo di ingresso analogico

Timeout






Input

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

18.6.3 Metodi Il modulo dispone di più metodi:

Metodo Descrizione

WaitLss Attesa finché il valore di ingresso non è inferiore a quello

indicato

WaitGrt Attesa finché il valore di ingresso non è maggiore di quello

indicato

WaitIns Attesa finché il valore di ingresso non si trova entro il limite

indicato

WaitOuts Attesa finché il valore di ingresso non si trova oltre il limite

indicato

Read Lettura del valore di ingresso

Tabella 18.7 Metodi del modulo di ingresso analogico

18. Moduli


Nell'editor FTL, dopo l'immissione del punto i metodi disponibili vengono automatica-

mente visualizzati in una lista da dove possono essere selezionati.

Mediante l'unità di comando manuale si possono selezionare questi metodi dalla struttura a menu nella cartella “Analog Inputs”.

La figura mostra le selezione dei metodi del modulo AIN sull'unità di comando manuale.

18.6.4 Attesa finché il valore non è inferiore/superiore, metodo WaitLss, WaitGrt

I metodi WaitLss e WaitGrt consentono di interrogare un ingresso analogico per sapere se

il suo stato è superiore o inferiore al valore specificato. Il parametro Timeout del modulo viene considerato.

Sintassi

<nome istanza>.WaitLss(value : REAL, OPT ovlEnable : BOOL)

<nome istanza>.WaitGrt(value : REAL, OPT ovlEnable : BOOL)



value REAL Valore limite

Tabella 18.8 Parametri dei metodi WaitLss, WaitGrt

Esempio:

Lin(pos1)

temperature.WaitLss(65.0, TRUE)

Lin(pos2)

18. Moduli


18.6.5 Attesa finché il valore non è dentro/fuori dall'intervallo, metodo WaitIns, WaitOuts

Con i metodi WaitIns e WaitOuts si può aspettare finché il valore dell'ingresso analogico

non si trova all'interno o all'esterno dell'intervallo di valori specificato. Il parametro Timeout del modulo viene considerato.

Sintassi

<nome istanza>.WaitIns( minValue : REAL,

maxValue : REAL,

OPT ovlEnable : BOOL)

<nome istanza>.WaitOuts( minValue : REAL,

maxValue : REAL,

OPT ovlEnable : BOOL)



minValue REAL Valore limite inferiore

maxValue REAL Valore limite superiore

Tabella 18.9 Parametri dei metodi WaitIns, WaitOuts

Esempio

Lin(pos1)

// attesa finché la temperatura non si trova entro i limiti

temperature.WaitIns(50.0, 55.0, TRUE)

Lin(pos2)

18.6.6 Lettura del valore, metodo Read

Il metodo Read legge il valore corrente dell'ingresso analogico.

Sintassi

<nome istanza>.Read(OPT ovlEnable)


18. Moduli


Esempio

Lin(pos1)

// lettura della temperatura senza arresto sulla traiettoria

value := temperature.Read(TRUE)

Lin(pos2)

18.7 Modulo di uscita analogico AOUT

Il modulo AOUT serve per l'interrogazione e la gestione di un'uscita analogica.


Per l'istanziazione del modulo di uscita analogico è necessario il riferimento hardware con l'uscita analogica. Questo viene indicato tramite il parametro <port> in fase di istanzia-zione.

Sintassi

<nome istanza> .AOUT( <Timeout> : DINT, MAPX(“< port>”))


Esempio:

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


quantity : AOUT := (-1, MAPX(“_system.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.

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


18.7.2 Variabili

Il modulo di uscita analogico possiede le seguenti variabili:


creazione

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

WaitIns e Waitouts.




-1

Output AOUTPORT Rimando all'uscita hardware ---

Tabella 18.10 Variabili del modulo di uscita analogico

Timeout






18. Moduli


Output

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

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

18. Moduli


18.7.4 Scrittura del valore di uscita, metodo Write

Con il metodo Write viene scritta un'uscita analogica. Il valore nominale desiderato viene

passato al parametro “value”.

Sintassi

<nome istanza>.Write(value :REAL)


value REAL Valore nominale per l'uscita analogica

Tabella 18.12 Parametri del metodo Write

Esempio:

quantity.Write(110.0) // imposta l'uscita su 110.0

value := 1.3

quantity.Write(value) // imposta l'uscita su 1.3

18.7.5 Attesa finché il valore non è superiore/inferiore, metodo WaitLss, WaitGrt

I metodi WaitLss e WaitGrt consentono di interrogare un'uscita analogica per sapere se il

suo stato è superiore o inferiore al valore specificato. Il parametro Timeout del modulo viene considerato.

Sintassi

<nome istanza>.WaitLss(value : REAL, OPT ovlEnable : BOOL)

<nome istanza>.WaitGrt(value : REAL, OPT ovlEnable : BOOL)



value REAL Valore limite

Tabella 18.13 Parametri dei metodi WaitLss, WaitGrt

Esempio:

Lin(pos1)

// attesa finché non è inferiore a 110.0

quantity.WaitLss(110.0, TRUE)

Lin(pos2)

18. Moduli


18.7.6 Attesa finché il valore non è dentro/fuori dall'intervallo, metodo WaitIns, WaitOuts

Con i metodi WaitIns e WaitOuts si può aspettare finché il valore dell'uscita analogica non

si trova all'interno o all'esterno dell'intervallo di valori specificato. Il parametro Timeout del modulo viene considerato.

Sintassi

<nome istanza>.WaitIns(minValue : REAL,

maxValue : REAL, OPT ovlEnable : BOOL)

<nome istanza>.WaitOuts(minValue : REAL,

maxValue : REAL, OPT ovlEnable : BOOL)



minValue REAL Valore limite inferiore

maxValue REAL Valore limite superiore

Tabella 18.14 Parametri dei metodi WaitIns, WaitOuts

Esempio

Lin(pos1)

// attesa finché la qualità non rientra nei limiti

quantity.WaitIns(100.0, 110.0, TRUE)

Lin(pos2)

18.7.7 Lettura del valore di uscita, metodo Read

Il metodo Read legge il valore corrente dell'uscita analogica.

Sintassi

<nome istanza>.Read(OPT ovlEnable)


Esempio

Lin(pos1)

// lettura della quantità senza arresto sulla traiettoria

value := quantity.Read(TRUE)

Lin(pos2)

18. Moduli


18.8 Modulo orologio CLOCK

Il modulo orologio (Timer) può essere utilizzato per un semplice misurazione del tempo durante l'esecuzione del programma. I tempi vengono misurati in millisecondi.


Per l'istanziazione del modulo orologio CLOCK è necessario il nome del modulo. Il modulo

non possiede variabili.

Istanziazione

<nome istanza> : CLOCK


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.

18. Moduli


Con l'istanziazione sull'unità di comando manuale, la registrazione viene automatica-mente scritta nel file di dati.

18.8.2 Metodi

Il modulo orologio dispone dei seguenti metodi:

Metodo Descrizione

Reset Reset dell'orologio

Start Avvio dell'orologio

Stop Arresto dell'orologio

Read Lettura del tempo arrestato in msec

ToStr Conversione del tempo in una stringa

Tabella 18.15 Metodi del modulo orologio


Mediante l'unità di comando manuale si possono selezionare questi metodi dalla struttura a menu nella cartella “Timing Blocks”.

La figura mostra le selezione dei metodi del modulo CLOCK sull'unità di comando

manuale.

18. Moduli


18.8.3 Avvio dell'orologio, metodo Start

Con il metodo Start viene avviato il timer. Il momento di avvio viene memorizzato inter-

namente nel modulo. Se l'avvio viene impartito su un timer già arrestato, il timer arrestato viene riattivato e il tempo continua a scorrere. Il timer può essere riavviato solo con l'istruzione Reset.

Sintassi

<nome istanza>.Start ( )

Esempio:

Timer.Start() // l'orologio viene avviato

18.8.4 Arresto dell'orologio, metodo Stop

Il metodo Stop arresta una misurazione del tempo già avviata. Il tempo trascorso viene

calcolato internamente nel modulo e messo a disposizione per la lettura.

Sintassi

<nome istanza>.Stop ( )

Esempio:

Timer.Stop() // l'orologio viene arrestato

18.8.5 Reset dell'orologio, metodo Reset

Il richiamo del metodo Reset azzera il timer. Se viene eseguito un reset su un timer in

funzionamento, questo viene azzerato e poi continua a funzionare.

Sintassi

<nome istanza>.Reset ( )

Esempio:

Timer.Reset() // l'orologio viene resettato

18.8.6 Lettura dell'orologio, metodo Read

Con il metodo Read si può leggere il valore di tempo attuale in millisecondi (msec).

18. Moduli


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


Lin(pos3)

:

18.8.7 Conversione del valore di tempo in una stringa

Con il metodo ToStr si può convertire il valore di tempo attuale in una stringa con la

struttura <Giorni> <Ore>:<Minuti>:<Secondi>:<Millisecondi>.

Sintassi

<nome istanza>.ToStr(OPT ovlEnable : BOOL) : STRING


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

Esempio:

Dati:

time : STRING

Programma:

Lin(pos1)

18. Moduli


time := Timer.ToStr() // lettura con arresto sulla

traiettoria

Lin(pos2)

time := Timer.ToStr(TRUE) // lettura nell'elaborazione


Lin(pos3)

18.9 Modulo encoder ENCODER

Il modulo encoder può essere utilizzato nel programma per leggere gli encoder incremen-tali collegati, che possono essere al massimo due.


Per l'istanziazione del modulo encoder è necessario il riferimento hardware con l'ingresso. Questo viene indicato tramite il parametro <port> in fase di istanziazione.

Sintassi

<nome istanza> .ENCODER( <Timeout> : DINT, MAPX(“<port>”))


Esempio:

Un encoder viene impostato come istanza di un modulo:


enc0 : ENCODER := (-1, MAPX(“_system.Encoder_0”))


L'istanziazione avviene nella finestra di dialogo per la creazione di variabili, selezionando il tipo (<Type:>) ENCODER e impostando l'identificatore (<Identifier:>) encTrack. Nella riga <MAPTO ENCPORT> viene creato il riferimento reale con un ingresso encoder configurato.

18. Moduli



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


18.9.2 Variabili

Il modulo encoder possiede le seguenti variabili:


creazione

timeout REAL Timeout di attesa -1

port ENCPORT Rimando all'ingresso hardware ---

Tabella 18.16 Variabili del modulo encoder

Timeout – (attualmente privo di funzione in questo modulo)

Con il parametro Timeout si può definire un tempo di attesa. Il metodo del modulo attende lo stato del segnale richiesto per il tempo impostato. Attualmente il modulo encoder non dispone di metodi in grado di considerare il timeout.

Port

La variabile Port descrive il rimando all'ingresso hardware.

18.9.3 Metodi

Il modulo encoder dispone dei seguenti metodi:

Metodo Descrizione

Set Impostazione manuale del valore dell'encoder incrementale

Read Lettura del valore dell'encoder incrementale

Tabella 18.17 Metodi del modulo encoder

18. Moduli




Mediante l'unità di comando manuale si possono selezionare questi metodi dalla struttura a menu nella cartella “Incremental Encoder”.

La figura mostra le selezione dei metodi del modulo encoder sull'unità di comando manuale.

18.9.4 Impostazione dell'encoder, metodo Set

Con il metodo Set si può attivare un valore dell'encoder incrementale dal programma

utente.

Sintassi:

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


count DINT Valore sul quale deve essere impostato l'encoder incrementale

(incrementi)

mode SETCOUNTMODE Parametro per l'impostazione del momento di acquisizione

Tabella 18.18 Parametri del metodo Set

Il modulo imposta il valore in sincrono con l'elaborazione principale del programma, ma non arresta il calcolo preliminare. Nel parametro mode si può definire il momento in cui verrà impostato il valore.

mode Significato

DIRECT Il valore viene acquisito nel ciclo successivo

del sistema I/O

ZEROPULSE Il valore viene acquisito all'impulso zero

successivo dell'encoder

Tabella 18.19 Modalità del metodo Set

Esempio:

enc0.Set(1000, DIRECT)

18. Moduli


18.9.5 Lettura dell'encoder, metodo Read

Con il metodo Read si può leggere il valore corrente dell'encoder incrementale dal

programma utente.

Sintassi:

<ENCODER>.Read ( OPT <ovlEnable> : BOOL) : DINT


ovlEnable BOOL Parametro per l'impostazione del momento di lettura

Tabella 18.20 Parametri del metodo Read

Il metodo restituisce il valore incrementale dell'encoder. Questo valore non viene calcolato con il fattore di conversione. Per leggere il valore normale bisogna accedere direttamente alla porta dell'ingresso encoder con l'elemento Value.

Esempio di lettura del valore normale:

value := enc0.port.value

Esempio di lettura del valore incrementale:

value := enc0.Read()

18.10 Modulo CANopen COPDEVICE

Il modulo CANopen può essere utilizzato nel programma per accedere ad unità che sono collegate al CMXR tramite il bus CAN delle periferiche.

Attenzione

Con il bus CAN delle periferiche si possono azionare unità CANopen. Questa unità non sono però assoggettate al comportamento di STOP EMERGENZA della cinematica. Non si verifica nessuna frenatura controllata degli attuatori ausiliari. Se il bus CAN delle periferiche viene azionato da un programma parallelo, nel caso di uno STOP EMERGENZA esso non verrà arrestato!

Nota

Le modalità di attivazione delle singole unità collegate al CMXR tramite il bus CAN sono descritte nella rispettiva documentazione del costruttore del modulo.

18. Moduli



L'istanziazione del modulo CANopen avviene in modo automatico, in ragione della configu-razione I/O dell'unità di comando, e non può essere eseguita manualmente.

L'accesso alle unità CANopen collegate avviene tramite un nome univoco, preimpostato con il software di configurazione FCT. Il nome specificato in FCT non può essere utilizzato direttamente e perciò gli viene assegnata l'estensione “_copd”. Ciò vale sia per gli attuatori collegati al DriveBus che per le unità CANopen collegate al bus CAN delle periferiche.

Esempio:

L'asse 1 della cinematica viene denominato Axis1 nella configurazione DriveBus in FCT.

L'accesso avviene tramite Axis1_copd.MetodoModulo( ).

Configurazione CANopen:

[IO.ONBOARD.SLOTCAN:0.FX200A:0.CAN:0.COPDEVICE:1]

name=“Axis1” // nome dell'unità COP


Axis1_copd.WriteSDO(16#6060,0,7,eight_bits)

18.10.2 Metodi

Il modulo CANopen dispone dei seguenti metodi:

Metodo Descrizione

WriteSDO Scrittura di SDO

ReadSDOUnsigned Lettura di SDO senza segno matematico

ReadSDOSigned Lettura di SDO con segno matematico

Tabella 18.21 Metodi del modulo CANopen



Mediante l'unità di comando manuale si possono selezionare questi metodi dalla struttura a menu nella cartella “CANopen Devices”.

18. Moduli


La figura mostra le selezione dei metodi del modulo CANopen sull'unità di comando manuale.

18.10.3 Scrittura di SDO, metodo WriteSDO

Con il metodo WriteSDO è possibile scrivere pacchetti di dati sul bus CAN.

Sintassi:

<COPDEVICE>.WriteSDO ( <index> : DINT, <subindex> : DINT, <data> : DINT, <type> : SdoDataType ) : BOOL


index DINT Indice dell'SDO

subindex DINT Sottoindice dell'SDO

data DINT Dati da scrivere

type SdoDataType Tipo di dati (Enum)

eight_bits (8 bit)

sixteen_bits (16 bit)

thirtytwo_bit (32 bit)

Tabella 18.22 Parametri del metodo WriteSDO

Se la scrittura del pacchetto ha esito positivo viene restituito TRUE, altrimenti FALSE.

Esempio:

oData := 12000

Axis3_copd.WriteSDO(16#6085, 0, oData, thirtytwo_bits)

18.10.4 Lettura di SDO, metodo ReadSDOSigned

Con il metodo ReadSDOSigned è possibile leggere pacchetti di dati con segno matematico

dal bus CAN.

18. Moduli


Sintassi:

<COPDEVICE>.ReadSDOSigned (<index> : DINT, <subindex> : DINT, <data> : DINT) : BOOL




data DINT Dati da leggere

Tabella 18.23 Parametri del metodo ReadSDOSigned

Se la lettura del pacchetto ha esito positivo viene restituito TRUE, altrimenti FALSE.

Esempio:

dint_iData : DINT := 0

Programma:

Axis3_copd.ReadSDOSigned(16#6098, 0, dint_iData)

SetInfo(“metodo della corsa di riferimento letto: %1”,

dint_iData)

:

18. Moduli


18.10.5 Lettura di SDO, metodo ReadSDOUnsigned

Con il metodo ReadSDOUnsigned è possibile leggere pacchetti di dati dal bus CAN.

Il metodo riconosce automaticamente la lunghezza dei dati letti dal bus CAN. Questi vengono restituiti come valore a 32 bit senza segno matematico.

Sintassi:

<COPDEVICE>.ReadSDOUnigned (<index> : DINT, <subindex> : DINT, <data> : DWORD) : BOOL




data DWORD Dati da leggere

Tabella 18.24 Parametri del metodo ReadSDOUnsigned

Se la lettura del pacchetto ha esito positivo viene restituito TRUE, altrimenti FALSE.

19. Segnali delle periferiche



19.1 Utilizzo di ingressi e uscite digitali

I segnali digitali vengono definiti mediante la configurazione, dove ad ogni segnale hardware viene assegnato un proprio nome. Questi nomi possono essere utilizzati nel programma di movimenti per interrogazioni o per comandi.

Ogni segnale digitale è rappresentato sotto forma di un tipo di dati strutturato. Esso contiene i dati seguenti:

State : BOOL Stato del segnale TRUE o FALSE

Error : BOOL Informazioni su un errore del segnale

L'accesso a questi dati avviene tramite il nome hardware e l'operatore punto.

Esempio:

Un segnale d'ingresso del sensore è denominato “GripperOpen”. L'accesso allo stato del sensore sarà:

GripperOpen.State

Questa espressione è del tipo di dati BOOL e può essere utilizzata come una variabile booleana nel programma.

19.2 Utilizzo di ingressi e uscite analogici

I segnali analogici vengono definiti mediante la configurazione, dove ad ogni segnale hardware viene assegnato un proprio nome. Il nome può essere utilizzato come una variabile nel programma di movimenti e, in questo modo, si può ad es. utilizzare un valore analogico per un calcolo.

Ogni segnale analogico è rappresentato sotto forma di un tipo di dati strutturato. Esso contiene i dati seguenti:

Value : REAL Valore del segnale

Error : BOOL Informazioni su un errore del segnale

L'accesso a questi dati avviene tramite il nome hardware e l'operatore punto.



Esempio:

Un segnale d'ingresso analogico è denominato “Level”. L'accesso allo stato del sensore sarà:

Level.Value

Questa espressione è del tipo di dati REAL e può essere utilizzata come una variabile nel programma.

20. Esempi


20. Esempi Nei capitoli seguenti sono riportati esempi di utilizzo del linguaggio programmazione.

Avvertenza

Tutti gli esempi servono per descrivere l'utilizzo del linguaggio di programmazione, senza alcuna pretesa di correttezza, completezza e di presentazione degli esempi come applicazione in grado di funzionare. Se in un'applicazione vengono incorporati sottopro-grammi descritti in questi esempi, è necessario verificare che siano adatti all'uso previsto e garantirne il corretto funzionamento con una messa in funzione corrispondente.

La non osservanza può comportare danni alle cose e alle persone

20.1 Arresto di movimenti

Un robot di manipolazione deve prelevare un pannello da una pila di lamiere e depositarlo

su un nastro trasportatore a rulli. L'altezza esatta della pila non è nota. Il sistema di pinze è tuttavia provvisto di un sensore che consente di rilevare se l'utensile di presa urta un ostacolo. Questo sensore viene utilizzato per sondare il pannello di lamiera superiore. Per rilevare se una pila di lamiere è stata completamente elaborata è presente un ulteriore sensore (di rilevamento pila vuota).

Nastro

trasportatore a rulli Pila di lamiere

Sistema di pinze con

rilevamento di collisioni

Ingresso: inCollision

Sensore di rilevamento pila vuota

Ingresso: inStackNotEmpty

x

z

y

20. Esempi


Il programma di movimenti comprende le seguenti posizioni:

Descrizione Nome della variabile di posizione

Posizione di prelievo sulla pila di lamiere takePosStack

Posizione di sicurezza sopra la pila di lamiere safetyPosStack

Posizione di sicurezza sopra il nastro trasportatore

a rulli

safetyDepositPos

Posizione di deposizione sul nastro trasportatore

a rulli

depositPos

Posizione preliminare modificabile sopra la pila di

lamiere

prePosition

Tabella 20.1 Panoramica delle posizioni

Per questa applicazione si possono utilizzare ulteriori posizioni. L'esempio si limita tuttavia alle posizioni indicate.

Poiché l'altezza della posizione di prelievo non è nota, a causa dell'altezza variabile della pila, essa viene impostata sotto la pila.

safetyPosStack

takePosStack

safetyDepositPos

depositPos

20. Esempi


Programma di movimenti:

:

Vel(dynCart, 200) // velocità lenta

prePosition := safetyPosStack

WHILE TRUE DO

Lin(safetyPosStack)

WAIT inStackNotEmpty.State // verifica se ci sono pezzi

sulla pila

Lin(prePosition)

Vel(dynCart, 200) // velocità lenta

Lin(takePosStack)

WAIT inCollision.State // attesa segnale del sensore

per collisione

StopMove() // arresto del movimento

// rilevamento della posizione effettiva sopra la pila

ReadActualPos(prePosition)

// calcolo della distanza di sicurezza sopra la pila

prePosition.z := prePosition.z + 10

gripper.Set() // chiusura pinza

Vel(dynCart, 1000) // velocità rapida

Lin(safetyPosStack)

Lin(safetyDepositPos)

Lin(depositPos)

gripper.Reset() // apertura pinza

Lin(safetyDepositPos)

END_WHILE

:

Funzionamento

La cinematica si sposta sulla posizione di prelievo finché la pinza non viene a trovarsi sopra il pannello di lamiera e il sensore di rilevamento collisioni fornisce il segnale corrispondente. Questa operazione viene eseguita a velocità lenta per proteggere il sistema da eventuali danneggiamenti.

Per poter raggiungere una posizione possibilmente vicina sopra la pila al prossimo ciclo, la posizione effettiva sopra la pila viene memorizzata. Questa posizione viene poi integrata con una distanza di sicurezza in modo che, al prossimo ciclo, il sistema possa spostarsi sulla pila a velocità rapida. Infine viene attivata una velocità lenta fino al contatto finale con il pezzo.

20. Esempi


20.2 Utilizzo dei moduli di ingresso e di uscita

Durante l'istanziazione dei moduli di ingresso o di uscita si può definire un timeout. Se ad esempio si utilizza la funzione Wait del modulo nella sequenza di lavorazione, un timeout eventualmente attivato deve essere analizzato dal programma utente.

Programma di movimenti:

:

inSensor.Wait()

IF inSensor.Read() = FALSE THEN

//interruzione della sequenza

SetError(“Timeout over”)

RETURN

END_IF

//proseguimento della sequenza

Lin(pos)

:

Nota

L'emissione di un messaggio di errore provoca un'interruzione del movimento. Per poter proseguire la sequenza è necessario reset-tare il messaggio di errore.

20. Esempi


20.3 Controllo del calcolo preliminare dei record

Di seguito vengono descritte diverse possibilità, sulla base di esempi, per influenzare il calcolo preliminare dei record.

1. Attesa del segnale di ingresso digitale

Nello svolgimento del programma, con l'istruzione WAIT viene impostata l'attesa di un segnale di ingresso digitale. Se lo stato dell'ingresso digitale è FALSE, il calcolo prelimi-nare dei record viene arrestato. Se lo stato è TRUE, il calcolo preliminare viene proseguito. Ciò è illustrato nella figura seguente.

2. Contatori di cicli

Un sottoprogramma viene ripetuto con un ciclo per 10 volte. I cicli vengono conteggiati mediante un contatore di cicli. Il calcolo preliminare dei record interpreta il programma sequenziale e incrementa il contatore di cicli in modo corrispondente. Il calcolo preliminare dei record raggiunge così molto velocemente la fine del programma e allo stesso modo il contatore di cicli raggiunge il valore 10. In questo lasso di tempo l'elaborazione principale dei record ha raggiunto solo l'istruzione Lin(Pos1).

Se si desidera che il contatore visualizzi il ciclo effettivo, è necessario interrompere il

calcolo preliminare dei record con un'istruzione WaitTime. Dopodiché il contatore di cicli verrà incrementato sempre al raggiungimento di Pos3. Ciò è illustrato nella figura seguente.

Lin(Pos1)

Lin(Pos2)

Lin(Pos3)

Lin(Pos4)

WAIT Sensor.State

Lin(Pos5)

Lin(Pos6)

Lin(Pos7)

Lin(Pos8)

Lin(Pos9)

Elaborazione principale dei record

Calcolo preliminare dei record

Lin(Pos1)

Lin(Pos2)

Lin(Pos3)

Lin(Pos4)

WAIT Sensor.State

Lin(Pos5)

Lin(Pos6)

Lin(Pos7)

Lin(Pos8)

Lin(Pos9)


Calcolo

preliminare dei record

20. Esempi


20.4 Utilizzo delle pinze

Nella tecnica di manipolazione vengono utilizzati svariati tipi di pinze. Ogni processo di presa richiede un certo tempo per chiudere o per aprire la pinza. Questo tempo può influire in maniera decisiva sul tempo di ciclo.

Nota

I tempi di presa provocano un aumento del tempo di ciclo e perciò vanno sempre considerati. A seconda del tipo di pinza viene generato un tempo di attesa anche nel programma FTL per garantire l'apertura o la chiusura della pinza.

Nota

I tempi di attesa per gli stati Chiuso o Aperto nelle pinze pneu-matiche dipendono sempre dalla pressione impostata. Al variare della pressione occorre modificare anche i tempi di attesa. Se sul sistema di pinze sono applicati sensori di finecorsa, in genere si può rinunciare ai tempi di attesa.

Nei capitoli seguenti viene rappresentata l'integrazione di vari tipi di pinze nel controller CMXR.

count := 0

Lin(Pos1)

Lin(Pos2)

LOOP 10 DO

Lin(Pos3)

count:=count + 1

Lin(Pos4)

END_LOOP

Lin(Pos5)



count := 0

Lin(Pos1)

Lin(Pos2)

LOOP 10 DO

Lin(Pos3)

WaitTime (1)

count:=count + 1

Lin(Pos4)

END_LOOP

Lin(Pos5)



20. Esempi


20.4.1 Ventose

Le ventose sono tipi di pinze che permettono di eseguire cicli di presa molto rapidi. Richiedono un vuoto che può essere generato ad es. da un ugello di Venturi.

Al momento di prelevare un pezzo deve essere presente il vuoto. Quando il pezzo viene depositato, oltre al disinserimento del vuoto deve essere eseguito un impulso di espul-sione per eliminare il vuoto formatosi nella ventosa. I generatori del vuoto del tipo VN-..-H-...-A eseguono l'impulso di espulsione automaticamente dopo il disinserimento del vuoto.

In altri modelli è necessario attivare questo impulso di espulsione mediante un segnale digitale supplementare.

Ventosa ESG Generatore del vuoto VN-..-H-...-A con

impulso di espulsione incorporato

Esempio:

Un pezzo deve essere spostato da una posizione pos2 alla posizione pos4.

Come generatore del vuoto viene utilizzato un ugello di Venturi azionato mediante un'uscita digitale del CMXR. A tale scopo viene impostato un modulo di uscita digitale.

pos2 pos4

pos3 pos1

20. Esempi


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 pos3. L'istruzione seguente WaitTime impedisce un'approssimazione in quanto il calcolo preliminare dei record viene arrestato in questo punto e proseguito al termine del tempo di attesa impostato.

20. Esempi


Profilo di movimento:

Comportamento temporale:

Tempo

pos1 pos3

Tempo di attesa

pos4

pos3

pos2

pos1

pos2 pos4

pos3 pos1


Velocità

20. Esempi


20.4.2 Pinze parallele pneumatiche

Le pinze parallele sono equipaggiate con dita di presa che vengono chiuse parallelamente. Le dita di presa possono essere adattate individualmente all'applicazione.

In genere le pinze parallele vengono azionate con due uscite separate per l'apertura e la

chiusura. Opzionalmente si possono integrare dei sensori sulle pinze per ottenere segnali di feed-back (aperta o chiusa) mediante i finecorsa.

Esempio:

Un pezzo deve essere spostato da una posizione pos2 alla posizione pos4.

Viene utilizzata una pinza parallela dotata di sensori di finecorsa. Si ottengono i segnali digitali seguenti, che vengono incorporati sotto forma di moduli nella programmazione FTL.

pos2 pos4

pos3 pos1

20. Esempi


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:



= 5000 mm/sec²


Lin(pos1)

outGripperOpen.Set() // apertura pinza

outGripperClose.Reset()

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


outGripperClose.Set() // chiusura pinza

outGripperOpen.Reset()

inGripperClosed.Wait() // attesa fino alla chiusura

Lin(pos1)

Lin(pos3)


outGripperOpen.Set() // apertura pinza

outGripperClose.Reset()

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

Lin(pos3)

Funzionamento:

Se sono presenti sensori per la segnalazione di feed-back delle posizioni di finecorsa delle pinze, non sono necessari tempi di attesa.

I movimenti vengono eseguiti con un'approssimazione della velocità del 75 %. Mediante l'attesa delle segnalazioni di finecorsa con il metodo del modulo Wait viene inibita un'approssimazione sulle posizioni di presa e di deposizione. Il calcolo preliminare dei record viene arrestato in questa posizione e proseguito dopo l'attivazione del segnale di ingresso digitale.

20. Esempi




Tempo

pos3

pos4

pos3

pos2

pos1

Tempo di attesa fino al segnale di feed-back per

pinza chiusa

Tempo di attesa fino al segnale di feed-back per

pinza aperta

Velocità

pos1

pos2 pos4

pos3 pos1


20. Esempi


20.4.3 Unità oscillante di presa pneumatica

L'unità oscillante di presa pneumatica HGDS della Festo combina una pinza parallela con un attuatore oscillante in un'unica unità.

L'unità HGDS offre la possibilità di montare sensori per il rilevamento dei fine corsa della pinza e dell'attuatore oscillante. I sensori sono necessari per comandare l'applicazione in modo sicuro.

Esempio:

Un pezzo deve essere spostato da una posizione pos2 alla posizione pos4 con una rotazione di 90 gradi.

Viene utilizzata l'unità HGDS, equipaggiata con sensori per il rilevamento delle posizioni di fine corsa. Si ottengono i segnali digitali seguenti, che vengono integrati sotto forma di moduli nella programmazione FTL.

pos2 pos4

pos3 pos1

Rotazione di 90 gradi

Unità oscillante di presa HGDS con pinza parallela

20. Esempi


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


outGripperClose.Set() // chiusura pinza

outGripperOpen.Reset()

inGripperClose.Wait() // attesa fino alla chiusura della

pinza

Lin(pos1)

outPos0Degree.Reset() // rotazione a 90 gradi

outPos90Degree.Set()

Lin(pos3)

inPos90Degree.Wait(TRUE) // rotazione a 90 gradi con

approssimazione


outGripperClose.Reset() // apertura pinza

outGripperOpen.Set()

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

pinza

Lin(pos3)

20. 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'approssimazione. Ciò significa che, in assenza della segnalazione di feed-back della rotazione a 90 gradi durante la corsa verso pos4, il movimento viene arrestato e si attende finché non si attiva il segnale di feed-back. Se il segnale di feed-back è già presente, viene direttamente eseguito un movimento di approssimazione verso la pos4.


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


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

20. Esempi


20.5 Utilizzo dell'interfaccia PLC

20.5.1 Definizione del compito

Nell'esempio seguente vengono prelevati pezzi dalla posizione “pickPos” (posizione di prelievo) e trasportati nella posizione “depositPos” (posizione di deposizione). La posi-zione di prelievo è dinamica. La coordinate esatte vengono calcolate in ogni ciclo da un sistema di visione e inviate all'unità di comando mediante l'interfaccia PLC PROFIBUS.

Per la sequenza vengono calcolate due posizioni intermedie dinamiche dalla posizione di partenza e dalla posizione finale. Queste posizioni verranno utilizzate come punti di appoggio durante la sequenza.

Se il PLC non invia i dati per tempo, il ciclo viene arrestato sulla posizione “wartePos”

finché il PLC non è pronto.

20.5.2 Interfaccia PLC

Lo scambio dei dati tra il controller CMXR e il PLC viene realizzato con due bit di sincroniz-zazione. Nel primo passo il PLC segnala che i dati sono stati inviati. Appena i dati vengono ricevuti dal CMXR, ciò viene segnalato al PLC. Infine vengono resettati entrambi i segnali di interfaccia. La sequenza è rappresentata nel diagramma di flusso seguente.

Acquisizione della

posizione

Segnale dal PLC (dati pronti)

plc_inboolreg[0]

Segnale al PLC (dati letti)

plc_outboolreg[0]

Nuova posizione trasmessa

Posizione acquisita

Fine trasmissione

pickPos depositPos

aboveDepositPos abovePickPos waitPos

20. Esempi


20.5.3 Programma sequenziale

Variabili:

waitPos : CARTPOS := (...)

pickPos : CARTPOS := (...)

depositPos : CARTPOS := (...)

abovePickPos : CARTPOS := (...)

aboveDepositPos : CARTPOS := (...)

gripper : DOUT := (...)

Programma:

// inizializzazione

Acc(dynCart, 4000)

Vel(dynCart, 100)

Lin(waitPos)

WHILE TRUE DO

// Handshake

WAIT plc_inboolreg[0] // PLC segnala una nuova posizione

pickPos := plc_cposreg[0]

abovePickPos.x := plc_cposreg[0].x

abovePickPos.y := plc_cposreg[0].y

plc_outboolreg[0] := TRUE // conferma l'acquisizione

WAIT NOT plc_inboolreg[0] // attesa di una reazione del PLC

plc_outboolreg[0] := FALSE

// accostamento della posizione di prelievo

Lin(abovePickPos)

Lin(pickPos)

// presa

gripper.Set()

WaitTime(200)

// accostamento della posizione di deposizione

Lin(abovePickPos)

Lin(aboveDepositPos)

20. Esempi


Lin(depositPos)

// deposizione

gripper.Reset()

WaitTime(200)

// accostamento della posizione di attesa

Lin(aboveDepositPos)

Lin(waitPos)

END_WHILE

21. Struttura a menu delle istruzioni FTL



Per semplificare la programmazione, sull'unità di comando manuale CDSA e nell'editor di programmazione FTL viene visualizzata una struttura a menu contenente tutte le istruzioni FTL disponibili. Di seguito sono rappresentate tutte le istruzioni disponibili per la “Programmazione FTL di base”.

Rappresentazione della struttura a menu sull'unità di comando manuale CDSA:

PLC-Interface

ProgHold

Mathematical functions

Position Functions

o ReadTargetPos

o ReadActualPos

o SavePosition

SIN

COS

TAN

COT

LN

ABS

SQRT

EXP

ASIN



ACOS

ATAN

ATAN2

ACOT

Time

TimeToStr

Reference Axis

RefAxis

RefAxisAsync

WaitRefFinished

IsAxisReferenced

Movement

Ptp

Lin

CircIp

LinToCircIp

PtpToCircIp

MoveAxisPtp

MoveAxisCart

PtpRel

LinRel

StopMove

Dynamics

DynOvr

Vel

Acc

Jerk

Ovr

OvlVel

OvlCart

Ramp

VconstOn

VconstOff



Program commands

WaitOnPath

StopProgram

WaitTime

WaitOnPos

CALL

RUN

KILL

… := …

//

WAIT

LABEL

GOTO

IF … GOTO

IF … THEN … END_IF

ELSE

ELSIF … THEN

WHILE … DO … END_WHILE

LOOP

RETURN

Robot commands

Reference Systems

o SetRefSys

o SetRefSys3P

o SetRefSysWorld

Tool

System functions

Time measurement

o CLOCK.Reset

o CLOCK.Start

o CLOCK.Stop

o CLOCK.Read

o CLOCK.ToStr



Additional commands

o SHR

o SHL

o ROR

o ROL

o STR

o CHR

o ORD

Message System

SetInfo

SetWarning

SetError

I/O-Modules

Analog Input

o AIN.Read

o AIN.WaitLss

o AIN.WaitGrt

o AIN.WaitIns

o AIN.WaitOuts

Analog Output

o AOUT.Write

o AOUT.Read

o AOUT.WaitLss

o AOUT.WaitGrt

o AOUT.WaitIns

o AOUT.WaitOuts

CANopen devices

o COPDEVICE.WriteSDO

o COPDEVICE.ReadSDOUnsigned

o COPDEVICE.ReadSDOSigned

Digital Input

o DIN.Read

o DIN.Wait

o DIN.WaitN

o DIN.RisingEdge

o DIN.ResetRisingEdge



Digital Output

o DOUT.Set

o DOUT.Reset

o DOUT.Write

o DOUT.Pulse

o DOUT.Read

o DOUT.ResetRisingEdge

o DOUT.Wait

o DOUT.WaitN

o DOUT.RisingEdge

Incremental Encoder

o ENCODER.Set

o ENCODER.Read

Indice analitico


#

##........................................................ 61

/

// ........................................................ 61

_

_global.tt ............................................. 19

A

ABS ................................................... 152 Acc ...................................................... 91 ACOS ................................................. 147

ACOT ................................................. 150 AIN .................................................... 170 AOUT ................................................. 175 Array ................................................... 31

ASIN .................................................. 146 ATAN ................................................. 149 ATAN2 ............................................... 151 AXISPOS .............................................. 63

C

Calcolo preliminare dei record ........................... 54, 56, 198

CALL .................................................... 51 CARTPOS ............................................. 63 CHR ................................................... 155 CircIp ................................................... 81 CLOCK ............................................... 180 Commento ........................................... 61 Conversioni del tipo ............................. 30 COS ................................................... 147 COT ................................................... 150

D

DIN .................................................... 159

DO ....................................................... 39 DOUT ................................................. 163 DynOvr ................................................ 96

E

ENCODER .......................................... 184 Error .................................................. 192 Esempio

Arresto di movimenti ...................... 194 Controllo del calcolo preliminare dei

record.......................................... 198

Utilizzo dei moduli di ingresso e di

uscita .......................................... 197 Utilizzo delle pinze ......................... 199 Utilizzo dell'interfaccia PLC ............ 210 WAIT con ingresso digitale ............... 57

EXP ................................................... 151

F

FTL ........................................... 12, 16, 19

G

GOTO .................................................. 48

I

IF…GOTO ............................................. 47 IF…THEN ............................................. 45 Interfaccia Profibus ........................... 130 IS_MAPPED ......................................... 37

IsReferenced ..................................... 121

J

Jerk ..................................................... 92

K

KILL ..................................................... 54

L

LABEL ................................................. 47 Lin....................................................... 74 LinRel .................................................. 76 LinToCircIp .......................................... 85 LN ..................................................... 151 LOOP .................................................. 49 LOW, HIGH .......................................... 34

M

MAP .................................................... 37 MAPTO ................................................ 37

MoveAxisCart ...................................... 72 MoveAxisPtp ....................................... 72

O

ORD .................................................. 155 OvlCart .............................................. 107 OvlVel ............................................... 105 Ovr ...................................................... 94

Indice analitico


P

Parole chiave ....................................... 24 plc_AxisPos ....................................... 133 plc_CartPos ....................................... 133 plc_RefSys ......................................... 134 plc_VarDint ........................................ 132 Posizione cartesiana ............................ 66 Posizione dell'asse .............................. 64 ProgHold ........................................... 135 Ptp ...................................................... 67 PtpRel ................................................. 70 PtpToCircIp .......................................... 83

R

Ramp ................................................... 98 Read .................................................. 187 ReadActualPos .................................. 142

ReadSDOSigned ................................ 189 ReadSDOUnsigned ............................ 191 ReadTargetPos .................................. 143 Record di programma disattivato ......... 61 RefAxis .............................................. 116 RefAxisAsync ..................................... 118 RETURN ............................................... 52 ROL ................................................... 154

ROR ................................................... 154 RUN ..................................................... 54

S

SavePosition ..................................... 144 Segmento nullo ................................. 103 Set .................................................... 186 SetError ............................................. 141 SetInfo .............................................. 139 SetRefSys .......................................... 111 SetRefSys3P ...................................... 112 SetRefSysWorld ................................. 114

SetWarning........................................ 140

SHL ................................................... 153

SHR ................................................... 153 SIN .................................................... 146 Sistemi di riferimento ........................ 134 SQRT ................................................. 152 State ................................................. 192 StopMove ........................................... 86 StopProg ............................................. 87 STR ................................................... 155

T

TAN ................................................... 149 TCP ................................................... 122

Tempo di attesa .................................. 54 tid ................................................. 19, 20 Time .................................................. 144 TimeToStr ......................................... 145

tip ....................................................... 19 Tipi di dati ........................................... 28 Tool .................................................. 125

U

Utensili ............................................. 122

V

Value ................................................ 192 VconstOff .......................................... 101 VconstOn ............................................ 99 Vel ...................................................... 90

W

WAIT ................................................... 56 WaitOnPath ......................................... 58 WaitOnPos .......................................... 60 WaitRefFinished ................................ 120 WaitTime............................................. 54 WHILE ................................................. 48 WriteSDO .......................................... 189

Indice analitico


Festo€¦ · Festo GDCP-CMXR-SW-IT it 0909a 3 Edizione...

Documents

Transcript of Festo€¦ · Festo GDCP-CMXR-SW-IT it 0909a 3 Edizione...