Proghbexperte r41 It

SOFTWARE
KR C...
Programmazione esperto
Release 4.1
ProgHBExperte R4.1 08.01.00 it
1 di 214
e Copyright KUKA Roboter GmbH
E’ vietato riprodurre o consegnare a terzi questa documentazione o parti di essa salvo l’esplicita autorizzazione dell’editore.
Nell’unità di controllo possono essere operative ulteriori funzioni non descritte in questa documentazione. L’utente però non ha il diritto di
pretendere queste funzioni in caso di sostituzione o di assistenza.
Il contenuto di questa documentazione e stato verificato circa la sua conformità con l’hardware e il software descritto. Nonostante ciò non
possono essere escluse delle divergenze, per cui non viene garantita la conformità totale. Le informazioni di questa documentazione vengono
in ogni caso controllate regolarmente ed eventuali correzioni verranno integrate nelle edizioni successive.
Ci riserviamo il diritto di apportare modifiche tecniche che non hanno effetto sulla funzione.
PD Interleaf
2 di 214
Indice
1 Generalità per quanto riguarda i programmi KRL . . . . . . . . . . . . . . . . . . . 7

1.1 Struttura e stesura di programmi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.1.1 Interfaccia grafica programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.1.2 Concetto dei file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.1.3 Struttura del file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Stesura ed editazione di programmi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.2.1 Stesura di un nuovo programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.2.2 Editare, compilare e unire un programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.3 Modifica di programmi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.3.1 Correzione programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.3.2 Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.3.2.1 Funzioni di blocco . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.3.2.2 Copia (CTRL--C) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.3.2.3 Incolla (CTRL--V) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.3.2.4 Taglia (CTRL--X) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.3.2.5 Cancella . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.3.2.6 Trova . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.3.2.7 Sostituisci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.4 Nascondere parti di programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.4.1 FOLD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.4.1.1 Programma esemplare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.5 Modi di esecuzione programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.6 Gestione errori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.7 Commenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2 Variabili e dichiarazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.1 Variabili e nomi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.2 Oggetti di dati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.2.1 Dichiarazione ed inizializzazione di oggetti di dati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.2.2 Tipi di dati semplici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.2.3 Campi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.2.4 Catene di caratteri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.2.5 Strutture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.2.6 Tipi di enumerazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
2.3 Manipolazione dei dati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
2.3.1 Operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
2.3.1.1 Operatori aritmetici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
2.3.1.2 Operatore geometrico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
2.3.1.3 Operatori di confronto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.3.1.4 Operatori logici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
2.3.1.5 Operatori bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
2.3.1.6 Priorità di operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.3.2 Funzioni standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
2.4 Variabili di sistema e file di sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3 Programmazione del movimento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

3.1 Utilizzo di diversi sistemi di coordinate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
3 di 214
3.2 Movimenti da punto a punto (PTP) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

3.2.1 Generalità (PTP sincrono) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
3.2.2 Profilo di traslazione superiore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
3.2.3 Comandi di movimento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
3.3 Movimenti lungo la traiettoria (Movimenti CP = Continuous Path) . . . . . . . . . . . . . . . . . . . . . 78
3.3.1 Velocità ed accelerazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
3.3.2 Gestione dell’orientamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
3.3.3 Movimenti lineari . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
3.3.4 Movimenti circolari . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
3.4 Processo avanzato del calcolatore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
3.5 Movimenti approssimati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
3.5.1 Approssimazione PTP--PTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
3.5.2 Approssimazione LIN--LIN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
3.5.3 Approssimazione CIRC--CIRC ed approssimazione CIRC--LIN . . . . . . . . . . . . . . . . . . . . . . . 97
3.5.4 Approssimazione PTP--traiettoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
3.5.5 Cambio utensile durante l’approssimazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
3.6 Apprendimento di punti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
3.7 Parametri di movimento (CmdMotionParam) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
4 KRL assistent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

4.1 Indicazioni di posizione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
4.2 Posizionamento [PTP] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
4.3 Movimento rettilineo [LIN] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
4.4 Movimento circolare [CIRC] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
5 Controllo dell’esecuzione del programma . . . . . . . . . . . . . . . . . . . . . . . . . 117

5.1 Diramazioni di programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
5.1.1 Istruzione di salto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
5.1.2 Salto condizionato . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
5.1.3 Smistatore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
5.2 Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
5.2.1 Loop di conteggio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
5.2.2 Loop respingente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
5.2.3 Loop non respingente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
5.2.4 Loop continuo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
5.2.5 Termine anticipato di esecuzioni di loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
5.3 Istruzioni di attesa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
5.3.1 Attesa fino al presentarsi di un evento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
5.3.2 Tempi di attesa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
5.4 Arresto del programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
5.5 Conferma di messaggi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
6 Istruzioni di immissione/emissione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

6.1 Generalità . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
6.2 Ingressi/uscite binari . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
6.3 Ingressi/uscite digitali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
4 di 214
6.3.1 Dichiarazione di segnali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
6.3.2 Settaggio di uscite nel punto di destinazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
6.4 Uscite a impulso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
6.5 Ingressi/uscite analogici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
6.5.1 Uscite analogiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
6.5.2 Ingressi analogici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
6.6 Ingressi digitali predefiniti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
7 Sottoprogrammi e funzioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147

7.1 Dichiarazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
7.2 Richiamo e passaggio di parametri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
8 Trattamento interrupt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

8.1 Dichiarazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
8.2 Attivazione di interrupt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
8.3 Arresto di movimenti in corso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
8.4 Annullamento di routine di interrupt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
8.5 Utilizzo di flag ciclici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
9 Trigger -- Azioni di commutazione riferite alla traiettoria . . . . . . . . . . . . 167

9.1 Azione di commutazione al punto di partenza o al punto di destinazione della traiettoria . 167
9.2 Azione di commutazione in un punto qualsiasi sulla traiettoria . . . . . . . . . . . . . . . . . . . . . . . . 171
10 Liste dati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177

10.1 Liste dati locali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
10.2 Liste dati globali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
11 Editor esterno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

11.1 Avvio dell’editor esterno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
11.2 Comando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
11.3 Menù “File” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
11.3.1 Apri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
11.3.2 Salva . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
11.3.3 Chiudi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
11.3.4 Esci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
11.4 Menù “Edit” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
11.4.1 Taglia (“CTRL”--”X”) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
11.4.2 Copia (“CTRL”--”C”) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
11.4.3 Incolla come ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
11.4.4 Cancella . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
11.4.5 Seleziona tutto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
11.5 Menù “Util” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
11.5.1 Mirror . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
11.5.2 Inserimento Manuale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
11.5.3 Cambio blocco . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
5 di 214
11.5.4 Pulizia lista file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

11.5.5 Regolazione TCP oppure BASE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
11.6 Menù “HotEdit” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
11.6.1 Base, TCP e World . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
11.6.2 Limits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
11.6.3 TTS (Sistema di coordinate di correzione) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
11.6.3.1 Config Point In TTS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
11.6.3.2 Limits--TTS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
11.7 Menù “ExtUtil” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
11.7.1 File -- Mirror . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
11.7.2 File -- Shift . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
11.7.2.1 Utilizzare il file di riferimento esistente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
11.7.2.2 Creare un nuovo file di riferimento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
11.7.3 Settaggio limiti software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
11.8 Menù “Aiuto” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
11.8.1 Versione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
11.8.2 In primo piano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
6 di 214
1 Generalità per quanto riguarda i programmi KRL
1 Generalità per quanto riguarda i programmi KRL

1.1 Struttura e stesura di programmi
1.1.1 Interfaccia grafica programma
Appena si è passato al livello esperto, l’interfaccia grafica cambia nel seguente modo:
Mentre per l’utente tutti i file di sistema sono invisibili, l’esperto può vederli ora nella finestra
di programmazione ed anche editarli. Inoltre sul livello esperto vengono visualizzati oltre ai
nomi dei file ed ai commenti anche le estensioni, gli attributi e le dimensioni dei file.
Nella figura precedente vengono visualizzati nella finestra di programmazione i file e le direc-
tory del percorso “R1”.
7 di 214
Come standard sono presenti dopo l’installazione del software KRC1 nella directory
“KRC:\R1\MADA\” i file riportati di seguito:
File Significato
$MACHINE.DAT Lista dei dati di sistema con variabili di sistema per l’adattamento
tra controllo e robot
$ROBCOR.DAT Lista dei dati di sistema con dati per il modello dinamico del robot
MACHINE.UPG File di sistema per upgrades futuri
ROBCOR.UPG File di sistema per upgrades futuri
Nella directory “KRC:\R1\SYSTEM\” si trovano i seguenti file:
File Significato
$CONFIG.DAT Lista dei dati di sistema con dati di configurazione generali
BAS.SRC Pacchetto base per il controllo del movimento
IR_STOPM.SRC Programma per la gestione errori in caso di anomalie
SPS.SUB Submitfile per la sorveglianza parallela
Nella directory “KRC:\R1\TP\” si trovano i seguenti file:
File Significato
A10.DAT Pacchetto tecnologico per la saldatura ad arco con tensioni pilota
A10.SRC analogiche
A10_INI.DAT Pacchetto tecnologico per l’inizializzazione della saldatura ad arco
A10_INI.SRC con tensioni pilota analogiche
A20.DAT Pacchetto tecnologico per la saldatura ad arco con numeri di
A20.SRC programma digitali
A50.DAT Pacchetto tecnologico per l’utilizzo del sensore dell’arco “Libo”
A50.SRC
ARC_MSG.SRC Programma per la programmazione di messaggi per la saldatura
sotto gas inerte.
ARCSPS.SUB Submitfile per saldatura ad arco
BOSCH.SRC Programma per la saldatura a punti con interfaccia seriale verso il
timer per saldatura a punti Bosch PSS5200.521C
COR_T1.SRC Programma per la correzione utensile (versione vecchia)
CORRTOOL.DAT Programma per la correzione utensile
CORRTOOL.SRC
FLT_SERV.DAT Programma per la gestione errori definita dall’utente per la
FLT_SERV.SRC saldatura ad arco
H50.SRC Pacchetto Gripper
H70.SRC Pacchetto Touchsensor
MSG_DEMO.SRC Programma con esempi di messaggi operativi
NEW_SERV.SRC Programma per la modifica di reazioni errori per FLT_SERV
P00.DAT Pacchetto di programmi per l’accoppiamento con un PLC
P00.SRC
8 di 214
1 Generalità per quanto riguarda i programmi KRL (segue)
PERCEPT.SRC Programma per il richiamo del protocollo PERCEPTRON

USER_GRP.DAT Programma per il pilotaggio del gripper definito dall’utente
USER_GRP.SRC
USERSPOT.DAT Pacchetto di software per la saldatura a punti definita dall’utente
USERSPOT.SRC
WEAV_DEF.SRC Programma per movimenti di oscillazione per la saldatura sotto
gas inerte
Nella directory “KRC:\R1\” si trova il seguento file:
CELL.SRC Programma per il controllo di robot tramite un PLC centrale. In

questo caso viene selezionato un programma pezzo in base ad
un numero di programma.
9 di 214
1.1.2 Concetto dei file

Un programma KRL può essere composto da file SRC e file DAT.
Ulteriori informazioni sulla stesura di un programma sono contenute in questo capitolo,

paragrafo [Stesura ed editazione di programmi].
Il file “SRC” è il file con il codice di programma vero e proprio. Esistono le varianti DEF e
DEFFCT (con valore di ritorno). Il file “DAT” contiene invece i dati specifici di programma.
Questa divisione si basa sul concetto dei file del KRL: il programma include oltre al ciclo di
lavorazione anche diverse azioni che il robot industriale deve eseguire, che possono essere
determinati cicli di movimento, l’apertura o la chiusura di un gripper fino a processi complessi
come ad esempio il comando di una pinza per saldatura tenendo conto di determinate condi-
zioni marginali.
Per la prova di programmi è utile o magari indispensabile poter eseguire delle operazioni
parziali singolarmente. Il concetto dei file realizzato nel KRL soddisfa le esigenze particolari
della programmazione robot.
1.1.3 Struttura del file

Un file è l’unità che il programmatore crea. Un file corrisponde dunque ad un file sul disco
rigido o nella memoria (RAM). Ogni programma nel KRL può consistere in uno o più file. I
programmi semplici sono composti da un solo file. Per operazioni più complesse conviene
che un programma sia composto da diversi file.
Informazioni dettagliate su sottoprogrammi e funzioni sono contenute nel capitolo [Sotto-

programmi e funzioni].
La struttura interna di un file KRL è costituita da una sezione delle dichiarazioni, una
sezione delle istruzioni come anche da un max. di 255 sottoprogrammi e funzioni locali.
DEF Il nome dell’oggetto senza estensione è allo stesso tempo il nome del file e viene quindi
riportato nella dichiarazione con DEF. Il nome puo essere composto da un max. di 24 caratteri
e non dev’essere una parola chiave (vedi capitolo [Variabili e dichiarazioni]). Ogni file inizia
con la dichiarazione “DEF” e finisce con “END”:
DEF NAME(x1:IN)
Dichiarazioni
Istruzioni
END
Dichiarazioni Le dichiarazioni vengono analizzate già prima dell’elaborazione del programma cioè durante
la traduzione. Nella sezione delle dichiarazioni non deve trovarsi quindi nessuna istruzione.
La prima istruzione è l’inizio della sezione delle istruzioni.
Istruzioni Le istruzioni sono delle dichiarazioni di carattere dinamico: vengono cioè eseguite durante
l’elaborazione del programma.
Lista dati Un programma robot può essere costituito solo da un file di programma o da un file di
programma con la relativa lista dati. L’appartenenza tra la lista dati e il file viene contrassegnata
tramite il nome comune. I nomi si distinguono soltanto nell’estensione, ad es.:
File: PROG1.SRC
Lista dati: PROG1.DAT
10 di 214
Nelle liste dati sono ammesse soltanto assegnazioni di valore con “=”. Se la lista dati
e il file hanno lo stesso nome, le variabili dichiarate nella lista dati possono essere utilizzate
nello stesso modo delle variabili dichiarate nel file SRC.
Informazioni dettagliate su questo argomento sono contenute nel paragrafo [Liste dati].
APPUNTI:
11 di 214
1.2 Stesura ed editazione di programmi

1.2.1 Stesura di un nuovo programma
Poiché un programma robot può essere scritto anche senza lista dati, il file e la lista dati non
vengono creati automaticamente in contemporanea sul livello esperto. Per creare un
programma azionare il softkey “Nuovo”. Appare la seguente finestra:
Viene richiesto di selezionare un template. Utilizzare a questo scopo i tasti freccia e confer-
mare col softkey “OK” oppure col tasto return.
I templates disponibili non possono essere creati in tutte le directory.
Ulteriori informazioni sui templates sono contenute nel Manuale d’uso, nella documen-
tazione [Operazione], capitolo [Navigatore], paragrafo [Apendice].
I differenti templates in dettaglio:

Modul:
Viene creato un file SRC e DAT che contiene un nucleo di programma.
Expert:
Viene creato un file SRC e DAT che contiene unicamente la riga DEF¼ e END.
Cell:
In questo caso viene creato soltanto un file SRC che contiene un nucleo di programma.
Questo programma serve per il controllo del robot tramite un PLC centrale.
Function:
In questo caso viene creata una funzione (file SRC) che contiene la riga DEF¼ e END.
Submit:
Viene creato un file SUB con nucleo di programma. Il submitfile contiene istruzioni e può
essere utilizzato ad es. per la sorveglianza ciclica (gripper, ecc.). Il submitfile lavora in
parallelo al funzionamento del robot e viene gestito dall’interpreter del controllo.
Expert Submit:
Come nel caso del template Submit viene creato un file SUB che contiene però solo la
riga DEF¼ e END.
La riga DEF¼ e END e i nuclei di programma dei singoli templates sono contenuti ad es. per
il template Cell sotto “C:\KRC\ROBOT\TEMPLATE\CellVorgabe.src”.
12 di 214
Dopo aver selezionato il relativo template viene richiesto di immettere un nome per il file
creato.
Nome del file Estensione del file Commento

(max. 24 caratteri) (SRC, DAT o SUB)
Il nome del file è come unico elemento assolutamente necessario e puo essere composto da
max. 24 caratteri. L’estensione del file viene aggiunta automaticamente. Se si desidera inse-
rire un commento, spostare il cursore tramite il tasto freccia destra sul relativo campo e digi-
tare il testo.
Premere il softkey “OK” o il tasto return per confermare questa immissione.
La lista dati è assolutamente necessaria se si desidera inserire nel file SRC anche dei
comandi sotto guida del menù.
1.2.2 Editare, compilare e unire un programma

Se è stato creato un file o una lista dati con “Nuovo” è possibile modificarli con l’editor. A
questo scopo serve il softkey “Apri”. Alla chiusura dell’editor viene compilato il codice
completo del programma, cioè il codice KRL testuale viene tradotto in un linguaggio
macchina comprensibile per il controllo.
Affinché il programma rimanga chiaro e comprensibile, occorre ad es. in caso di dira-

mazioni far rientrare queste su diversi livelli. Nell’editor ciò può essere effettuato tra-
mite caratteri di spaziatura.
Compilatore Il compilatore verifica la correttezza sintattica e semantica del codice. Se vengono rilevati
degli errori, viene emesso un relativo messaggio e creato un file errore con l’estensione
“.ERR”.
Soltanto programmi privi di errori possono essere selezionati ed eseguiti.
Ulteriori informazioni sulla gestione di errori di editazione sono contenute nel paragrafo
[Gestione errori].
Correlatore Al caricamento di un programma tramite il softkey “Selezionare” vengono uniti tutti i file e le
liste dati necessari in un programma. Durante il collegamento viene verificato se tutti i moduli
sono presenti, analizzati e privi di errori. Il correlatore verifica inoltre, al momento del
passaggio di parametri, la compatibilità tra i tipi dei parametri di passaggio. Se durante il
collegamento si presentano degli errori viene creato – come nel caso della compilazione –
un file errore con l’estensione “.ERR”.
13 di 214
E’ possibile anche scrivere un programma KRL tramite un normale editor di testo e

caricarlo in seguito tramite il softkey “Caricare” nella memoria di sistema. In questo caso
però è necessario verificare che tutte le inizializzazioni necessarie (ad es. velocità degli
assi) vengano effettuate.
In seguito un semplice programma di esempio per la determinazione delle velocità e delle

accelerazioni degli assi:
DEF PROG1()
;----- Sezione delle dichiarazioni -----

INT J
;------ Sezione delle istruzioni -------

$VEL_AXIS[1]=100 ;Determinazione delle velocità degli assi
$VEL_AXIS[2]=100
$VEL_AXIS[3]=100
$VEL_AXIS[4]=100
$VEL_AXIS[5]=100
$VEL_AXIS[6]=100
$ACC_AXIS[1]=100 ;Determinazione delle accelerazioni degli assi

$ACC_AXIS[2]=100
$ACC_AXIS[3]=100
$ACC_AXIS[4]=100
$ACC_AXIS[5]=100
$ACC_AXIS[6]=100
PTP {A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}
FOR J=1 TO 5
PTP {A1 4}
PTP {A2 -7,A3 5}
PTP {A1 0,A2 -9,A3 9}
ENDFOR
PTP {A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}

END
APPUNTI:
14 di 214
1.3 Modifica di programmi

In linea di massima esistono due possibilità per modificare un programma sul livello esperto
dell’interfaccia grafica:
G Correzione programma (PROKOR)
G Editor
1.3.1 Correzione programma

La correzione programma è il metodo standard. Se viene selezionato un programma o
arrestato un programma in corso si passa automaticamente nel modo PROKOR.
Qui è possibile inserire o modificare comandi in base al modulo Inline oppure al codice ASCII
(sul livello esperto) che influenzano soltanto una riga di programma, cioè nessuna struttura
di controllo (loop, ecc.) o dichiarazioni di variabili.
Se selezionate, le immissioni errate vengono cancellate immediatamente dopo l’abban-
dono della riga di programma e appare un messaggio di errore nella finestra dei mes-
saggi.
1.3.2 Editor
Se si vuole modificare o inserire determinati comandi KRL o strutture di programma ciò viene
effettuato tramite l’editor. Siccome alla chiusura dell’editor viene compilato il codice
completo, possono essere riconosciuti anche degli errori che si presentano soltanto in
combinazione con più righe (ad es. delle variabili dichiarate in modo errato).
1.3.2.1 Funzioni di blocco
Le funzioni di blocco sono disponibili soltanto nell’editor a partire dal livello utente
“Esperto”. Un programma, il cui contenuto dev’essere modificato tramite le funzioni di
blocco, dev’essere aperto col softkey “Edit”. Le modalità per passare al livello utente
“Esperto” sono descritte nel capitolo [Configurazione del sistema], paragrafo “Gruppo
d’utente”.
Posizionare dapprima il cursore di editazione lampeggiante all’inizio o alla fine della parte di
programma da spostare. Tenere poi premuto il tasto “Shift” sulla tastiera mentre il cursore
viene spostato in giù o in su. In questo modo viene selezionata una parte del programma che
dev’essere modificata nel prossimo passo di lavoro tramite le funzioni di blocco. La parte
selezionata è riconoscibile dallo sfondo colorato.
Programma Azionare il tasto di menù “Programma” e selezionare dal menù che ora si apre la funzione
desiderata.
Se per le funzioni di blocco vengono usati il blocco numerico e la tastiera, la funzione NUM
dev’essere disattivata. Premere in questo caso il tasto “Num” sulla tastiera. La relativa
indicazione nella riga di stato è allora spenta.
1.3.2.2 Copia (CTRL--C)

La parte di programma selezionata viene bufferizzata fino all’ulteriore elaborazione. Può
essere successivamente inserito in un altro punto.
15 di 214
Come alternativa è possibile tener premuto il tasto CTRL sul blocco numerico e premere
il tasto C sulla tastiera. In seguito rilasciare entrambi i tasti.
1.3.2.3 Incolla (CTRL--V)

Posizionare ora il cursore di editazione al posto dove la parte del programma “tagliata” o
“copiata” dev’essere inserita.
Selezionare ora l’opzione “Incolla”. La parte di programma selezionata precedentemente

viene reinserita al di sotto del cursore di editazione.
il tasto V sulla tastiera. In seguito rilasciare entrambi i tasti.
1.3.2.4 Taglia (CTRL--X)

Se dal menù viene selezionata l’opzione “Taglia”, la parte di programma selezionata viene
temporaneamente memorizzata e cancellata dalla lista del programma.
il tasto X sulla tastiera. In seguito rilasciare entrambi i tasti.
1.3.2.5 Cancella
L’area selezionata può essere eliminata dal programma. In questo caso non avviene
nessuna bufferizzazione. La parte di programma eliminata è con ciò persa in modo irrevoca-
bile.
16 di 214
Per questo motivo viene posta una domanda di sicurezza nella finestra dei messaggi alla
quale occorre rispondere tramite la barra softkey.
G Abbandona L’azione “Cancella” viene cancellata.

G Sì L’area selezionata viene cancellata in modo irrevocabile.
G No La funzione “Cancella” viene annullata.
Se viene selezionata l’opzione “Cancella” dal menù, la parte di programma selezionata

viene cancellata senza bufferizzazione dalla lista di programma.
1.3.2.6 Trova
Ulteriori informazioni sono contenute nel Manuale d’uso, nella documentazione [Pro-
grammazione utente], capitolo [Editazione di un programma], paragrafo [Lavorare
con l’editor di programma].
1.3.2.7 Sostituisci
La funzione “Trova e sostituisci” è disponibile soltanto sul livello esperto ed esclusivamente

nell’editor. Questa applicazione cerca una sequenza prestabilita di caratteri all’interno del
programma nella zona visibile (righe non fold o folds aperti) e consente la sostituzione con
una sequenza di caratteri definita.
Selezionare a questo scopo nel menù “Programma” l’opzione “Sostituisci”.
17 di 214
Viene aperta la seguente finestra:
La barra softkey cambia.
Inserire una sequenza di caratteri nella riga di ricerca e spostarsi tramite il tasto freccia in
basso nella riga di sostituzione. Inserire qui il termine che deve sostituire quello ricercato.
Se il termine ricercato è presente più volte nel documento e si desidera sostituirlo soltanto
in un determinato punto, azionare il softkey “Cerca” ripetutamente finché il punto desiderato
è stato trovato. Premere in seguito “Sostituire”. Il termine ricercato viene sostituito con quello
indicato.
Se si desidera sostituire il termine ricercato dappertutto oppure in un’area di programma se-
lezionata in precedenza, azionare dopo la compilazione del modulo di ricerca e di sostitu-
zione il softkey “Sost. tutto”.
18 di 214
Nella finestra dei messaggi appare il messaggio “L’area indicata/selezionata è stata esami-
nata” (conferma che la ricerca è stata effettuata nell’intero programma oppure nella sele-
zione). Dopo l’azionamento del softkey “Abbandona” si esce dalla funzione di sostituzione e
nella finestra dei messaggi viene visualizzato il numero delle sostituzioni effettuate dall’atti-
Abbandona vazione di questa funzione.
2 sostituzioni eseguite
APPUNTI:
19 di 214
1.4 Nascondere parti di programma

Diversamente dagli editor normali, l’editor KCP consente una visualizzazione dei contenuti
dei programmi specifica alle richieste. Ad esempio l’utente vede soltanto i contenuti
essenziali di un programma, mentre sul livello esperto è visibile l’intero programma.
1.4.1 FOLD
L’interfaccia grafica KUKA si serve di una particolare tecnica per la chiara rappresentazione
di un programma. Le istruzioni effettuate come commenti KRL permettono di sopprimere la
visualizzazione di successive parti del programma. In questo modo il programma viene
suddiviso in sezioni che vengono chiamate “FOLDS” conformemente al loro carattere di
cartella.
I “FOLDS” sono come standard “chiusi” e possono essere “aperti” soltanto sul livello esperto.
Essi contengono informazioni invisibili per l’utente sull’interfaccia grafica KUKA. Sul livello
esperto esiste la possibilità di rendere invisibile un blocco KRL per l’utente. A questo scopo le
relative dichiarazioni e istruzioni vengono rinchiuse tra le denominazioni “;FOLD” e
“;ENDFOLD”.
Programma I folds in un programma possono essere visualizzati o nascosti premendo il tasto menù “Pro-
gramma” e selezionando successivamente “FOLD” e il comando desiderato.
Programma nell’editor Programma selezionato
Sono disponibili le seguenti opzioni:

G FOLD attuale ap./ch. il FOLD della riga nella quale si trova il cursore di
editazione viene aperto/chiuso
G Aprire tutti i FOLDs apre tutti i FOLDs del programma
G Chiudere tutti i FOLDs chiude tutti i FOLDs del programma
Se viene resettato un programma selezionato nel quale sono aperti dei folds, questi
folds vengono automaticamente chiusi.
Dalla sequenza...
;FOLD RESET OUT
FOR I=1 TO 16
$OUT[I]=FALSE
ENDFOR
;ENDFOLD
20 di 214
...sono visibili, con i folds chiusi, sull’interfaccia grafica soltanto le parole “RESET OUT”. Con
questo comando è ad esempio possibile rendere invisibile per l’utente la sezione delle
dichiarazione e delle inizializzazioni.
1.4.1.1 Programma esemplare
DEF FOLDS()
;FOLD DECLARATION;% ulteriori informazioni

;--------- Sezione delle dichiarazioni ---------
EXT BAS (BAS_COMMAND :IN,REAL :IN )
DECL AXIS HOME
INT I
;ENDFOLD
;FOLD INITIALISATION
;---------- Inizializzazione ---------
INTERRUPT DECL 3 WHEN $STOPMESS==TRUE DO IR_STOPM ( )
INTERRUPT ON 3
BAS (#INITMOV,0 ) ;inizializzazione di velocità,
;accelerazioni, $BASE, $TOOL, etc.
FOR I=1 TO 16
$OUT[I]=FALSE
ENDFOR
HOME={AXIS: A1 0,A2 -90,A3 90,A4 0,A5 30,A6 0}
;ENDFOLD
;------------- Sezione principale ------------

PTP HOME ;Movimento SAK
LIN {X 540,Y 630,Z 1500,A 0,B 90,C 0}
PTP HOME
END
Il programma esemplare ha il seguente aspetto sull’interfaccia grafica:
Sezione principale
Lo stesso programma con i folds aperti:
21 di 214
Sezione delle dichiarazioni
Inizializzazione
inizializzazione di velocità,
accelerazioni,
Sezione principale
Nel FOLD chiuso è visibile soltanto l’espressione dopo la parola chiave “FOLD”. Nel FOLD
aperto sono invece visibili tutte le istruzioni e dichiarazioni.
“FOLD” è solamente un’istruzione per l’editor. Il compilatore interpreta le istruzioni FOLD

a causa del punto e virgola preposto come normale commento.
22 di 214
1.5 Modi di esecuzione programma

I modi di esecuzione programma determinano se l’esecuzione deve avvenire
G senza arresto di programma
G per passi o
G per frasi.
Nella seguente tabella sono descritti tutti i modi di esecuzione programma.
Modo di Descrizione
esecuzione
GO
Vengono eseguite tutte le istruzioni del programma senza
ARRESTO fino alla fine del programma.
MSTEP Motion Step (frase di movimento)

Il programma viene eseguito per passi, cioè con un ARRESTO
dopo ogni frase di movimento.
Il programma viene eseguito senza processo avanzato.
ISTEP Inkremental Step (frase singola)
Il programma viene eseguito per frasi, cioè con un ARRESTO
dopo ogni istruzione (anche riga bianca).
PSTEP
Program Step (passo di programma)
I sottoprogrammi vengono eseguiti completamente.
CSTEP Continuous Step (frase di movimento)

Il programma viene eseguito per passi, cioè con un ARRESTO
dopo ogni frase di movimento con arresto preciso.
Il programma viene eseguito con processo avanzato, cioè con l’ap-
prossimazione di punti.
I modi di esecuzione programma GO, MSTEP e ISTEP possono essere selezionati sul KCP
tramite un tasto stato o la variabile “$PRO_MODE”. PSTEP e CSTEP possono essere impo-
stati invece soltanto tramite la variabile “$PRO_MODE”. Per modificare lo stato di questa
variabile richiamare la funzione menù “Visualizza” --> “Variabile” --> “Singolo”. Inserire in se-
guito nel campo di immissione “Nome” la variabile “$PRO_MODE” e nel campo “Valore
nuovo” il valore desiderato.
23 di 214
I modi di esecuzione programma “#PSTEP” e “#CSTEP” possono essere selezionati

soltanto tramite la correzione di variabili e non per mezzo di tasti stato.
Ulteriori informazioni sono contenute nel capitolo [Variabili e dichiarazioni], paragrafo

[Oggetti di dati] sotto (Tipi di enumerazione).
APPUNTI:
24 di 214
1.6 Gestione errori

Se durante la compilazione o il collegamento si verifica un errore, nella finestra dei mes-
saggi viene emesso un messaggio di errore e il file errato viene contrassegnato nel naviga-
tore.
Come esempio serve il file “ERROR.SRC” che è stato creato (in modo errato):
Dopo la chiusura dell’editor appare nella finestra dei messaggi un messaggio di avvertimento
che riguarda il numero degli errori.
Contemporaneamente i file interessati vengono contrassegnati durante questa operazione

con una croce rossa.
E‘ disponibile la seguente barra softkey:
Il softkey “Apri” carica il file nell’editor e all’azionamento del softkey “Edit DAT” (“Lista dati”) il
file Dat viene aperto con l’editor. Per cancellare i file errati premere “Cancella”. Tramite
“Nuovo” è possibile creare un nuovo file.
25 di 214
Premendo il softkey “Edit ERR”, questa lista viene aperta.

Errore Visualizzazione
Riga di titolo col nome del file
Linea Colonna Errore No Descrizione
Breve descrizione
Numero errore
*1
Numero della riga e colonna errata
Riga del testo sorgente errata

TIPO DELLA VARIABILE DIVERSO DA INT Descrizione dell’errore =
breve descrizione
In seguito cambia la barra softkey:
NOTA *1
I numeri di riga indicati corrispondono ai numeri di riga assoluti nel programma come
li visualizzerebbe un normale editor ASCII. Per ottenere la concordanza tra i numeri
delle righe nella visualizzazione errore e i numeri delle righe sul KCP occorrerebbe
che tutti i folds siano aperti e che siano attive la visualizzazione dettagli e la riga DEF.
Questa rappresentazione è però poco chiara poiché vengono messe a disposizione
tutte le informazioni nonostante non siano necessarie. Ulteriori informazioni sulla vi-
sualizzazione dettagli e sulla riga DEF sono contenute nel paragrafo [Nascondere
parti di programma].
Dalla visualizzazione errore risulta che si sono presentati i seguenti errori:

G nel file SCR sono errate 3 righe;
G i numeri delle righe errate sono 51, 52 e 55;
G nella riga 51 i numeri di errore
-- 2263: tipo della variabile loop diverso da INT;
G nella riga 52 il numero di errore
-- 2249: stampa diversa da INT;
G nella riga 55 il messaggio di errore
-- 2309: attesa del segno “(”.
Dal messaggio di errore “2263” si può riconoscere molto velocemente che la variabile I non
è stata dichiarata come Integer. Il messaggio di errore 2249 risulta anche dalla dichiarazione
mancante, poiché in caso di un loop di conteggio il contatore dev’essere sempre del tipo INT.
Il messaggio “2309” significa: il compilatore interpreta la riga come richiamo di un sottopro-
gramma dove mancano però le parentesi.
26 di 214
Il significato dei numeri di errore può essere visualizzato online tramite la funzione menù
“Visualizza” --> “Variabile” --> “Singolo”. Indicare a questo scopo nella finestra di stato nel
campo di immissione “Nome” il segno “&” seguito dal numero di errore, in questo caso ad
esempio “&2263” ed azionare il tasto Enter.
Se il file SRC (in questo caso “ERROR.SRC”) viene caricato nell’editor, è possibile effettuare
le relative correzioni. Per comodità, il cursore si posiziona lampeggiante nella prima riga er-
rata. Occorre prestare attenzione che la visibilità limitata sia disattivata e che la riga DEF sia
visibile. Ulteriori informazioni sono contenute nel paragrafo [Nascondere parti di pro-
gramma].
Nell’esempio presente non è necessario aprire i fold, ma se si desidera ciò utilizzare il
comando menù “Edit” --> “Folds” --> “Aprire tutti i FOLDs”.
La riga “INT I” mancante nel programma creato originariamente dev’essere inserita

prima della riga “INI”. Ciò è possibile soltanto se la riga “DEF ERROR ( )” è visibile.
Inserire quindi la riga

INT I
prima della riga INI e cancellare nella riga 10 un segno d’uguaglianza.
I = I + 1
Inserire questa riga qui
Cancellare un segno
d’uguaglianza
Aggiorna Dopo la chiusura dell’editor e la memorizzazione del file corretto è possibile azionare il soft-
key “Aggiorna” e la lista errori scompare quando tutti gli errori sono rimossi.
27 di 214
1.7 Commenti
I commenti sono una parte importante di ogni programma di computer perché permettono di
rendere il programma chiaro e comprensibile anche per altri. La velocità di esecuzione del
programma non viene influenzata dai commenti.
I commenti possono essere inseriti in una posizione qualsiasi del programma. Vengono
sempre preceduti da un punto e virgola “;”, ad es.:
¼
PTP P1 ;Movimento verso il punto di partenza
¼
;--- Reset uscite ---
FOR I = 1 TO 16
$OUT[I] = FALSE
ENDFOR
¼
APPUNTI:
28 di 214
2 Variabili e dichiarazioni
2 Variabili e dichiarazioni
2.1 Variabili e nomi
Oltre all’utilizzo di costanti, cioè l’indicazione diretta del valore sotto forma di cifre, caratteri,
ecc., nel KRL possono anche essere usate delle variabili ed altre forme di dati nel
programma.
Nel caso della programmazione di robot industriali, le variabili sono ad esempio necessarie
per l’elaborazione dei valori dei sensori. Esse permettono di memorizzare il valore letto dal
sensore e di analizzarlo in diversi punti del programma. Inoltre è possibile effettuare delle
operazioni aritmetiche, ad es. per calcolare una nuova posizione.
Una variabile viene rappresentata nel programma tramite un nome la cui denominazione può
essere scelta liberamente entro certi limiti.
Nomi I nomi nel KRL

S non devono superare un max. di 24 caratteri,
S possono essere composti da lettere (A--Z), cifre (0--9) ed i caratteri ’_’ e ’$’,
S non devono iniziare con delle cifre,
S non devono essere delle parole chiave.
Siccome tutte le variabili di sistema (vedi paragrafo 2.4) iniziano col carattere ’$’ si consiglia
di non usare questo carattere come primo carattere nel nome definito da Voi.
Dei nomi KRL validi sono ad esempio

SENSORE_1
UGELLO13
P1_A_P12
Una variabile dev’essere considerata un’area di memoria fissa il cui contenuto può essere
richiamato tramite il nome della variabile. La variabile è realizzata quindi rispetto al tempo
di esecuzione del programma tramite una posizione di memoria (luogo) e un contenuto di
memoria (valore).
Assegnazione Tramite il segno d’uguaglianza (=) vengono assegnati dei valori alle variabili. L’istruzione
valore
QUANTITA’ = 5
significa dunque che nell’area di memoria con l’indirizzo QUANTITA’ viene registrato il valore
5. I dettagli dell’indirizzo non sono interessanti per il programmatore poiché viene assegnato
autonomamente dal compilatore. E’ solo importante che il contenuto della memoria possa
essere richiamato in ogni momento nel programma per mezzo del suo nome.
Poiché diversi oggetti di dati (vedi paragrafo 2.2) richiedono anche un diverso fabbisogno
di memoria, il tipo di dati di una variabile dev’essere dichiarato prima dell’utilizzo (vedi para-
grafo 2.2.1).
29 di 214
Durata Con durata di una variabile si intende il tempo durante il quale alla variabile è assegnata una
posizione di memoria. Essa dipende dal fatto se la variabile è dichiarata in un file SRC o in
una lista dati:
G Variabile dichiarata in un file SRC
La durata si limita al tempo di esecuzione del programma. Dopo il termine dell’esecuzione
l’area di memoria viene disallocata e il valore della variabile viene perso.
G Variabile dichiarata in una lista dati (vedi capitolo “Liste dati”)
La durata non dipende dal tempo di esecuzione del programma. La variabile esiste finché
esiste la lista dati. Tali variabili sono quindi permanenti (fino alla prossima
attivazione/disattivazione).
APPUNTI:
30 di 214
2 Variabili e dichiarazioni (segue)
2.2 Oggetti di dati

Con oggetti di dati si intendono delle unità di memoria denominabili di un determinato tipo
di dati. Le unità di memoria possono consistere in un numero variabile di celle di memoria
(bytes, parole, ecc.). Se un tale oggetto di dati viene dichiarato dal programmatore con un
nome si ottiene una variabile. La variabile occupa ora una o più celle di memoria nelle quali
possono essere scritti e letti dei dati tramite il programma. Grazie alla denominazione
simbolica delle celle di memoria con nomi che possono essere scelti liberamente, la
programmazione diventa più semplice e chiara e il programma più facilmente leggibile.
Per quanto riguarda il chiarimento del termine tipo di dati riportiamo il seguente esempio: in
una cella di memoria con 8 bit si trova la combinazione bit
00110101
Come dev’essere interpretata questa combinazione bit? Si tratta della rappresentazione
binaria della cifra 53 oppure del carattere ASCII “5” che hanno lo stesso schema di bit?
Per poter rispondere in modo inequivocabile a questa domanda manca un’informazione
Tipo di dati importante: l’indicazione del tipo di dati di un oggetto di dati. Nel caso suddetto ciò potrebbe
essere ad esempio il tipo “numero intero” (INTEGER) o “carattere” (CHARACTER).
Oltre a questo motivo tecnico per l’introduzione del tipo di dati, l’utilizzo di essi è anche
vantaggioso per l’utente, perché permette di lavorare proprio con il tipo che è particolarmente
adatto per la specifica applicazione.
2.2.1 Dichiarazione ed inizializzazione di oggetti di dati

DECL L’assegnazione di un nome di una variabile ad un tipo di dati e la prenotazione della posizione
di memoria avviene nel KRL per mezzo della dichiarazione DECL. Con
DECL INT QUANTITA’,NUMERO
vengono ad es. dichiarate due variabili QUANTITA’ e NUMERO del tipo di dati “numero intero”
(Integer).
Con ciò il compilatore conosce queste due variabili come anche il relativo tipo di dati e può
verificare nel caso di utilizzo delle variabili se questo tipo di dati permette l’operazione
prevista.
La dichiarazione inizia, come mostrato nell’esempio, con la parola chiave DECL, seguita dal
tipo di dati e dalla lista di variabili che dovranno avere questo tipo di dati.
Nel caso della dichiarazione di variabili e campi di un tipo di dati predefinito, la parola chiave
DECL può essere omessa. Oltre ai semplici tipi di dati INT, REAL, CHAR e BOOL (vedi
paragrafo 2.2.2) sono predefiniti tra l’altro i tipi di dati di struttura POS, E6POS, FRAME, AXIS
e E6AXIS (vedi paragrafo 2.2.5).
Per variabili (non campi!) del tipo di dati POS, la dichiarazione può essere omessa
completamente. Il tipo di dati POS è un tipo di dati standard per variabili.
Non è possibile rinunciare alla parola chiave DECL nel caso della dichiarazione di tipi di
struttura o di enumerazione liberamente definibili (vedi paragrafo 2.2.5 e 2.2.6).
Inizializzazione Dopo la dichiarazione di una variabile, il suo valore è per il momento impostato su invalido,
altrimenti dipenderebbe dall’occupazione di memoria casuale. Per poter lavorare con la
variabile, ad essa dev’essere assegnato in anticipo un determinato valore. Questa prima
assegnazione di un valore ad una variabile viene chiamata inizializzazione.
Nel momento della creazione di file nuovi tramite il softkey “Nuovo” sull’interfaccia grafica
KUKA viene anche generata automaticamente una sequenza INI. La dichiarazione di va-
riabili dev’essere effettuata sempre prima di questa sequenza.
Un’assegnazione di un valore ad una variabile è un’istruzione e quindi per principio non si
deve trovare nella sezione delle dichiarazioni. Ma l’inizializzazione può avvenire in qualsiasi
posizione nella sezione delle istruzioni. E’ opportuno però inizializzare tutte le variabili
dichiarate in una sezione di inizializzazione direttamente dopo la sezione delle dichiarazioni
(vedi Fig. 1).
31 di 214
Soltanto nelle liste dati è ammesso inizializzare delle variabili direttamente nella riga di
dichiarazione.
DEF NAME()
;---- Sezione delle dichiarazioni ----

¼
;---- Sezione di inizializzazione ----

¼
;---- Sezione delle istruzioni ----

¼
END
Fig. 1 Struttura base di un programma robot
Ulteriori informazioni sono contenute nel capitolo [Liste dati].
32 di 214
2.2.2 Tipi di dati semplici

Con tipi di dati semplici si intendono alcuni tipi di dati base che esistono nella maggior parte
dei linguaggi di programmazione. I tipi di dati semplici contengono a differenza dei tipi di dati
strutturati (vedi paragrafo 2.2.3--2.2.6) soltanto un unico valore. I tipi di dati conosciuti nel
KRL sono elencati con la loro relativa gamma di valori in Tab. 1.
Tipo di dati Integer Real Boolean Character

Parola chiave INT REAL BOOL CHAR
Significato numero intero numero con stato logico 1 carattere
virgola mobile
Gamma di -231¼231-1 +1.1E-38¼ TRUE, FALSE caratteri ASCII
valori ±3.4E+38
Tab. 1 Tipi di dati semplici
INT Il tipo di dati Integer è un sottoinsieme dell’insieme dei numeri interi. Può essere soltanto un
sottoinsieme poiché nessun calcolatore è in grado di rappresentare l’insieme teoricamente
infinito dei numeri interi. I 32 bit previsti nel KR C... per i tipi Integer producono 231 numeri
interi più segno. Il numero 0 viene considerato appartenente ai numeri positivi.
Con
NUMERO = -23456
alla variabile NUMERO viene assegnato il valore -23456.
Se ad una variabile INTEGER viene assegnato un valore REAL, il valore viene arrotondato
secondo le regole generali (da x.0 fino a x.49 in giù, da x.5 fino a x.99 in su). Tramite l’istru-
zione
NUMERO = 45.78
la variabile INTEGER NUMERO ottiene il valore 46.
Eccezione: In caso di divisione Integer, il numero dopo la virgola viene tagliato, ad es.:
7/4 = 1
Mentre l’uomo calcola e pensa nel sistema decimale, un computer conosce solo lo zero e
l’uno che rappresentano i due stati Off e On. Uno stato (Off o On) viene quindi indicato con
un bit. Per motivi di velocità il calcolatore accede generalmente ad un intero pacchetto di tali
zeri e uni. Grandezze tipiche di pacchetti sono 8 bit (=1 Byte), 16 bit o 32 bit. Per operazioni
Sistema binario orientate alla macchina è quindi spesso opportuna la rappresentazione nel sistema binario
Sistema (cifre 0 e 1) o nel sistema esadecimale (cifre 0--9 e A--F). I valori interi binari o esadecimali
esadecimale possono essere indicati nel KRL con l’aiuto dell’apice (’) e dell’indicazione di B per rappresen-
tazione binaria eppure H per rappresentazione esadecimale.
D 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
H 0 1 2 3 4 5 6 7 8 9 A B C D E F 10
Tab. 2 I primi 17 numeri nel sistema decimale ed esadecimale
33 di 214
Il numero 90 può essere assegnato nel KRL in tre diversi modi ad una variabile Integer:
NUMEROINT = 90 ;Sistema decimale
NUMEROINT = ’B1011010’ ;Sistema binario
NUMEROINT = ’H5A’ ;Sistema esadecimale
Bin ® Dec La conversione di numeri binari nel sistema decimale avviene nel modo seguente:
1 0 1 1 0 1 0
= 1S26+0S25+1S24+1S23+0S22+1S21+0S20= 90
26 25 24 23 22 21 20
Esa ® Dec Per trasferire dei numeri dal sistema esadecimale nel sistema decimale si procede come
segue:
5 A
=5S161+10S160=90
161 160
REAL Col termine della rappresentazione a virgola mobile si intende la suddivisione di un numero
in mantissa ed esponente e la loro rappresentazione in forma normalizzata. Viene ad es.
rappresentato
5.3 come 0.53000000 E+01
-100 come -0.10000000 E+03
0.0513 come 0.51300000 E-01
Calcolando con valori Real occorre tener conto, a causa del limitato numero di posizioni a
virgola mobile e dell’imprecisione che ne deriva, che le abituali leggi dell’algebra non sono
più valide in tutti i casi. Nell’algebra vale ad esempio:
1⋅3 = 1
3
Se si fa calcolare ciò successivamente da un computer può darsi che il risultato sia soltanto
0.99999999 E+00. Da un paragone logico di questo numero con la cifra 1 risulterebbe il
valore FALSE. Per le applicazioni pratiche nell’ambito dei robot questa precisione è però
generalmente sufficiente considerando che il test logico dell’uguaglianza nel caso di
grandezze Real può essere effettuato con senso soltanto all’interno di un piccolo range di
tolleranza.
Delle assegnazioni ammesse a variabili Real sono ad es.:
NUMEROREAL1 = -13.653
NUMEROREAL2 = 10
NUMEROREAL3 = 34.56 E-12
Se ad una variabile REAL viene assegnato un valore INTEGER, viene effettuata automati-
camente una conversione del tipo in REAL. La variabile NUMEROREAL2 ha quindi secondo
l’assegnazione sopra indicata il valore 10.0!
BOOL Le variabili di Boole servono per la descrizione di stati logici (ad es. ingressi/uscite). Possono
assumere soltanto i valori TRUE (vero) e FALSE (falso):
STATO1 = TRUE
STATO2 = FALSE
34 di 214
CHAR Le variabili Character possono rappresentare esattamente 1 carattere ASCII. In caso di

assegnazione di un carattere ASCII ad una variabile CHAR, il carattere assegnato deve
trovarsi tra virgolette (”):
CARATTERE1 = “G”
CARATTERE2 = “?”
Per quanto riguarda la memorizzazione di intere sequenze di caratteri vedi paragrafo 2.2.4.
2.2.3 Campi
Con campi si intende il raggruppamento di oggetti dello stesso tipo di dati in un oggetto di
dati con la possibilità di richiamare i singoli componenti di un campo per mezzo di indici.
Tramite la dichiarazione
DECL INT OTTO[7]
Indice di campo è possibile ad es. depositare 7 diversi numeri Integer nel campo OTTO[]. L’accesso ad ogni
singola componente del campo è possibile tramite l’indicazione dell’indice corrispondente (il
prima indice è sempre l’1):
OTTO[1] = 5 ; al 1. elemento viene assegnato il numero 5
Ci si può immaginare il campo col nome OTTO[] come scaffale con 7 ripiani. L’occupazione
dei ripiani sarebbe, secondo le assegnazioni precedenti, la seguente:
5 10 15 20 25 30 35
OTTO [1] [2] [3] [4] [5] [6] [7]
Fig. 2 Rappresentazione di un campo unidimensionale
Se tutti gli elementi di un campo devono essere inizializzati con lo stesso numero, ad es. 0,
non è necessario programmare ogni assegnazione esplicitamente, ma è possibile “automa-
tizzare” la riservazione per mezzo di un loop e di una variabile di conteggio:
FOR I = 1 TO 7
OTTO[I] = 0
ENDFOR
Ulteriori informazioni sono contenute nel capitolo [Controllo dell’esecuzione del

programma] paragrafo [Loop].
La variabile di conteggio è in questo caso la variabile Integer I. Essa dev’essere dichiarata

prima dell’utilizzo come Integer.
35 di 214
S Il tipo di dati di un campo è uno qualsiasi. Quindi i singoli elementi possono

a loro volta consistere di tipi di dati composti
(ad es.: un campo di campi)
S Per gli indici è ammesso soltanto il tipo di dati Integer
S Oltre a costanti e variabili sono anche ammesse delle espressioni aritmetiche
per l’indice (vedi paragrafo 2.3.1)
S L’indice conta sempre da 1
Bidimens. Oltre ai campi unidimensionali illustrati finora, cioè campi con soltanto un indice, nel KRL è
possibile anche utilizzare dei campi bidimensionali o tridimensionali. Con
DECL REAL MATRICE[5,4]
viene dichiarato un campo 5×4 bidimensionale con 5×4=20 elementi REAL. Ci si può
immaginare questo campo come matrice con 5 colonne e 4 file. Con la sequenza di
programma
I[3] = 0
FOR COLONNA = 1 TO 5
FOR FILA = 1 TO 4
I[3] = I[3] + 1
MATRICE[COLONNA,FILA] = I[3]
ENDFOR
ENDFOR
agli elementi della matrice viene attribuito un valore conformemente all’ordine della loro
assegnazione. Si ottiene quindi la seguente allocazione della matrice:
Piano 1
Fila 1
Fila 2
1
Fila 3 5
2 9
6 13
Fila 4 10 17
3
7 14
4 11 18
8 15
12 19
Colonna 1
16
Colonna 2
20
Colonna 3
Colonna 4
Colonna 5
Fig. 3 Rappresentazione di un campo bidimensionale
36 di 214
Tridimens. Ci si può infine immaginare i campi tridimensionali come diversi matrici bidimensionali poste
una dietro all’altra. La terza dimensione indica per così dire il piano nel quale si trova la
matrice (vedi Fig. 4). La dichiarazione di un campo tridimensionale avviene in modo analogo
a quella dei campi unidimensionali o bidimensionali, ad es.:
DECL BOOL CAMPO_3D[3,5,4]
La sequenza di inizializzazione potrebbe essere la seguente:
FOR PIANO = 1 TO 3
FOR COLONNA = 1 TO 5
FOR FILA = 1 TO 4
CAMPO_3D[PIANO,COLONNA,FILA] = FALSE
ENDFOR
ENDFOR
ENDFOR
Piano 3
Piano 2
41
Piano 1 45
42 49
21 46 53
Fila 1 25 50 57
22 29 54
Fila 2 26 33 58
1
5 30 37 55
Fila 3 34 59
2 9
6 13 38 56
Fila 4 10 17 35 60
3
7 14 39
4 11 18 36
8 15 40
12 19
Colonna 1
16
Colonna 2
20
Colonna 3
Colonna 4
Colonna 5
Fig. 4 Rappresentazione di un campo tridimensionale
37 di 214
2.2.4 Catene di caratteri

Col tipo di dati CHAR si possono memorizzare, come nominato prima, soltanto dei singoli
caratteri. Per l’utilizzo di intere catene di caratteri, come ad es. parole, viene definito sempli-
cemente un campo unidimensionale del tipo CHAR:
DECL CHAR NAME[8]
E’ possibile ora come prima richiamare ogni singolo elemento del campo NAME[], ad es.:
NAME[3] = “G”
E’ però anche possibile inserire intere catene di caratteri:

NAME[] = “ABCDEFG”
occupa i primi sette elementi del campo NAME[] con le lettere A, B, C, D, E, F e G:
A B C D E F G
2.2.5 Strutture
Se devono essere raggruppati diversi tipi di dati, allora il campo è inappropriato e bisogna
STRUC ricorrere alla forma più generale del collegamento. Con la proposizione dichiarativa STRUC
è possibile raggruppare diversi tipi di dati, che sono stati definiti precedentemente o che sono
dei tipi di dati predefiniti, in un nuovo tipo dati di collegamento. In particolare anche altri colle-
gamenti e campi possono far parte di un collegamento.
Un esempio tipico per l’utilizzo di collegamenti è il tipo di dati standard POS. E’ composto da
6 valori REAL e 2 valori INT ed è stato definito nel file $OPERATE.SRC nel modo seguente:
STRUC POS REAL X, Y, Z, A, B, C, INT S, T
Punto Se viene utilizzata ad es. una variabile POSIZIONE del tipo di dati di struttura POS, allora
separatore è possibile occupare gli elementi o singolarmente tramite il punto separatore, ad es.:
POSIZIONE.X = 34.4
POSIZIONE.Y = -23.2
POSIZIONE.Z = 100.0
POSIZIONE.A = 90
POSIZIONE.B = 29.5
POSIZIONE.C = 3.5
POSIZIONE.S = 2
POSIZIONE.T = 6
Aggregato oppure insieme per mezzo del cosiddetto aggregato
POSIZIONE={X 34.4,Y -23.2,Z 100.0,A 90,B 29.5,C 3.5,S 2,T 6}
Ulteriori informazioni sono contenute nel capitolo [Variabili e dichiarazioni] paragrafo

[Dichiarazione ed inizializzazione di oggetti di dati].
Per gli aggregati valgono le seguenti disposizioni:
38 di 214
S I valori di un aggregato possono essere delle semplici costanti oppure degli

aggregati stessi.
S Non è necessario indicare in un aggregato tutti i componenti della struttura.
S Non è necessario indicare i componenti nell’ordine nel quale sono state definiti.
S Ogni componente dev’essere contenuto soltanto una volta in un aggregato.
S In caso di campi composti da strutture, un aggregato descrive il valore di un
singolo elemento del campo.
S All’inizio di un aggregato può essere indicato il nome del tipo di struttura,
separato da un doppio punto.
Per variabili POS sono quindi ammesse ad esempio anche le seguenti assegnazioni:
POSIZIONE={B 100.0,X 29.5,T 6}

POSIZIONE={A 54.6,B -125.64,C 245.6}
POSIZIONE={POS: X 230,Y 0.0,Z 342.5}
In caso di strutture POS, E6POS, AXIS, E6AXIS e FRAME i componenti mancanti

non vengono modificati. Per tutti gli altri aggregati, i componenti non presenti
vengono settati su invalido.
Le modalità per la creazione di proprie variabili di struttura vengono illustrate in base

all’esempio seguente:
In un sottoprogramma per la saldatura ad arco dev’essere trasmessa in una variabile

S_PARA la seguente informazione:
REAL V_FILO Velocità filo

INT CURVA Curva caratteristica 0...100%
BOOL ARCO con/senza arco (per simulazione)
La variabile S_PARA dev’essere composta da 3 elementi di diverso tipo di dati. Prima di tutto
dev’essere definito un nuovo tipo di dati che soddisfa queste richieste:
STRUC TIPOSALDATURA REAL V_FILO, INT CURVA, BOOL ARCO

Con ciò è stato creato un nuovo tipo di dati con la denominazione TIPOSALDATURA
(TIPOSALDATURA non è una variabile!). TIPOSALDATURA è composto dai 3 componenti
V_FILO,CURVA ed ARCO. Ora è possibile dichiarare una qualsiasi variabile del nuovo tipo
di dati, ad es.:
DECL TIPOSALDATURA S_PARA
Con ciò è stata creata una variabile S_PARA del tipo di dati TIPOSALDATURA. I singoli
elementi possono essere richiamati, come già illustrato, per mezzo del punto separatore o
dell’aggregato:
S_PARA.V_FILO = 10.2
S_PARA.CURVA = 66
S_PARA.ARCO = TRUE
oppure
S_PARA = {V_FILO 10.2,CURVA 50, ARCO TRUE}
Per poter distinguere meglio i tipi di dati autodefiniti dalle variabili, i nomi dei nuovi tipi di
dati dovrebbero terminare o iniziare con ...TIPO.
39 di 214
Strutture Nel file $OPERATE.SRC sono predefinite le seguenti strutture:

predefinite
STRUC AXIS REAL A1,A2,A3,A4,A5,A6
STRUC E6AXIS REAL A1,A2,A3,A4,A5,A6,E1,E2,E3,E4,E5,E6
STRUC FRAME REAL X,Y,Z,A,B,C
STRUC POS REAL X,Y,Z,A,B,C, INT S,T
STRUC E6POS REAL X,Y,Z,A,B,C,E1,E2,E3,E4,E5,E6, INT S,T
I componenti A1¼A6 della struttura AXIS sono dei valori angolari (assi rotatori) oppure dei
valori di traslazione (assi traslatori) per lo spostamento specifico per asse degli assi robot
1¼6.
Con i componenti addizionali E1¼E6 nella struttura E6AXIS possono essere pilotati degli
assi addizionali.
Nella struttura FRAME è possibile stabilire 3 valori di posizione nello spazio (X, Y e Z) come
anche 3 orientamenti nello spazio (A, B e C). Un punto nello spazio è quindi definito in modo
univoco per quanto riguarda la posizione e l’orientamento.
Siccome esistono dei robot che possono raggiungere il medesimo punto nello spazio con
diverse posizioni assiali, le variabili Integer S e T nella struttura POS servono per stabilire una
posizione assiale univoca.
Ulteriori informazioni sono contenute nel capitolo [Programmazione del movimento]

paragrafo [Comandi di movimento] Status (S) e Turn (T).
Con i componenti E1...E6 nella struttura E6POS possono essere pilotati degli assi addizionali.
Tipi di dati I tipi AXIS, E6AXIS, POS, E6POS e FRAME vengono chiamati anche tipi di dati geometrici
geometrici poiché il programmatore può descrivere con essi in modo semplice delle relazioni
geometriche.

paragrafo [Utilizzo di diversi sistemi di coordinate].
2.2.6 Tipi di enumerazione

Un tipo di dati di enumerazione è un tipo di dati composto da un numero limitato di costanti.
Le costanti sono dei nomi che possono essere definiti liberamente e possono essere stabilite
dall’utente. Una variabile di questo tipo di dati (variabile di enumerazione) può assumere
soltanto il valore di una di queste costanti.
Come esempio prendiamo la variabile di sistema $MODE_OP. In essa viene memorizzato
quale modo operativo è selezionato in questo momento. Sono disponibili i modi operativi T1,
T2, AUT ed EX.
Ora si potrebbe dichiarare $MODE_OP come variabile Integer, assegnare ad ogni modo
operativo una cifra e memorizzare questa poi in $MODE_OP. Ciò sarebbe però per niente
chiaro.
ENUM Una soluzione molto più elegante è offerta dal tipo di enumerazione. Nel file
$OPERATE.SRC è stato generato a questo scopo un tipo dati di enumerazione col nome
MODE_OP:
ENUM MODE_OP T1, T2, AUT, EX, INVALID
Il comando per la dichiarazione di tipi di enumerazione è quindi ENUM. Le variabili del tipo di
enumerazione MODE_OP possono assumere soltanto i valori T1, T2, AUT, EX o INVALID.
La dichiarazione delle variabili avviene con la parola chiave DECL:
DECL MODE_OP $MODE_OP
Alla variabile di enumerazione $MODE_OP può ora essere attribuita tramite normale
assegnazione uno dei quattro valori del tipo di dati MODE_OP. Per la differenziazione dalle
40 di 214
costanti semplici viene preposto ai costanti di enumerazione autodefinite in caso di

# -- carattere inizializzazioni o richiami un carattere “#”, ad es.:
$MODE_OP = #T1
Con ENUM è ora possibile generare un qualsiasi numero di tipi dati di enumerazione auto-
definiti.
APPUNTI:
41 di 214
2.3 Manipolazione dei dati

Per la manipolazione dei diversi oggetti di dati esiste una pluralità di operatori e funzioni
tramite i quali è possibile costruire delle formule. La potenzialità di un linguaggio di program-
mazione robot dipende allo stesso modo dagli oggetti di dati ammessi e dalle loro possibilità
di manipolazione.
2.3.1 Operatori
Con operatori si intendono gli usuali operatori matematici al contrario di funzioni come ad
Operando esempio SIN(30) che fornisce il seno dell’ angolo 30_. Nell’operazione 5+7 si chiamano
quindi 5 e 7 operandi e + operatore.
Ad ogni operazione il compilatore verifica l’ammissibilità degli operandi. Così ad esempio 7
-- 3 è un’operazione ammessa trattandosi della sottrazione di due numeri Integer, 5 + “A” è
un’operazione invalida trattandosi dell’addizione di un valore Integer con un carattere.
In caso di alcune operazioni come 5 + 7.1, cioè l’addizione di valori Integer con valori Real,
viene effettuato un adattamento del tipo e trasformato il valore Integer 5 nel valore Real 5.0.
Questo argomento sarà trattato più in dettaglio quando si parlerà dei singoli operatori.
2.3.1.1 Operatori aritmetici

Gli operatori aritmetici riguardano i tipi di dati INTEGER e REAL. Tutte le 4 operazioni fonda-
mentali sono ammesse nel KRL (vedi Tab. 3).
Operatore Descrizione
+ Addizione o segno positivo
-- Sottrazione o segno negativo
* Moltiplicazione
/ Divisione
Tab. 3 Operatori aritmetici
Il risultato di un’operazione aritmetica è soltanto INT se tutti i due operandi sono del tipo
INTEGER. Se il risultato di una divisione Integer non è intero, allora i numeri dopo la virgola
vengono eliminati. Se almeno uno dei due operandi è REAL anche il risultato è del tipo REAL
(vedi Tab. 4).
Operandi INT REAL

INT INT REAL
REAL REAL REAL
Tab. 4 Risultato di un’operazione aritmetica
42 di 214
Riportiamo il seguente esempio di programma:
DEF ARITH()

INT A,B,C
REAL K,L,M

;prima dell’inizializzazione tutte le variabili sono invalide!
A = 2 ;A=2
B = 9.8 ;B=10
C = 7/4 ;C=1
K = 3.5 ;K=3.5
L = 0.1 E01 ;L=1.0
M = 3 ;M=3.0

A = A * C ;A=2
B = B - ’HB’ ;B=-1
C = C + K ;C=5
K = K * 10 ;K=35.0
L = 10 / 4 ;L=2.0
L = 10 / 4.0 ;L=2.5
L = 10 / 4. ;L=2.5
L = 10./ 4 ;L=2.5
C = 10./ 4. ;C=3
M = (10/3) * M ;M=9.0
END
2.3.1.2 Operatore geometrico

L’operatore geometrico viene rappresentato nel KRL da un doppio punto “:”. Effettua una
connessione di frame tra i tipi di dati FRAME e POS.
La connessione di due frame è l’usuale trasformazione di sistemi di coordinate. Per questo
motivo la connessione di una struttura FRAME con una struttura POS influisce soltanto sul
frame all’interno della struttura POS. I componenti S e T non vengono influenzati dalla trasfor-
mazione e quindi ad essi non è necessario assegnare un valore. Ai valori X, Y, Z, A, B e C
dev’essere però sempre assegnato un valore sia in caso di operandi POS che di operandi
FRAME.
Connessione Una connessione di frame viene analizzata da sinistra verso destra. Il risultato è sempre del
di frame tipo di dati dell’operando più a destra di tutti (vedi Tab. 5).
Operando Operatore Operando destra Risultato

sinistro (sistema di coor-
(sistema di dinate di destina-
coordinate di zione)
riferimento)
POS : POS POS
POS : FRAME FRAME
FRAME : POS POS
FRAME : FRAME FRAME
Tab. 5 Combinazioni di tipi di dati in caso dell’operatore geometrico
43 di 214
Se l’operando sinistro è del tipo di dati POS, allora avviene un adattamento del tipo. La
posizione indicata tramite la struttura POS viene trasformata in un frame. Ciò significa
che il sistema rileva il frame dell’utensile per questa posizione.
In seguito viene illustrato il modo di azione dell’operatore geometrico con un semplice
esempio (vedi Fig. 5):
In una stanza si trova un tavolo. Il sistema di coordinate dello SPAZIO è definito come un
sistema di coordinate fisso nell’angolo anteriore sinistro della stanza.
Il tavolo si trova parallelamente alle pareti della stanza. L’angolo anteriore sinistro del tavolo
dista esattamente 600 mm dalla parete anteriore e 450 mm dalla parete sinistra della stanza.
L’altezza del tavolo è di 800 mm.
Sul tavolo si trova un pezzo in lavorazione di forma parallelepipeda. Il sistema di coordinate
del PEZZO viene posto come mostrato in Fig. 5 in un angolo del pezzo. Per poter manipolare
il pezzo in un secondo tempo in modo opportuno, l’asse Z del sistema di coordinate del
PEZZO è rivolto verso basso. Il pezzo è ruotato di 40˚ rispetto all’asse Z del sistema di
coordinate del TAVOLO. La posizione del sistema di coordinate del PEZZO rispetto al
sistema di coordinate del TAVOLO è di X=80 mm, Y = 110 mm e Z = 55 mm.
Base=Tavolo:Pezzo
ZR
XB
YR YB
ZB
Base
Pezzo
ZT YT
XT
Tavolo
XR
Fig. 5 Modo d’azione dell’operatore geometrico
Il compito ora è di descrivere il sistema di coordinate del PEZZO rispetto al sistema di coordi-
nate dello SPAZIO. A questo scopo occorre dichiarare prima le seguenti variabili di tipo
frame:
FRAME TAVOLO, PEZZO, BASE
Il sistema di coordinate dello SPAZIO è già definito in modo specifico del sistema. I sistemi
di coordinate TAVOLO e PEZZO vengono ora inizializzati conformemente alle condizioni
marginali:
TAVOLO = {X 450,Y 600,Z 800,A 0,B 0,C 0}
PEZZO = {X 80,Y 110,Z 55,A -40,B 180,C 0}
44 di 214
Il sistema di coordinate del PEZZO rispetto al sistema di coordinate dello SPAZIO risulta
essere ora per mezzo dell’operatore geometrico
BASE = TAVOLO:PEZZO
Nel nostro caso BASE è occupato come segue:
BASE = {X 530,Y 710,Z 855,A 140,B 0,C -180}
Un’altra possibilità sarebbe:
BASE = {X 530,Y 710,Z 855,A -40,B 180,C 0}
Soltanto in questo specifico caso i componenti di BASE risultano dall’addizione

dei componenti di TAVOLO e PEZZO. Il motivo è che il sistema di coordinate del
TAVOLO non è ruotato rispetto al sistema di coordinate dello SPAZIO.
Generalmente però non è possibile una semplice addizione dei componenti!
Una connessione di frame non è commutativa, cioè scambiando il frame di
riferimento e il frame di destinazione normalmente varierà anche il risultato!

paragrafo [Utilizzo di diversi sistemi di coordinate].
Un ulteriore esempio per quanto riguarda l’applicazione dell’operatore geometrico: si tratta

di raggiungere diversi sistemi di coordinate e connessioni di sistemi di coordinate. Per
l’illustrazione dei cambiamenti di orientamento, la punta dell’utensile si sposta in ogni
sistema di coordinate dapprima un po’ in direzione X, poi un po’ in direzione Y e finalmente
un po’ in direzione Z.
45 di 214
DEF GEOM_OP ( );
--------- Sezione delle dichiarazioni ---------

DECL AXIS HOME ;Variabile HOME del tipo AXIS
DECL FRAME MYBASE[2] ;Campo del tipo FRAME;
---------- Inizializzazione ---------

HOME={AXIS: A1 0,A2 -90,A3 90,A4 0,A5 30,A6 0}; settare sistema
di coordinate base
$BASE={X 1000,Y 0,Z 1000,A 0,B 0,C 0}REF_POS_X={X 100,Y 0,Z 0,A
0,B 0,C 0} ;Pos. di riferimento
REF_POS_Y={X 100,Y 100,Z 0,A 0,B 0,C 0}
REF_POS_Z={X 100,Y 100,Z 100,A 0,B 0,C 0}; definire propri
sistemi di coordinate
MYBASE[1]={X 200,Y 100,Z 0,A 0,B 0,C 180}
MYBASE[2]={X 0,Y 200,Z 250,A 0,B 90,C 0};
------------- Sezione principale ------------

PTP HOME ; Movimento SAK; Movimento rispetto al sistema di
coordinate $BASE
PTP $NULLFRAME ;Movimento diretto sull’origine del
sistema di coordinate $BASE
WAIT SEC 2 ;attendere 2 secondi
PTP REF_POS_X ;movimento di 100mm in direzione x
PTP REF_POS_Y ;movimento di 100mm in direzione y
PTP REF_POS_Z ,movimento di 100mm in direzione z;
movimento rispetto al sistema di coordinate $BASE spostato di
MYBASE[1]
PTP MYBASE[1]
WAIT SEC 2
PTP MYBASE[1]:REF_POS_X
PTP MYBASE[1]:REF_POS_Y
PTP MYBASE[1]:REF_POS_Z; movimento rispetto al sistema di
coordinate $BASE spostato di MYBASE[2]
PTP MYBASE[2]
WAIT SEC 2
PTP MYBASE[2]:REF_POS_X
PTP MYBASE[2]:REF_POS_Y
PTP MYBASE[2]:REF_POS_Z; movimento rispetto al sistema di coor-
dinate $BASE spostato di MYBASE[1]:MYBASE[2]
WAIT SEC 2
PTP MYBASE[1]:MYBASE[2]:REF_POS_X
PTP MYBASE[1]:MYBASE[2]:REF_POS_Y
PTP MYBASE[1]:MYBASE[2]:REF_POS_Z; movimento rispetto al
sistema di coordinate $BASE spostato di MYBASE[2]:MYBASE[1]
PTP MYBASE[2]:MYBASE[1]
WAIT SEC 2
PTP MYBASE[2]:MYBASE[1]:REF_POS_X
PTP MYBASE[2]:MYBASE[1]:REF_POS_Y
PTP MYBASE[2]:MYBASE[1]:REF_POS_Z
PTP HOME
END
46 di 214
2.3.1.3 Operatori di confronto

Con gli operatori di confronto riportati in Tab. 6 possono essere create delle espressioni
logiche. Il risultato di un confronto è quindi sempre del tipo di dati BOOL, poiché un confronto
può essere soltanto vero (TRUE) o falso (FALSE).
Operatore Descrizione Tipi di dati ammessi

== uguale INT, REAL, CHAR, ENUM, BOOL
<> diverso da INT, REAL, CHAR, ENUM, BOOL
> maggiore INT, REAL, CHAR, ENUM
< minore INT, REAL, CHAR, ENUM
>= maggiore o uguale INT, REAL, CHAR, ENUM
<= minore o uguale INT, REAL, CHAR, ENUM
Tab. 6 Operatori di confronto
I confronti possono essere usati in istruzioni di esecuzione programma (vedi capitolo 5), il
risultato di un confronto può essere assegnato ad una variabile di Boole.
Il test riguardo all’uguaglianza o ineguaglianza ha in caso di valori Real solo limita-

tamente senso, poiché a causa di errori di arrotondamento durante il calcolo dei
valori da confrontare, delle formule algebriche identiche possono fornire dei valori
diversi (vedi 2.2.2).
S Sono possibili delle combinazioni di operandi da INT, REAL, e CHAR.

S Un tipo ENUM dev’essere confrontato soltanto con lo stesso tipo ENUM.
S Un tipo BOOL dev’essere confrontato soltanto con un tipo BOOL.
Il confronto di valori numerici (INT, REAL) e caratteri (CHAR) è possibile perché ad ogni
carattere ASCII è assegnato un codice ASCII. Questo codice è un numero che determina
l’ordine dei caratteri nella sequenza dei caratteri.
Le singole costanti di un tipo di enumerazione vengono numerate al momento della loro
dichiarazione nell’ordine della loro apparizione. Gli operatori di confronto si riferiscono a
questi numeri.
Oltre ai confronti semplici sono ammessi anche i confronti multipli. In seguito alcuni esempi
al riguardo:
¼
BOOL A,B
¼
B = 10 < 3 ;B=FALSE
A = 10/3 == 3 ;A=TRUE
B = ((B == A) <> (10.00001 >= 10)) == TRUE ;B=TRUE
A = “F” < “Z” ;A=TRUE
¼
47 di 214
2.3.1.4 Operatori logici

Questi servono per la connessione logica di variabili di Boole, di costanti e di semplici espres-
sioni logiche che vengono create per mezzo degli operatori di confronto. L’espressione
(A > 5) AND (A < 12)
ha ad esempio soltanto il valore TRUE se A si trova nell’ambito tra 5 e 12. Tali espressioni
vengono utilizzate spesso in istruzioni per il controllo dell’esecuzione (vedi paragrafo 5). Gli
operatori logici sono elencati in Tab. 7.
Operatore Numero operandi Descrizione

NOT 1 Inversione
AND 2 AND logico
OR 2 OR logico
EXOR 2 Anticoincidenza
Tab. 7 Operatori logici
Gli operandi di una connessione logica devono essere del tipo BOOL, il risultato è anch’esso
sempre del tipo BOOL. In Tab. 8 sono rappresentati i possibili risultati delle relative connes-
sioni in base al valore degli operandi.
Operazione NOT A A AND B A OR B A EXOR B

A = TRUE B = TRUE FALSE TRUE TRUE FALSE
A = TRUE B = FALSE FALSE FALSE TRUE TRUE
A = FALSE B = TRUE TRUE FALSE TRUE TRUE
A = FALSE B = FALSE TRUE FALSE FALSE FALSE
Tab. 8 Tavola di verità per connessioni logiche
Alcuni esempi per quanto riguarda le connessioni logiche:

¼
BOOL A,B,C
¼
A = TRUE ;A=TRUE
B = NOT A ;B=FALSE
C = (A AND B) OR NOT (B EXOR NOT A) ;C=TRUE
A = NOT NOT C ;A=TRUE
¼
48 di 214
2.3.1.5 Operatori bit

Con l’aiuto degli operatori bit (vedi Tab. 9) è possibile connettere dei numeri interi tra di loro
effettuando una connessione logica dei singoli bit dei numeri. Gli operatori bit connettono dei
singoli bit nello stesso modo come gli operatori logici due valori di Boole se si considera il
valore bit 1 come TRUE e il valore 0 come FALSE.
Da una operazione AND per bit dei numeri 5 e 12 risulta ad es. il numero 4, da una disgiun-
zione per bit il numero 13 e da una operazione di anticoincidenza per bit il numero 9:
0 1 0 1 = 5
1 1 0 0 = 12
AND 0 1 0 0 = 4
OR 1 1 0 1 = 13
EXOR 1 0 0 1 = 9
Nel caso dell’inversione per bit non vengono semplicemente invertiti tutti i bit. In caso di
utilizzo di B_NOT viene invece sommato 1 all’operando e il segno viene invertito, ad es.:
B_NOT 10 = -11
B_NOT -10 = 9
Gli operatori bit vengono impiegati ad esempio per interconnettere dei segnali I/O digitali
(vedi 6.3).
Operatore Numero operandi Descrizione

B_NOT 1 Inversione per bit
B_AND 2 Operazione AND per bit
B_OR 2 Disgiunzione per bit
B_EXOR 2 Operazione di anticoincidenza per bit
Tab. 9 Operatori bit logici
Poiché i caratteri ASCII sono anche attivabili tramite il codice ASCII di numeri interi, il
tipo di dati degli operandi può essere oltre a INT anche CHAR. Il risultato è sempre del
tipo INT.
49 di 214
Esempi per l’utilizzo di operatori bit:

¼
INT A
¼
A = 10 B_AND 9 ;A=8
A = 10 B_OR 9 ;A=11
A = 10 B_EXOR 9 ;A=3
A = B_NOT 197 ;A=-198
A = B_NOT ’HC5’ ;A=-198
A = B_NOT ’B11000101’ ;A=-198
A = B_NOT “E” ;A=-70
¼
Presupponiamo di avere definito un’uscita digitale della larghezza di 8 bit. E’ possibile
richiamare l’uscita tramite la variabile INTEGER DIG. Per settare i bit 0, 2, 3 e 7 si può
semplicemente programmare
Sovrapporre DIG = ’B10001101’ B_OR DIG
bit
Tutti gli altri bit rimangono invariati indipendentemente dal valore che hanno.
Per mascherare ad es. i bit 1, 2 e 6 programmare
Mascherare DIG = ’B10111001’ B_AND DIG
bit
Tutti gli altri bit non vengono modificati.
E’ altrettanto facile verificare con gli operatori bit se dei singoli bit dell’uscita sono settate.
L’espressione
Filtrare bit (’B10000001’ B_AND DIG) == ’B10000001’
diventa TRUE, se i bit 0 e 7 sono settati, altrimenti diventa FALSE.
Se si vuole soltanto verificare se almeno uno dei due bit 0 o 7 è settato, è sufficiente che
l’operazione AND per bit sia maggiore di zero:
(’B10000001’ B_AND DIG) > 0
50 di 214
2.3.1.6 Priorità di operatori

Se vengono usate delle espressioni più complesse con più operatori è necessario osservare
Priorità le diversepriorità dei singoli operatori (vedi Tab. 10), poiché le singole espressioni vengono
eseguite nell’ordine delle loro priorità.
Priorità Operatore
1 NOT B_NOT
2 * /
3 + -
4 AND B_AND
5 EXOR B_EXOR
6 OR B_OR
7 == <> < > >= <=
Tab. 10 Priorità di operatori
In linea di massima vale:
G Le espressioni tra parentesi vengono elaborate per prime.

G In caso di espressioni senza parentesi l’analisi avviene nell’ordine della
priorità.
G Le connessioni con operatori della stessa priorità vengono eseguite da sinistra
verso destra.
Esempi:
¼
INT A,B
BOOL E,F
¼
A = 4
B = 7
E = TRUE
F = FALSE
¼
E = NOT E OR F AND NOT (-3 + A * 2 > B) ;E=FALSE
A = 4 + 5 * 3 - B_NOT B / 2 ;A=23
B = 7 B_EXOR 3 B_OR 4 B_EXOR 3 B_AND 5 ;B=5
F = TRUE == (5 >= B) AND NOT F ;F=TRUE
¼
51 di 214
2.3.2 Funzioni standard

Per risolvere certi problemi matematici, nel KRL sono predefinite alcune funzioni standard
(vedi Tab. 11) che possono essere utilizzate direttamente senza una ulteriore dichiarazione.
Descrizione Funzione Tipo di Gamma Tipo di Gamma

dati argo- valori dati valori
mento argomento funzione risultato
Importo ABS(X) REAL --∞¼+∞ REAL 0¼+∞
Radice SQRT(X) REAL 0¼+∞ REAL 0¼+∞
Seno SIN(X) REAL --∞¼+∞ REAL -1¼+1
Coseno COS(X) REAL --∞¼+∞ REAL -1¼+1
Tangente TAN(X) REAL --∞¼+∞* REAL --∞¼+∞
Arcocos. ACOS(x) REAL -1¼+1 REAL 0_¼180_
Arcotang. ATAN2(Y,X) REAL --∞¼+∞ REAL -90_¼+90_
* nessun multiplo dispari di 90_, cioè X ¸ (2k-1)*90_, kÎ8
Tab. 11 Funzioni standard matematiche
Importo La funzione ABS(X) calcola l’importo del valore X, ad es.:

B = -3.4
A = 5 * ABS(B) ;A=17.0
Radice SQRT(X) calcola la radice quadrata del numero X, ad es.:
A = SQRT(16.0801) ;A=4.01
Seno Le funzioni trigonometriche SIN(X), COS(X) e TAN(X) calcolano il seno, il coseno e il tan-
Coseno gente dell’angolo X, ad es.:
Tangente
A = SIN(30) ;A=0.5
B = 2*COS(45) ;B=1.41421356
C = TAN(45) ;C=1.0
Il tangente di ±90_ e di multipli dispari di ±90_ (±270_, ±450_, ±630_¼) è infinito. Quindi il
tentativo di calcolare uno di questi valori comporta un messaggio di errore.
Arcocoseno ACOS(X) è la funzione inversa di COS(X):
A = COS(60) ;A=0.5
B = ACOS(A) ;B=60
Arcoseno Per l’arcoseno, la funzione inversa di SIN(X), non è predefinita nessuna funzione standard.
Ma è molto facile calcolarlo in base alla relazione SIN(X) = COS(90_--X):
A = SIN(60) ;A=0.8660254
B = 90-ACOS(A) ;B=60
Il tangente di un angolo è definito come il cateto opposto (Y) diviso per il cateto adiacente
(X) nel triangolo rettangolo. Se si dispone della lunghezza dei due cateti è possibile calcolare
Arcotangente l’angolo tra il cateto adiacente e l’ipotenusa con l’arcotangente.
In caso di un cerchio intero è decisivo quale segno hanno i componenti X e Y. Se si tenesse
conto soltanto del quoziente sarebbe possibile calcolare con l’arcotangente soltanto degli
angoli tra 0_ e 180_. Questa è anche una caratteristica di tutte le calcolatrici consueti: l’arco-
tangente di valori positivi produce un angolo tra 0_ e 90_, l’arcotangente di valori negativi un
angolo tra 90_ e 180_.
Per mezzo dell’indicazione esplicita di X e Y viene stabilito tramite il loro segno in modo uni-
voco il quadrante nel quale si trova l’angolo (vedi Fig. 6). E’ quindi possibile calcolare anche
52 di 214
degli angoli nei quadranti III e IV. Per questo motivo, per il calcolo dell’arcotangente nella
funzione ATAN2(Y,X) sono necessarie anche queste due indicazioni, ad es.:
A = ATAN2(0.5,0.5) ;A=45
B = ATAN2(0.5,-0.5) ;B=135
C = ATAN2(-0.5,-0.5) ;C=225
D = ATAN2(-0.5,0.5) ;D=315
II I
X=COS(a)
Y=SIN(a)
a
0
III IV
Fig. 6 Utilizzo di X e Y nella funzione ATAN2(Y,X)
Ulteriori informazioni sono contenute nel capitolo [Sottoprogrammi e funzioni].
APPUNTI:
53 di 214
2.4 Variabili di sistema e file di sistema

Un importante prerequisito per l’elaborazione di applicazioni complesse nella tecnica robot
è che il controllo può essere programmato liberamente e confortevolmente.
A questo scopo dev’essere programmabile in modo semplice la funzionalità del controllo
robot nel linguaggio robot. Soltanto quando l’integrazione dei parametri del controllo in un
programma robot è possibile in modo completo e contemporaneamente facile si può
sfruttare la piena funzionalità di un controllo robot. Il KR C... risolve ciò in modo eccellente
tramite il concetto delle variabile e dei file di sistema predefiniti.
Esempi per delle variabili predefinite sono $POS_ACT (posizione robot attuale), $BASE
(sistema di coordinate base) o $VEL.CP (velocità di avanzamento).
Un elenco di tutte le variabili predefinite è contenuto nella documetazione Appendice,

capitolo [Variabili di sistema].
Le variabili di sistema sono integrate completamente nel concetto delle variabili del KRL.
Dispongono di un tipo di dati opportuno e possono essere lette e scritte come ogni altra
variabile nel programma se non esistono delle limitazioni a causa del tipo di dati. La posizione
attuale del robot può essere ad es. soltanto letta ma non scritta. Tali limitazioni vengono
verificate dal controllo.
Per quanto possibile per motivi tecnici di sicurezza si dispone perfino dell’accesso per
scrittura ai dati di sistema. Con ciò nascono molte possibilità per la diagnosi poiché una
pluralità di dati di sistema può essere caricata o influenzata dal KCP e dal sistema di
programmazione.
Delle variabili di sistema utili con accesso per scrittura sono ad esempio $TIMER[] e
$FLAG[].
Timer Le 16 variabili Timer $TIMER[1]...$TIMER[16] servono per la misurazione di cicli tempo-
rali e possono essere impiegate come “cronometro”. L’avvio e l’arresto del processo di misu-
razione avviene tramite le variabili di sistema $TIMER_STOP[1]...$TIMER_STOP[16]:
$TIMER_STOP[4] = FALSE
avvia ad esempio il timer 4,
$TIMER_STOP[4] = TRUE
arresta il timer 4. Tramite una normale assegnazione di valore, la rispettiva variabile timer
può essere resettata in qualsiasi momento, ad es.:
$TIMER[4] = 0
Se il valore di una variabile timer cambia da meno a più, allora viene settato un corrispon-
dente flag su TRUE (condizione timer out), ad es.:
$TIMER_FLAG[4] = TRUE
Al caricamento del controllo vengono preimpostate tutte le variabili timer con 0, i flag
$TIMER_FLAG[1]...$TIMER_FLAG[16] con FALSE e le variabili
$TIMER_STOP[1]...$TIMER_STOP[16] con TRUE.
L’unità delle variabili timer sono i millesimi di secondo (ms). L’aggiornamento di
$TIMER[1]...$TIMER[16] e $TIMER_FLAG[1]...$TIMER_FLAG[16]
avviene ogni 12 ms.
54 di 214
Flags I 1024 flags $FLAG[1]...$FLAG[1024] vengono impiegati come merker globali. Queste
variabili di Boole vengono preimpostate con FALSE. Il valore attuale dei flags può essere
visualizzato in ogni momento sull’interfaccia grafica sotto il punto menù “Visualizza”.
Flags ciclici Inoltre nel KR C... sono disponibili 32 flags ciclici $CYCFLAG[1]¼$CYCFLAG[32]. Dopo
il caricamento del controllo essi sono tutti preimpostati su FALSE.
I flags sono attivi ciclicamente soltanto sul livello robot. In un submitfile i flags ciclici sono
ammessi ma non avviene nessuna analisi ciclica.
I flags ciclici possono essere definiti ed attivati anche in sottoprogrammi, funzioni e sottopro-
grammi interrupt.
$CYCFLAG[1]...$CYCFLAG[32] sono del tipo di dati BOOL. Per un’assegnazione ad un flag
ciclico può essere utilizzata una qualsiasi espressione di Boole.
Sono ammesse
G delle variabili di sistema di Boole e
G delle variabili di Boole che sono state dichiarate ed inizializzate in una lista dati.
Non sono ammesse
G delle funzioni che forniscono un valore di Boole.
L’istruzione
$CYCFLAG[10] = $IN[2] AND $IN[13]
comporta ad esempio che l’espressione di Boole “$IN[2] AND $IN[13]” venga
analizzata ciclicamente. Ciò vuol dire che appena varia l’ingresso 2 o l’ingresso 13 varia
anche $CYCFLAG[10], indipendentemente dal fatto in quale posizione si trova il puntatore
di programma dopo l’esecuzione della suddetta espressione.
Tutti i flags ciclici definiti rimangono validi finché un modulo viene deselezionato o viene
eseguita una selezione di frase con reset. Al raggiungimento della fine del programma tutti
i flag ciclici rimangono attivi.
Ulteriori informazioni sono contenute nel capitolo [Trattamento interrupt] paragrafo

[Utilizzo di flag ciclici].
$ -- carattere Generalmente i nomi delle variabili predefinite sono scelti in modo da poterli ricordare
facilmente. In effetti, tutti cominciano con un carattere $ seguito da un’abbreviazione inglese
caratteristica. Siccome vengono trattate come delle variabili usuali non è necessario
ricordarsi comandi insoliti o delle opzioni strane.
Per evitare confusione con le variabili di sistema, si consiglia di non dichiarare

delle proprie variabili che iniziano con un carattere $.
Una parte delle variabili predefinite si riferisce all’intero controllo KR C... (ad es.
$ALARM_STOP per la definizione dell’uscita per il segnale di emergenza verso il PLC). Altre
riguardano invece soltanto il robot (ad es. $BASE per il sistema di coordinate base).
55 di 214
Sull’interfaccia grafica KUKA appare il drive del robot nel quale i dati rilevanti per il controllo
sono depositati nella directory “Steu” e i dati rilevanti per il robot nella directory “R1”.
Fig. 7 Diversi livelli sull’interfaccia grafica KUKA
Durante la programmazione del KR C... è possibile creare dei file di programma e delle liste
dati. Nei file di programma si trovano delle definizioni di dati e delle istruzioni eseguibili, le
liste dati contengono soltanto delle definizioni di dati ed eventualmente delle inizializzazioni.
Ulteriori informazioni sono contenute nel capitolo [Liste dati].
Oltre alle liste dati create durante la programmazione, nel KR C... esistono anche delle liste
dati definite da KUKA che vengono fornite con il software di controllo. Queste liste dati
vengono chiamate liste dati predefinite e contengono principalmente le variabili predefinite.
Le liste dati predefinite non possono essere né cancellate né create da Voi. Esse vengono
generate nel momento dell’installazione del software e sono poi sempre presenti. Anche i
nomi delle liste dati predefinite iniziano come i nomi dei dati predefiniti con un carattere $.
Nel KR C... esistono le seguenti liste dati predefinite:
G $MACHINE.DAT
è una lista dati predefinita con delle variabili di sistema esclusivamente predefinite.
Tramite i dati macchina il controllo viene adattato al robot collegato (cinematica,
parametri di regolazione, ecc.). Esiste una $MACHINE.DAT sia nel sistema di controllo
che nel sistema robot. Non è possibile creare delle variabili nuove o cancellare delle
variabili esistenti.
Esempi:
$ALARM_STOP Segnale per Emergenza (specifico del controllo)
$NUM_AX Numero degli assi robot (specifico del robot)
G $CUSTOM.DAT
è una lista dati presente soltanto nel sistema di controllo. Contiene dei dati con i quali
è possibile progettare o parametrizzare determinate funzioni di controllo. Per il
programmatore esiste soltanto la possibilità di modificare i valori delle variabili
predefinite. Non è possibile creare delle variabili nuove o cancellare delle variabili
esistenti.
Esempi:
$PSER_1 Parametri di protocollo dell’interfaccia seriale 1
$IBUS_ON Attivazione di gruppi interbus alternativi
56 di 214
G $CONFIG.DAT
è una lista dati predefinita da KUKA che però non contiene delle variabili di sistema
predefinite. Esiste una $CONFIG.DAT sul livello del controllo e sul livello robot. Lì
possono essere definiti delle variabili, delle strutture, dei canali e dei segnali che sono
validi per più tempo e che sono di importanza superiore per molti programmi.
La lista dati è suddivisa nei seguenti blocchi:
-- BAS
-- AUTOEXT
-- GRIPPER
-- PERCEPT
-- SPOT
-- A10
-- A20
-- TOUCHSENSE
-- USER
Delle dichiarazioni globali dell’utente dovrebbero essere inserite preferibilmente nel
blocco USER poiché soltanto le dichiarazioni contenute qui vengono mantenute in caso
di un successivo aggiornamento del software.
G $ROBCOR.DAT
Il file $ROBCOR.DAT contiene dei dati specifici del robot per il modello dinamico del
robot. Questi dati sono necessari per la programmazione della traiettoria. Anche qui
non è possibile creare delle variabili nuove o cancellare delle variabili esistenti.
Tab. 12 fornisce un riassunto delle liste dati predefinite.
Lista dati Sistema Assegnazione valore

Controllo Robot nel momento della tramite
$MACHINE.DAT n n Messa in servizio KUKA/utente
$CUSTOM.DAT n Messa in servizio Utente/KUKA
$CONFIG.DAT n n Creazione o tras- Utente/KUKA
formazione celle
$ROBCOR.DAT n Fornitura KUKA
Tab. 12 Liste dati predefinite nel KR C...
APPUNTI:
57 di 214
58 di 214
3 Programmazione del movimento
3 Programmazione del movimento

Uno dei compiti più importanti di un controllo robot è il movimento del robot. Il programmatore
comanda i movimenti del robot industriale tramite delle istruzioni di movimento speciali. Esse
costituiscono anche la caratteristica principale che differenzia i linguaggi robot dai tradizio-
nali linguaggi di programmazione per computer come C o Pascal.
Istruzioni di A secondo del tipo di controllo queste istruzioni di movimento possono essere suddivise in
movimento comandi per semplici movimenti da punto a punto e in comandi per movimenti lungo la traiet-
toria. Mentre nel caso dei movimenti lungo la traiettoria l’esecutore finale (ad es. gripper o
utensile) descrive una traiettoria nello spazio che è stata definita in modo esatto per quanto
riguarda la geometria (retta o curva), la traiettoria nel caso di movimenti da punto a punto
dipende dalla cinematica del robot e quindi non è esattamente prevedibile. Entrambi i tipi di
movimento hanno in comune che la programmazione avviene dalla posizione attuale verso
una nuova posizione. Per questo motivo in un’istruzione di movimento è generalmente suffi-
ciente indicare soltanto la posizione di destinazione (eccezione: movimenti circolari, vedi
3.3.4).
Le coordinate di posizioni possono essere specificate o testualmente tramite l’immissione
di valori numerici o muovendo il robot su di esse e memorizzando i valori attuali (Teach). Esi-
ste la possibilità di riferire le indicazioni a diversi sistemi di coordinate.
Altre caratteristiche del movimento come le velocità, le accelerazioni e l’orientamento pos-
sono essere impostate tramite le variabili di sistema. L’approssimazione di punti intermedi
viene inizializzata tramite dei parametri opzionali nell’istruzione di movimento. In caso di ap-
prossimazione dev’essere impostato un processo avanzato del calcolatore.
3.1 Utilizzo di diversi sistemi di coordinate

Per poter indicare la posizione oppure l’orientamento di un punto nello spazio vengono usati
Sistemi di diversi sistemi di coordinate. E’ possibile fare una distinzione basilare tra sistemi di coordi-
coordinate nate specifici per asse e sistemi di coordinate cartesiani:
Specifico per Nel sistema di coordinate specifico per asse vengono indicati gli spostamenti (in caso di
asse assi traslatori) oppure gli orientamenti (in caso di assi rotatori) di ogni asse robot. Per un robot
a 6 assi con braccio flessibile occorre dunque indicare tutti i 6 angoli snodo del robot per de-
terminare in modo univoco la posizione e l’orientamento (vedi Fig. 8).
Fig. 8 Sistema di coordinate specifico per asse di un robot a 6 assi con braccio flessibile
59 di 214
La descrizione di una posizione specifica per asse avviene nel KR C... tramite il tipo di strut-
tura predefinito AXIS, i cui componenti hanno a seconda del tipo di asse il significato di angoli
o di lunghezze.

[Strutture].
Delle posizioni specifiche per asse possono essere raggiunte soltanto insieme a frasi di mo-
vimento PTP. Se un movimento lungo la traiettoria viene programmato con una posizione
robot specifica per asse, ciò provoca un errore.
Trasforma- Poiché il programmatore pensa in coordinate cartesiane, la programmazione nel sistema di
zione di coordinate specifico per asse è quasi sempre molto scomodo. Il controllo offre quindi diversi
coordinate sistemi di coordinate cartesiani per la programmazione le cui coordinate vengono trasfor-
mate prima dell’esecuzione del movimento automaticamente nel sistema specifico per asse
(vedi Fig. 9).
Trasformazione in avanti
A1, A2, A3, A4, A5, A6
X, Y, Z, A, B, C (, S, T)
Trasformazione indietro
Fig. 9 Trasformazione di coordinate
Cartesiano In un sistema di coordinate cartesiano, i tre assi delle coordinate X, Y, e Z sono

perpendicolari tra di loro e costituiscono in questo ordine un sistema a destra.
60 di 214
3 Programmazione del movimento (segue)
La posizione di un punto nello spazio è definita nel sistema di coordinate cartesiano in modo
univoco tramite l’indicazione delle coordinate X, Y e Z. Queste risultano dalle distanze trasla-
torie di ogni valore delle coordinate rispetto all’origine delle coordinate (vedi Fig. 10).
Z
P
Z1
Y1
X1 X
P(X1=5, Y1=2, Z1=4)
Fig. 10 Descrizione traslatoria della posizione di un punto
Per poter raggiungere ogni punto nello spazio con un orientamento qualsiasi sono necessa-
rie oltre ai tre valori traslatori anche tre indicazioni rotatorie:
Gli angoli denominati A, B e C nel KR C... descrivono delle rotazioni intorno agli assi delle
coordinate Z, Y e X. Occorre rispettare l’ordine delle rotazioni:
1. Rotazione intorno all’asse Z dell’angolo A
2. Rotazione intorno al nuovo asse Y dell’angolo B
3. Rotazione intorno al nuovo asse X dell’angolo C
Questo ordine di rotazione corrisponde agli angoli roll--pitch--yaw (rullare--beccheggiare--
imbardare) noti dall’aviazione. L’angolo C corrisponde al rullare, l’angolo B al beccheggiare
e l’angolo A all’imbardare (vedi Fig. 11).
61 di 214
A B C
Z’ Y’
Z B
A Y ’’
Z ’’
Y X’ Y ’’’
Z ’’’
X
C
X ’’ X ’’’
Fig. 11 Descrizione rotatoria dell’orientamento di un punto
Tramite le traslazioni X, Y e Z e le rotazioni A, B e C è quindi possibile descrivere in modo

univoco la posizione e l’orientamento di un punto nello spazio. Nel KR C... ciò avviene per
mezzo della struttura predefinita FRAME.

[Strutture].
In caso di movimenti lungo la traiettoria, l’indicazione delle coordinate FRAME è sempre uni-
voca e sufficiente. Per lo spostamento da punto a punto può però essere raggiunto in caso
di determinate cinematiche del robot (ad es. braccio flessibile a 6 assi) il medesimo punto
(posizione ed orientamento) nello spazio con diverse posizione degli assi. Tramite le due ul-
teriori indicazioni “S” e “T” questa ambiguità può essere evitata. Nel KR C... è prevista la
struttura POS per un frame ampliato di “S” e “T”.

[Strutture] e nel presente capitolo [Programmazione del movimento] paragrafo [Co-
mandi di movimento].
62 di 214
Nel KR C... sono predefiniti i seguenti sistemi di coordinate cartesiani (Tab. 13 e Fig. 12):
Sistema di coordinate Variabile di Stato

sistema
Sistema di coordinate mondo $WORLD protetto da scrittura
Sistema di coordinate robot $ROBROOT protetto da scrittura
(in R1\MADA\$MACHI-
NE.DAT modificabile)
Sistema di coordinate utensile $TOOL* scrittura possibile
Sistema di coordinate base (pezzo) $BASE* scrittura possibile
Tab. 13 Sistemi di coordinate predefiniti
y
z
Sistema di
z x coordinate utensile
z y
Sistema di x
y coordinate base
Sistema di
coordinate mondo Sistema di
z coordinate robot
y x
Fig. 12 Sistemi di coordinate cartesiani per robot
Sistema di coordinate mondo

Il sistema di coordinate mondo è un sistema di coordinate fisso (cioè non si muove insieme
al movimento del robot) che serve come sistema di coordinate origine per un sistema robot
(robot, appoggio pezzo oppure utensile). Costituisce quindi il sistema di riferimento sia per
il sistema robot che anche per la periferia delle celle.
Sistema di coordinate robot

Questo sistema di coordinate si trova nel piede del robot e serve come sistema di coordinate
di riferimento per la struttura meccanica del robot. Si riferisce a sua volta al sistema di coordi-
nate mondo ed è identico con questo al momento della consegna. Con $ROBROOT può es-
sere definito uno spostamento del robot rispetto a $WORLD.
Sistema di coordinate utensile

Il sistema di coordinate utensile ha la sua origine nella punta dell’utensile. L’orientamento può
essere scelto in modo che il suo asse X sia identico alla direzione di lavoro dell’utensile e
che prosegua oltre l’utensile. In caso di un movimento della punta dell’utensile viene anche
mosso il sistema di coordinate utensile.
63 di 214
Al momento della consegna il sistema

di coordinate utensile si trova nella
flangia del robot (asse Z è identico
all’asse 6). Si riferisce tramite la tras-
formazione al sistema di coordinate
Y robot.
X
Z
Se avviene un cambio di utensile, dopo la nuova misurazione è possibile continuare ad usare

il programma originario poiché al calcolatore sono note le coordinate della punta dell’utensile.
Sistema di coordinate base

Il sistema di coordinate base viene impiegato come sistema di riferimento per la descrizione
della posizione del pezzo in lavorazione. La programmazione del robot avviene nel sistema
di coordinate base. Il suo sistema di coordinate di riferimento è il sistema di coordinate
mondo. Al momento della consegna vale $BASE=$WORLD.
Modificando $BASE possono ad es. essere lavorati più pezzi uguali in posti diversi con lo
stesso programma.
Interpolazione In caso di interpolazione della traiettoria di movimento, il controllo robot calcola nel caso nor-
riferita alla male (utensile sulla flangia del robot) la posizione attuale ($POS_ACT) con riferimento al si-
base stema di coordinate $BASE (vedi Fig. 13).
z
$TOOL
y
z
x
$POS_ACT
y
$BASE x
x
$ROBROOT
z y
$WORLD x
Fig. 13 Catena cinematica in caso di interpolazione riferita alla base
64 di 214
Utensile fisso Nella prassi industriale si tende però sempre di più ad ancorare l’utensile (ad es. cannello
di saldatura) saldamente nello spazio e di far passare il pezzo stesso tramite un gripper
adatto lungo l’utensile fisso.
La variabile $TOOL si riferisce sempre all’utensile oppure al pezzo che si trova sul robot. La
variabile $BASE si riferisce invece sempre all’utensile oppure al pezzo esterno.
Interpolazione Poiché ora il pezzo e l’utensile hanno cambiato la loro posizione, ma il movimento deve avve-
riferita al nire ancora con riferimento al pezzo, è necessario effettuare l’interpolazione della traiettoria
gripper di movimento tramite il sistema di coordinate $TOOL. Questa assegnazione del tipo di inter-
polazione avviene implicitamente all’utilizzo di un TCP normale o esterno. Tramite la varia-
bile di sistema $IPO_MODE è possibile definire questo tipo di interpolazione. La riga di pro-
gramma
$IPO_MODE = #TCP
consente una interpolazione riferita al gripper nel sistema di coordinate $TOOL. La posizione
attuale $POS_ACT viene ora calcolata rispetto a $TOOL (vedi Fig. 14). Con
$IPO_MODE = #BASE
il tipo di interpolazione viene di nuovo impostato sull’interpolazione riferita alla base per il
caso normale. Ciò è anche l’impostazione standard al caricamento del controllo.
$TOOL y
x
z z
$POS_ACT
z y
x
$BASE
x
$ROBROOT
z y
$WORLD x
Fig. 14 Catena cinematica in caso di interpolazione riferita al gripper
Un esempio per quanto riguarda lo spostamento di sistemi di coordinate è contenuto nel

capitolo [Variabili e dichiarazioni] paragrafo [Operatore geometrico].
65 di 214
3.2 Movimenti da punto a punto (PTP)

3.2.1 Generalità (PTP sincrono)
PTP Il movimento da punto a punto (PTP) costituisce la possibilità più veloce per muovere la
punta dell’utensile (Tool Center Point: TCP) dalla posizione attuale ad una posizione di
destinazione programmata. Il controllo calcola a questo scopo le necessarie differenze
angolari per ogni asse.
Tramite la variabile di sistema
G $VEL_AXIS[Numero asse] vengono programmate le velocità massime specifiche
per asse,
e tramite
G $ACC_AXIS[Numero asse] le accelerazioni massime specifiche per asse.
Tutte le indicazioni sono in %, riferite ad un valore massimo definito nei dati macchina. Se
queste due variabili di sistema non fossero state definite per tutti gli assi, durante l’esecu-
zione del programma viene emesso un relativo messaggio errore.
I movimenti dei singoli assi vengono sincronizzati in modo (PTP sincrono) che tutti gli assi
iniziano e terminano il movimento contemporaneamente. Ciò significa che soltanto l’asse col
percorso più lungo, il cosiddetto asse dominante, si sposta col valore limite programmato per
accelerazione e velocità. Tutti gli altri assi si muovono con le accelerazioni e le velocità ne-
cessarie per raggiungere allo stesso momento il punto di destinazione del movimento, indi-
pendentemente dei valori programmati in $VEL_AXIS[Nr] e $ACC_AXIS[Nr].
Se è attivato l’adattamento dell’accelerazione o il profilo di traslazione superiore
($ADAP_ACC=#STEP1, $OPT_MOVE=#STEP1), gli assi vengono spostati addizionalmente
in modo sincrono relativo alla fase, cioè tutti gli assi si trovano contemporaneamente nella
fase di accelerazione, di traslazione costante e di rallentamento.
Siccome in caso di movimenti PTP con coordinate di destinazione cartesiane

generalmente non è noto qual’è l’asse dominante, è spesso opportuno impostare gli stessi
valori di accelerazione e di velocità per tutti gli assi.
La movimentazione sincrona relativa al tempo riduce la sollecitazione meccanica del robot,

poiché i momenti del motore e riduttore vengono abbassati per tutti gli assi con percorsi di
traslazione più brevi.
La movimentazione sincrona relativa alla fase porta (addizionalmente) ad una traiettoria che
presenta, indipendentemente dalla velocità e dall’accelerazione programmata, lo stesso an-
damento nello spazio.

paragrafo [Movimenti approssimati].
66 di 214
3.2.2 Profilo di traslazione superiore

Come standard viene utilizzato per movimenti PTP un profilo di traslazione superiore. Con
questo modello lo spostamento dal punto di partenza al punto di destinazione avviene in
modo temporalmente ottimale per frasi singoli PTP e per frasi di approssimazione PTP.
Ciò significa che con i riduttori e motori presenti non è possibile muoversi più velocemente.
I momenti ammessi vengono sfruttati in ogni punto della traiettoria sempre in modo ottimale,
particolarmente anche nella fase di velocità costante. La velocità viene in questo caso sem-
pre adattata in modo che i momenti non vengano superati.
Una variazione dei valori di velocità e di accelerazione provoca anche in frasi di approssima-
zione soltanto una variazione del profilo di velocità sulla traiettoria. La curva geometrica nello
spazio rimane invariata.
I valori della velocità ed i valori limiti dell’accelerazione (indicazione in percentuale) possono
essere impostati singolarmente per ogni asse. Questo valore limite non ha però direttamente
effetto sull’accelerazione, ma sul momento di accelerazione dell’asse. Ciò significa che un
valore di accelerazione dell’asse del 50% non riduce necessariamente l’accelerazione della
metà.
67 di 214
3.2.3 Comandi di movimento

Il seguente esempio di programma PTP_AXIS.SRC rappresenta per principio il più piccolo
programma KRL in grado di girare:
DEF PTP_AXIS() ;Il nome del programma è PTP_AXIS

$VEL_AXIS[2]=100
$VEL_AXIS[3]=100
$VEL_AXIS[4]=100
$VEL_AXIS[5]=100
$VEL_AXIS[6]=100
$ACC_AXIS[1]=100 ;Determinazione accelerazioni degli assi

$ACC_AXIS[2]=100
$ACC_AXIS[3]=100
$ACC_AXIS[4]=100
$ACC_AXIS[5]=100
$ACC_AXIS[6]=100
PTP {AXIS: A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}
END
Dapprima vengono determinate in questo programma le velocità e le accelerazioni degli

assi. Prima di poter eseguire un movimento da punto a punto occorre effettuare le
assegnazioni.
In seguito il robot sposta ogni asse nelle posizioni angolari specificate nella struttura AXIS.
Per esempio asse 1 su 0_, l’asse 2 su --90_, l’asse 3 su 90_, l’asse 4 su 0_, l’asse 5 su 0_
e l’asse 6 su 0_.
Fig. 15 Posizione zero meccanica
68 di 214
Se durante l’indicazione delle coordinate degli assi vengono omessi dei singoli componenti,
il robot sposta soltanto gli assi indicati mentre la posizione degli altri rimane invariata. Con
PTP PTP {A3 45}

viene portato ad es. soltanto l’asse 3 su 45_. Occorre osservare che le indicazioni angolari
nell’istruzione PTP sono dei valori assoluti. Il robot quindi non ruota l’asse di ulteriori 45_, ma
si sposta sulla posizione 45_ assoluta dell’asse.
Per lo spostamento relativo serve l’istruzione PTP_REL. Per ruotare ad es. gli assi 1 e 4 cia-
scuna di 35_ occorre programmare:
PTP_REL PTP_REL {A1 35,A4 35}
A3 = 0_
PTP {A3 45}
A3 = 90_
PTP_REL {A3 45}
Fig. 16 Differenza tra coordinate specifiche per asse assolute e relative
In caso di spostamento relativo occorre però osservare che un movimento

arrestato durante l’esecuzione non può essere ripreso senza problemi. Il
controllo non è in grado di tener conto, dopo un riavvio e una nuova
selezione di frase oppure dopo un cambio del tipo di esecuzione
programma, del percorso già effettuato e si sposterà di nuovo dell’intera
distanza relativa programmata il che comporta infine un punto di
destinazione errato.
69 di 214
Lo spostamento in coordinate specifiche per asse è quasi sempre scomodo poiché l’uomo
pensa ed agisce nello spazio cartesiano. A questo scopo serve l’indicazione delle coordinate
cartesiane tramite una struttura POS utilizzata nel seguente esempio:
DEF PTP_POS()
$BASE = $WORLD ;Settaggio del sistema di coordinate base

$TOOL = $NULLFRAME ;Settaggio del sistema di coordinate utensile

$VEL_AXIS[2]=100
$VEL_AXIS[3]=100
$VEL_AXIS[4]=100
$VEL_AXIS[5]=100
$VEL_AXIS[6]=100
$ACC_AXIS[1]=100 ;Determinazione accelerazioni degli assi

$ACC_AXIS[2]=100
$ACC_AXIS[3]=100
$ACC_AXIS[4]=100
$ACC_AXIS[5]=100
$ACC_AXIS[6]=100
PTP {POS:X 1025,Y 0,Z 1480,A 0,B 90,C 0,S ’B 010’,T ’B 000010’}
END
Occorre osservare ora che in caso di indicazione del punto di destinazione in

coordinate cartesiane devono essere definiti, oltre ai valori di velocità e di
accelerazione, assolutamente anche il sistema di coordinate base e il sistema di
coordinate utensile.
Sistemi di Nel nostro caso il sistema di coordinate base ($BASE) è stato settato in modo identico al si-
coordinate stema di coordinate mondo ($WORLD) il quale si trova come standard nel piede del robot
($ROBROOT). Al sistema di coordinate utensile ($TOOL) è stato assegnato il frame zero
($NULLFRAME = {FRAME: X 0, Y 0, Z 0,A 0,B 0,C 0}) che significa che tutte le
indicazioni si riferiscono al centro della flangia. Il centro dell’utensile (Tool Center Point: TCP)
si trova dunque per così dire nel centro della flangia. Se è flangiato un utensile i valori devono
essere corretti in modo opportuno. Al riguardo si rimanda alla documentazione per la misura-
zione di utensili.
Con la suddetta istruzione PTP il robot si sposta ora in modo che nel punto di destinazione
del movimento il TCP sia spostato di 1025 mm in direzione x, di 0 mm in direzione y e di
1480 mm in direzione z rispetto al piede del robot. Le indicazioni “A”, “B” e “C” definiscono
l’orientamento del TCP. Status “S” e Turn “T” definiscono la posizione degli assi.
Se l’esempio viene sperimentato con un robot KR 6 si otterrà lo stesso risultato come
nell’esempio precedente. Il robot si muove nella posizione zero meccanica. Le due istruzioni
sono quindi identiche per questo tipo di robot.
Anche nel caso dell’indicazione del punto di destinazione in coordinate cartesiane è possibile
omettere dei singoli componenti dell’indicazione geometrica. L’istruzione
PTP {Z 1300, B 180}
comporta un movimento del TCP in direzione dell’asse z sulla posizione assoluta 1300 mm
e un “beccheggio” del TCP di 180_.
70 di 214
Per lo spostamento relativo del robot si usa di nuovo il comando PTP_REL. Con
PTP_REL {Z 180, B -90}
è dunque possibile riportare il robot nella sua posizione originaria. Occorre osservare che
i movimenti relativi non devono essere nuovamente selezionati dopo un’interruzione.
ZBASE
PTP {X 50, Y 50} PTP_REL {X 50, Y 50}
YBASE
200
150
100
50
XBASE
50 100 150 200
Fig. 17 Differenza tra coordinate cartesiane assolute e relative
In caso di coordinate cartesiane è possibile effettuare una connessione di frame

direttamente nell’istruzione di movimento tramite l’operatore geometrico. In questo modo
si può ad es. inizializzare uno spostamento rispetto al sistema di coordinate base senza
modificare la variabile $BASE.
Lo spostamento di base con l’operatore doppio punto presenta inoltre un

vantaggio decisivo rispetto ad una nuova assegnazione di $BASE:
Lo spostamento avviene nella frase di movimento, mentre un’assegnazione
$BASE deve avvenire prima della frase di movimento. Quindi anche in caso di
arresto di programma e successiva selezione della frase è sempre selezionata
la base giusta per il movimento.
Una nuova assegnazione ripetuta di $BASE come nella seguente sequenza

¼
$BASE = $WORLD
¼
PTP POS_1
$BASE = {X 100,Y -200,Z 1000,A 0, B 180,C 45)
PTP POS_2
¼
porterebbe invece dopo l’interruzione della frase di movimento POS_2 e la riselezione della
frase POS_1 ad un punto di destinazione errato poiché ora verrebbe impiegata la nuova base
anche per la frase di movimento POS_1. La stessa cosa avviene del resto anche già all’arre-
sto della prima frase di movimento se è impostato un relativo processo avanzato del calcola-
tore.
71 di 214

paragrafo [Processo avanzato del calcolatore].
Per questo motivo, se possibile, $BASE e $TOOL dovrebbero essere assegnati

soltanto una volta, ad es. nella parte di inizializzazione del programma. Ulteriori
spostamenti possono poi essere effettuati con l’operatore geometrico.
Ad un TouchUp con il pacchetto base fornito come standard vengono depositati per ogni
punto automaticamente $BASE e $TOOL nella lista dati.
Nel seguente esempio viene eseguito nel secondo comando PTP uno spostamento delle
coordinate del punto di destinazione di 300 mm in direzione X, di --100 mm in direzione Y,
come anche una rotazione di 90° intorno all’asse Z.
DEF FR_VERS ( )

DECL FRAME BASE1 ;Variabile BASE1 del tipo FRAME

HOME={AXIS: A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}
BASE1={FRAME: X 300,Y -100,Z 0,A 90,B 0,C 0}

PTP HOME ; Movimento SAK
; Movimento rispetto al sistema di coordinate $BASE
PTP {POS: X 540,Y 630,Z 1500,A 0,B 90,C 0,S 2,T 35}
; Movimento rispetto al sistema di coordinate $BASE spostato di
BASIS1
PTP BASE1:{POS: X 540,Y 630,Z 1500,A 0,B 90,C 0,S 2,T 35}
PTP HOME
END
In questo esempio, le necessarie assegnazioni delle velocità, accelerazioni e dei

sistemi di coordinate $BASE e $TOOL non vengono inoltre più eseguite “a mano”.
Viene invece usato il pacchetto base presente come standard “BAS.SRC”. A
questo scopo esso dev’essere dapprima reso noto al programma tramite
l’istruzione EXT.
Con l’istruzione di inizializzazione
INI BAS (#INITMOV, 0)
vengono assegnati infine a tutte le variabili di sistema importanti dei valori standard.
Ulteriori informazioni sono contenute nel capitolo [Sottoprogrammi e funzioni] paragrafo

[Dichiarazione].
72 di 214
SAK Prima di poter eseguire un programma dev’essere ottenuta la coincidenza frase (SAK), cioè
la corrispondenza della posizione attuale del robot con la posizione programmata. Siccome
il movimento SAK non rappresenta un movimento programmato e sperimentato, esso
dev’essere effettuato tenendo premuto il tasto start (funzione uomo morto) e con velocità
automaticamente ridotta. Al raggiungimento della traiettoria programmata il movimento
viene arrestato e il programma può essere ripreso azionando nuovamente il tasto start.
Nel modo operativo “Automatico Esterno” non viene effettuato nessun

movimento SAK!
Come prima istruzione di movimento si consiglia quindi un movimento “Home”

durante il quale il robot viene portato in una posizione di partenza chiaramente
definita e non critica nella quale viene poi anche ottenuta la coincidenza frase.
Il robot dovrebbe essere riportato in questa posizione alla fine del programma.
SeT I valori “S” e “T” in un’indicazione POS servono per scegliere tra diverse posizioni robot possi-
bili per la medesima posizione nello spazio (a causa delle singolarità di cinematica) una posi-
zione precisa e definita in modo univoco.
Per la prima istruzione di movimento è quindi, in caso di utilizzo di coordinate cartesiane,
molto importante programmare anche “Status” e “Turn” affinché venga definita una posi-
zione di partenza univoca. Siccome per movimenti lungo la traiettoria (vedi 3.3) “S” e “T” non
vengono considerati, la prima istruzione di movimento di un programma (movimento Home)
dovrebbe essere in ogni caso un’istruzione PTP completa con l’indicazione di “Status” e
“Turn” (o un’istruzione PTP completa con le coordinate degli assi).
Nelle seguenti istruzioni PTP possono essere omesse le indicazioni “S” e “T” se non è neces-
saria una determinata posizione degli assi, ad es. a causa di ostacoli. Il robot mantiene il vec-
chio valore S e sceglie il valore T con il quale risulta il percorso assiale più breve, il quale,
a causa dell’unica programmazione di “S” e “T” nella prima frase PTP, è sempre lo stesso
per i diversi processi di programmazione.
Status e Turn richiedono entrambi dei valori Integer che dovrebbero essere fatti per motivi
pratici in forma binaria.
Turn L’integrazione di una indicazione di posizione cartesiana con il valore Turn consente anche
di poter raggiungere degli angoli assiali maggiori di +180_ oppure minore di --180_ senza una
particolare strategia di traslazione (ad es. punti intermedi). I singoli bit determinano in caso
di assi rotatori il segno del valore degli assi nel modo seguente:
Bit x = 0: Angolo dell’asse x ³ 0_
Bit x = 1: Angolo dell’asse x < 0_
Valore Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0

0 A6 ³ 0_ A5 ³ 0_ A4 ³ 0_ A3 ³ 0_ A2 ³ 0_ A1 ³ 0_
1 A6 < 0_ A5 < 0_ A4 < 0_ A3 < 0_ A2 < 0_ A1 < 0_
Tab. 14 Significato dei bit Turn
L’indicazione T ’B 10011’ significa quindi che gli angoli degli assi 1, 2 e 5 sono negativi, gli
angoli degli assi 3, 4 e 6 invece positivi (tutti i bit 0 di maggior peso possono essere omessi).
Status Con lo Status S vengono gestite delle ambiguità riguardo alla posizione degli assi (vedi
Fig. 18). S dipende dunque dalla relativa cinematica del robot.
73 di 214
Ambiguità
Asse 5
Asse 3
Asse 2
Asse 5
Asse 4 Asse 6
Fig. 18 Esempi per cinematiche robot ambigue
Il significato dei singoli bit è:

Bit 0: Posizione del punto radice del polso (zona base/zona sopratesta)
Bit 1: Configurazione braccio
Bit 2: Configurazione polso
I bit vengono settati per tutti i robot a 6 assi con braccio flessibile secondo la tabella seguente:
Valore Bit 2 Bit 1 Bit 0

0 0_ £ A5 < 180_ A3 < f Zona base
A5 < --180_ (f dipende dal tipo di robot)
1 --180_ £ A5 < 0_ A3 ³ f Zona sopratesta
A5 ³ 180_ (f dipende dal tipo di robot)
Tab. 15 Bit Status per robot a 6 assi con braccio flessibile
Ci si può immaginare la zona base/sopratesta in modo cartesiano. A questo scopo vengono

definiti i seguenti termini:
Punto radice del polso: Punto d’intersezione degli assi del polso
Sistema di coordinate A1: Se l’asse 1 si trova su 0_ esso è identico al sistema di coordi-
nate $ROBROOT. In caso di valori diversi da 0_ viene mosso in-
sieme all’asse 1.
Quindi la zona base/sopratesta può essere definita come segue:
G Se il valore x del punto radice del polso espresso nel sistema di coordinate A1 è positivo,
il robot si trova nella zona base.
G Se il valore x del punto radice del polso espresso nel sistema di coordinate A1 è
negativo, il robot si trova nella zona sopratesta.
74 di 214
Il bit 1 indica la posizione del braccio. Il settaggio del bit dipende dal relativo tipo di robot. In
caso di robot i cui assi 3 e 4 si intersecano vale: il bit 1 ha il valore 0 se l’asse 3 < 0_, altrimenti
il bit 1 = 1. In caso di robot con un offset tra l’asse 3 e 4 (ad es. KR 30, vedi Fig. 19), la posi-
zione angolare nella quale varia il valore del bit 1 dipende dalla dimensione di questo offset.
Offset
Fig. 19 Offset tra l’asse 3 e 4 nel caso di un KR 30

In Fig. 20 vengono rappresentati gli effetti dei bit Status sulla configurazione del robot. Il me-
desimo punto nello spazio è stato raggiunto con quattro diverse posizioni di robot. Nella
prima posizione il robot si trova nella posizione base, l’asse 5 ha un valore di circa 45_, l’asse
3 di circa 80_.
Non è riconoscibile quasi nessuna differenza rispetto alla seconda configurazione del robot.
Soltanto l’asse 4 è stato ruotato di 180_ e gli altri assi l’hanno seguito. Mentre la configura-
zione del braccio è rimasta invariata, è cambiata la configurazione del polso: l’asse 5 ha ora
circa --45_, il bit Status 2 è di conseguenza 1.
Dalla posizione 2 alla 3 cambia la configurazione del braccio. L’asse 3 ruota ad una posizione
angolare di circa --50_, il bit Status 1 assume il valore 0.
Nella quarta posizione il robot si trova infine nella posizione sopratesta. A questo scopo
l’asse 1 è stato ruotato di 180_. Il bit Status 0 diventa 1.
75 di 214
Fig. 20 Effetti dei bit Status sulla posizione del robot
76 di 214
APPUNTI:
77 di 214
3.3 Movimenti lungo la traiettoria (Movimenti CP = Continuous Path)

3.3.1 Velocità ed accelerazione
Al contrario dei movimenti PTP, in caso di movimenti lungo la traiettoria non sono impostate
soltanto la posizione di partenza e quella di destinazione. Viene richiesto addizionalmente
che la punta dell’utensile del robot si muova su una traiettoria lineare o circolare tra questi
punti.
Per questo motivo le velocità ed accelerazioni da indicare ora non si riferiscono più ai singoli
assi ma al movimento del TCP. La punta dell’utensile viene con ciò spostata con una velocità
ben definita. Le velocità e le accelerazioni devono essere programmate per la traslazione,
l’angolo di oscillazione e l’angolo di rotazione. Tab. 16 fornisce una vista d’insieme delle va-
riabili di sistema da programmare e delle loro unità.
Nome Tipo di Unità Funzione

variabile dati
Velocità $VEL.CP REAL m/s Velocità di avanzamento
$VEL.ORI1 REAL °/s Velocità di oscillazione
$VEL.ORI2 REAL °/s Velocità di rotazione
Accelerazioni $ACC.CP REAL m/s@ Accelerazione di
avanzamento
$ACC.ORI1 REAL °/s@ Accelerazione di
oscillazione
$ACC.ORI2 REAL °/s@ Accelerazione di
rotazione
Tab. 16 Variabili di sistema per velocità ed accelerazioni
Almeno uno dei componenti di movimento traslazione, oscillazione e rotazione si muove

in ogni momento durante l’esecuzione del movimento con l’accelerazione o la velocità
programmata. I componenti non dominanti vengono adattati in modo sincrono relativo alla
fase.
Anche alle velocità e alle accelerazioni per i movimenti lungo la traiettoria vengono
assegnati al richiamo della sequenza di inizializzazione del pacchetto base i valori massimi
definiti nei dati macchina o in $CONFIG.DAT.
Inoltre vengono sorvegliate per i movimenti CP la velocità e l’accelerazione dell’asse e in

caso di superamento dei limiti di sorveglianza che sono definiti nelle variabili di sistema
$ACC_ACT_MA e $VEL_ACT_MA viene provocata una reazione di arresto ed emesso un
messaggio di errore. Questi limiti sono come standard il 250% dell’accelerazione nominale
dell’asse (Acceleration) ed il 110% della velocità nominale dell’asse (Velocity). Questi ambiti
di sorveglianza valgono per tutti i modi operativi e per lo spostamento manuale.
Esiste la possibilità di ridurre tramite la variabile di sistema $CP_VEL_TYPE gli avanzamenti
degli assi e con ciò l’accelerazione e la velocità per evitare l’intervento dei limiti di sorve-
glianza (reazione di arresto). Come default la variabile è impostata su #CONSTANT, cioè la
riduzione non è attiva nella modalità programma. Se si desidera abilitare questa funzione,
per il modo operativo T1 occorre settare #VAR_T1 (in T1 vengono usate velocità e accelera-
zioni degli assi minori) e per tutti gli altri modi operativi #VAR_ALL. Nel funzionamento ma-
nuale la riduzione è sempre attiva.
Tramite la variabile di sistema $CPVELREDMELD si ottiene, in entrambi i modi operativi test,
un messaggio se la velocità di avanzamento viene ridotta. A questo scopo dev’essere asse-
gnato “1” alla variabile per un messaggio.
78 di 214
3.3.2 Gestione dell’orientamento

Se durante il movimento lungo la traiettoria l’orientamento dell’utensile nello spazio dev’es-
sere variato, allora il tipo di gestione dell’orientamento può essere impostato tramite la varia-
bile di sistema $ORI_TYPE (vedi Fig. 21):
G $ORI_TYPE = #CONSTANT Durante il movimento lungo la traiettoria l’orienta-

mento rimane costante; per il punto di destinazione
viene ignorato l’orientamento programmato e
viene utilizzato quello del punto di partenza.
G $ORI_TYPE = #VAR Durante il movimento lungo la traiettoria l’orienta-
mento varia continuamente dall’orientamento in-
iziale all’orientamento finale. Questo valore viene
settato anche all’inizializzazione tramite
BAS(#INITMOV,0).
Fig. 21 Cambiamento dell’orientamento in caso di un movimento lineare
79 di 214
In caso di movimenti circolari oltre all’orientamento costante e variabile si può scegliere an-
che tra l’orientamento riferito allo spazio e quello riferito alla traiettoria:
G $CIRC_TYPE = #BASE Orientamento riferito allo spazio durante il movimento

circolare. Questo valore viene settato anche
all’inizializzazione tramite BAS (#INITMOV,0).
G $CIRC_TYPE = #PATH Orientamento riferito alla traiettoria durante il
movimento circolare.
Costante + In caso dell’orientamento riferito alla traiettoria, l’asse longitudinale dell’utensile viene gui-
riferito alla dato relativamente al piano ed alla tangente del cerchio. Questa relazione può essere illu-
traiettoria strata con l’aiuto del cosiddetto treppiede che accompagna la traiettoria (vedi Fig. 22).
Fig. 22 Orientamento costante riferito alla traiettoria in caso di movimenti circolari
Il treppiede accompagnante la traiettoria è composto dal vettore della tangente del cerchio
t, dal vettore normale n e dal vettore binormale b. L’orientamento dell’utensile segue in
Fig. 22 col treppiede accompagnante la traiettoria sul segmento circolare. Riferito al trep-
piede accompagnante la traiettoria, per le posizioni dell’utensile non risulta nessun cambia-
mento dell’orientamento. Ciò è tra l’altro un importante prerequisito per la saldatura ad arco.
Nell’esempio mostrato, l’orientamento dell’utensile relativamente al treppiede accompa-
gnante la traiettoria non viene variato durante il movimento dal punto di partenza al punto
di destinazione ($ORI_TYPE=#CONST).
80 di 214
Variabile + Se si desidera un cambiamento dell’orientamento riferito alla traiettoria tra la posizione di

riferito alla partenza e quella di destinazione ($ORI_TYPE=#VAR), allora questo viene effettuato relati-
traiettoria vamente al treppiede accompagnante la traiettoria tramite la rotazione e l’oscillazione so-
vrapposta (vedi Fig. 23). La gestione dell’orientamento nel treppiede accompagnante la
traiettoria è nel caso di movimenti circolari quindi completamente analoga alla gestione
dell’orientamento nel caso di movimenti lineari.
Fig. 23 Orientamento variabile riferito alla traiettoria in caso di movimenti circolari
81 di 214
Costante + In caso dell’orientamento riferito allo spazio, l’orientamento viene guidato relativamente al
riferito allo sistema base attuale ($BASE).
spazio
L’orientamento riferito allo spazio è adatto particolarmente per applicazioni focalizzate sul
movimento lungo la traiettoria, cioè la punta dell’utensile viene guidata sulla traiettoria circo-
lare, e per applicazioni con poco cambiamento dell’orientamento tra il punto di partenza ed
il punto di destinazione oppure per applicazioni con orientamento esattamente costante nello
spazio (vedi Fig. 24) durante un movimento circolare (ad es. spalmatura di colla con un
ugello di rotazione).
Fig. 24 Orientamento costante riferito allo spazio in caso di movimenti circolari
82 di 214
Variabile + Un cambiamento di orientamento riferito allo spazio ($ORI_TYPE=#VAR) tra la posizione di

riferito allo partenza e la posizione di destinazione viene effettuato tramite la sovrapposizione di movi-
spazio menti oscillatori e rotatori (vedi Fig. 25). In questo caso però relativamente al sistema di coor-
dinate base.
Fig. 25 Orientamento variabile riferito allo spazio in caso di movimenti circolari
In Tab. 17 sono elencate ancora una volta le preimpostazioni delle variabili di sistema per
la gestione dell’orientamento in caso di movimenti lungo la traiettoria:
nel sistema tramite BAS(#INITMOV,0)

$ORI_TYPE #VAR
$CIRC_TYPE #PATH #BASE
Tab. 17 Preimpostazioni di $ORI_TYPE e $CIRC_TYPE
83 di 214
3.3.3 Movimenti lineari
LIN Nel caso di un movimento lineare il KR C... calcola una retta dalla posizione attuale (nel pro-
gramma corrisponde all’ultimo punto programmato) alla posizione indicata nel comando di
movimento.
La programmazione di un movimento lineare avviene tramite le parole chiavi LIN oppure

LIN_REL in combinazione con l’indicazione del punto di destinazione, quindi analogamente
alla programmazione PTP. Per movimenti lineari la posizione di destinazione viene indicata
in modo cartesiano. Sono dunque ammessi soltanto i tipi di dati FRAME o POS.
In caso di movimenti lineari, lo status dell’angolo del punto di destinazione deve

corrispondere a quello del punto di partenza. L’indicazione di Status e Turn in un
punto di destinazione del tipo di dati POS viene quindi ignorata. Per questo motivo
occorre programmare precedentemente alla prima istruzione LIN già un movimento
PTP con l’indicazione completa delle coordinate (ad es. movimento HOME).
L’assegnazione delle variabili di velocità e di accelerazione necessaria per i movimenti lungo

la traiettoria come anche il settaggio dei sistemi di coordinate Tool e Base viene effettuato
nel seguente programma esemplare nuovamente tramite la routine di inizializzazione
BAS.SRC.
DEF LIN_BEW ()

EXT BAS (BAS_COMMAND: IN, REAL: IN)

BAS (#INITMOV, 0) ;inizializzazione di velocità,
HOME = {AXIS: A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}

PTP {A5 30}
; Movimento lineare verso la posizione indicata, l’orientamento

; viene continuamente adattato all’orientamento finale
LIN {X 1030,Y 350,Z 1300,A 160,B 45,C 130}
; Movimento lineare nel piano Y-Z, S e T vengono ignorati

LIN {POS: Y 0,Z 800,A 0,S 2,T 35}
; Movimento lineare verso la posizione indicata, l’orientamento

; non viene variato
$ORI_TYPE=#CONST
LIN {FRAME: X 700,Y -300,Z 1000,A 23,B 230,C -90}
; l’orientamento continua a non essere variato

LIN {FRAME: Z 1200,A 90,B 0,C 0}
; Movimento relativo lungo l’asse X

LIN_REL {FRAME: X 300}
PTP HOME
END
84 di 214
3.3.4 Movimenti circolari

CIRC Per la definizione univoca di un cerchio o di un arco di cerchio nello spazio occorrono 3 punti
che si distinguono tra di loro e che non si trovano su una retta.
Il punto di partenza di un movimento circolare è dato, come per PTP o LIN, dalla posizione
attuale.
Per la programmazione di un movimento circolare con le istruzioni CIRC o CIRC_REL si
deve quindi definire oltre al punto di destinazione anche un punto ausiliario. Durante il calcolo
della traiettoria di movimento da parte del controllo vengono analizzati soltanto i componenti
traslatori (X, Y, Z) del punto ausiliario. L’orientamento della punta dell’utensile varia a se-
CA conda della gestione dell’orientamento continuamente dal punto di partenza al punto di desti-
nazione oppure rimane costante.
Addizionalmente alla posizione ausiliaria e quella di destinazione può anche essere

programmato un angolo circolare con l’opzione CA (Circular Angle). La geometria dell’arco
di cerchio viene sempre determinata tramite il punto di partenza, il punto ausiliario e quello
di destinazione. La posizione di destinazione sull’arco di cerchio che dev’essere
effettivamente raggiunta viene però stabilita tramite l’angolo circolare programmato. Ciò
è utile particolarmente per una riprogrammazione della posizione di destinazione -- senza
variazione della geometria del cerchio.
L’arco di cerchio da percorrere può essere allungato oppure accorciato conformemente
all’angolo circolare. L’orientamento di destinazione programmato viene poi raggiunto nel
punto di destinazione effettivo. Tramite il segno dell’angolo circolare può essere stabilito il
senso di rotazione, cioè la direzione nella quale l’arco di cerchio viene percorso (vedi
Fig. 26):
CA > 0_ nel senso programmato (Punto di partenza ® Punto ausiliario ®
Punto di destinazione)
CA < 0_ contro il senso programmato (Punto di partenza ®
Punto di destinazione ® Punto ausiliario)
Il valore dell’angolo circolare non è limitato. Soprattutto è possibile anche programmare dei
cerchi interi (> 360_).
CA > 0° CA < 0°
Punto di destinazione effettivo
Punto ausiliario
´
Punto ausiliario
´ Punto di
destinazione
programmato
CA = 235°
´ Punto di destinazione
programmato ´
Punto di destinazione
effettivo
CA = --235°
Punto di partenza Punto di partenza
Fig. 26 Effetto dell’opzione CA nel comando CIRC oppure CIRC_REL

Le indicazioni relative per la posizione ausiliaria e quella di destinazione (CIRC_REL) si riferi-
scono sempre alla posizione di partenza. Le indicazioni di posizione specifiche per asse non
sono ammesse come nel caso di movimenti LIN. Inoltre devono essere completamente as-
segnati $BASE e $TOOL prima dell’esecuzione di un movimento circolare.
85 di 214
DEF CIRC_BEW ( )

DECL AXIS HOME

HOME={AXIS: A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}

PTP {POS: X 980,Y -238,Z 718,A 133,B 66,C 146,S 6,T 50}
; orientamento variabile riferito allo spazio (preimpostazione)

CIRC {X 925,Y -285,Z 718},{X 867,Y -192,Z 718,A 155,B 75,C 160}
; orientamento costante riferito allo spazio

; punto di destinazione determinato tramite indicazione dell’an-
golo
$ORI_TYPE=#CONST
CIRC {X 982,Y -221,Z 718,A 50,B 60,C 0},{X 1061,Y -118,Z 718,
A -162,B 60,C 177}, CA 300.0
; orientamento costante riferito alla traiettoria

; punto di destinazione tramite indicazione dell’angolo (indietro)
$CIRC_TYPE=#PATH
CIRC {X 867,Y -192,Z 718},{X 982,Y -221,Z 718,A 0}, CA -150
$ORI_TYPE=#VAR
LIN {A 100} ; riorientamento del TCP
; orientamento variabile riferito alla traiettoria

CIRC {X 963.08,Y -85.39,Z 718},{X 892.05,Y 67.25,Z 718.01,
A 97.34,B 57.07,C 151.11}
; movimento circolare relativo

CIRC_REL {X -50,Y 50},{X 0,Y 100}
PTP HOME
END
86 di 214
3.4 Processo avanzato del calcolatore

Una caratteristica di prestazione fondamentale di un robot industriale è la velocità con la
quale esso è in grado di effettuare i suoi lavori. Oltre alla dinamica del robot è di importanza
decisiva anche l’efficienza dell’esecuzione del programma utente che è composto oltre dai
movimenti anche da istruzioni aritmetiche ed istruzioni che comandano la periferia.
Una più veloce esecuzione del programma può essere ottenuta
G tramite la riduzione della durata del movimento e
G tramite la riduzione del tempo di inattività tra i movimenti.
Nel caso di condizioni marginali prestabilite, come velocità ed accelerazioni assiali massime,
il primo punto può essere ottenuto tramite l’approssimazione temporalmente ottimale di mo-
vimenti.

paragrafo [Movimenti approssimati].
Il tempo di inattività tra i movimenti può essere ridotto elaborando le complesse istruzioni
aritmetiche e logiche tra le frasi di movimento durante il movimento del robot, cioè elaboran-
dole in un processo avanzato (le istruzioni “anticipano” il movimento).
$ADVANCE Tramite la variabile di sistema $ADVANCE è possibile stabilire un massimo di frasi di movi-
mento che il processo avanzato deve anticipare rispetto al processo principale (cioè la frase
di movimento attualmente in esecuzione). Il puntatore principale visibile sull’interfaccia gra-
fica durante l’esecuzione del programma mostra sempre la frase di movimento che viene
attualmente eseguita.
Il puntatore avanzato invece non è visibile e può indicare sia delle istruzioni che vengono
elaborate completamente dal controllo, sia delle frasi di movimento che vengono soltanto
preparate dal controllo ed eseguite in un secondo tempo nel processo principale (vedi
Fig. 27).
Puntatore principale
Il puntatore avanzato si trova in questa

posizione; $ADVANCE = 1
Fig. 27 Puntatore principale e puntatore avanzato
87 di 214
Nella parte di programma sopra indicata, il processo avanzato è settato su 1 ed il puntatore

principale si trova nella riga 16 (cioè il movimento LIN viene eseguito in questo momento).
Un processo avanzato del calcolatore di 1 significa che le istruzioni dalla riga 16 fino alla riga
22 sono già state completamente elaborate parallelamente all’esecuzione del movimento e
che i dati di movimento per i movimenti PTP nella riga 24 sono in fase di preparazione.
Per rendere possibile l’approssimazione dev’essere impostato un processo avanzato del

calcolatore di almeno 1. (La variabile $ADVANCE ha come standard il valore “3”. Come
massimo sono possibili 5 passi di processo avanzato.)
In un sottoprogramma interrupt non è possibile nessun processo avanzato del calcolatore.
Il controllo esegue i programmi interrupt sempre riga per riga e per questo motivo in questi
programmi l’approssimazione non è possibile.
Le preimpostazioni di $ADVANCE:
nel sistema tramite BAS (#INITMOV, 0)

$ADVANCE 0 3
Arresto Istruzioni e dati che hanno influenza sulle periferiche (ad es. istruzioni di entrata
automatico
del processo e di uscita) o che si riferiscono allo stato attuale del robot provocano un arresto
avanzato del processo avanzato (vedi Tab. 18). Ciò è necessario per assicurare la cor-
retta sequenza temporale delle istruzioni e dei movimenti del robot.
Istruzioni ANOUT ON ANOUT OFF

ANIN ON ANIN OFF
DIGIN ON DIGIN OFF
PULSE
HALT WAIT
CREAD CWRITE COPEN CCLOSE
SREAD SWRITE
Combinazione CP-PTP senza approssimazione
Istruzioni in END (se nel modulo è stato definito un interrupt non globale)
connessione
INTERRUPT DECL (se l’interrupt è già stato dichiarato)
con un inter-
rupt RESUME senza BRAKE
Variabili di si- $ANOUT[Nr] $ANIN[Nr]
stema in uso
$DIGIN1 $DIGIN2 ¼ $DIGIN6
$OUT[Nr] $IN[Nr]
$AXIS_ACT $AXIS_BACK $AXIS_FOR $AXIS_RET
$POS_ACT $POS_BACK $POS_FOR $POS_RET
$AXIS_INC $AXIS_INT $POS_ACT_MES $POS_INT
$TORQUE_AXIS $ASYNC_AXIS
$TECH[X].MODE, $TECH[X].CLASS in caso di determinate
operazioni
$LOAD, $LOAD_A1, $LOAD_A2, $LOAD_A3 (se si tratta di un
robot con precisione assoluta e variazione del carico)
88 di 214
Altre variabili di $ALARM_STOP $AXIS_ACTMOD $INHOME_POS $ON_PATH

sistema $EM_STOP $EXTSTARTTYP $REVO_NUM $SAFETY_SW
$ACT_TOOL $PAL_MODE $ACT_BASE $ACT_EX_AX
$OV_PRO $WORKSPACE $IBUS_OFF $IBUS_ON
$ASYNC_EX_AX
_DECOUPLE
Variabili tutte,
importate all’accesso
Altro Se tra frasi con approssimazione avviene un cambio filtro, viene
provocato un arresto del processo avanzato.
Tab. 18 Istruzioni e variabili che provocano un arresto automatico del processo avanzato
CONTINUE In casi di applicazione dove dev’essere impedito questo arresto del processo avanzato oc-
corre programmare direttamente prima della relativa istruzione il comando CONTINUE. Il
controllo in questo caso prosegue con il processo avanzato. L’effetto è però limitato soltanto
alla prossima riga di programma (anche una riga vuota !!).
Se invece si desidera arrestare il processo avanzato in un certo punto senza dover a

questo scopo modificare la variabile di sistema $ADVANCE, si può ricorrere ad un piccolo
accorgimento: è sufficiente programmare in questo punto un tempo di attesa di 0 secondi.
L’istruzione WAIT provoca un arresto automatico del processo avanzato, ha però nessun
altro effetto:
WAIT SEC 0
Ulteriori informazioni sono contenute nel capitolo [Controllo dell’esecuzione del

programma] paragrafo [Tempi di attesa].
APPUNTI:
89 di 214
3.5 Movimenti approssimati

Per aumentare la velocità è possibile l’approssimazione di punti che non devono essere rag-
giunti precisamente. Il robot accorcia il percorso come illustrato nella Fig. 28.
Profilo di Il profilo di approssimazione viene generato automaticamente dal controllo. Il programma-
approssima- tore può influenzare soltanto l’inizio e la fine dell’approssimazione. Per il calcolo della frase
zione di approssimazione il controllo necessita dei dati del punto di partenza, del punto di approssi-
mazione e del punto di destinazione.
Per rendere possibile l’approssimazione, il processo avanzato del calcolatore

($ADVANCE) dev’essere impostato almeno su 1. Se il processo avanzato del
calcolatore è troppo piccolo appare il messaggio “Approssimazione non possi-
bile” e i punti vengono raggiunti precisamente.
Se dopo un’istruzione di approssimazione viene programmata un’istruzione che provoca un
arresto automatico del processo avanzato (vedi Tab. 18), l’approssimazione non è possibile.
Ulteriori informazioni sull’istruzione TRIGGER come rimedio sono contenute nel capitolo
[Trigger -- Azioni di commutazione riferite alla traiettoria].
Appros-
simazione
Punto intermedio
Punto di destinazione
Punto di partenza
Fig. 28 Approssimazione di punti intermedi
90 di 214
3.5.1 Approssimazione PTP--PTP

Per l’approssimazione PTP il controllo calcola le distanze assialmente da percorrere
nell’area di approssimazione e programma per ogni asse dei profili di velocità che assicurano
dei passaggi tangenziali dalle frasi singole al profilo di approssimazione.
Inizio di L’approssimazione inizia quando l’ultimo asse (= asse dominante) è inferiore ad un determi-
approssima- nato angolo rispetto al punto di approssimazione. Nei dati macchina è predefinito un angolo
zione per ogni asse:
$APO_DIS_PTP[1] = 90

$APO_DIS_PTP[6] = 90
Nel programma è possibile indicare tramite $APO.CPTP l’inizio dell’approssimazione come
percentuale di questi valori massimi. Ad esempio:
$APO.CPTP = 50
In questo caso viene iniziata l’approssimazione quando il primo asse deve percorrere un an-
golo residuo di 45_ (50% di 90_) fino al punto di approssimazione. Il termine dell’approssima-
zione avviene precisamente quando il primo asse si è spostato di un angolo di 45_ dal punto
di approssimazione.
Þ Più grande è $APO.CPTP, più la traiettoria viene arrotondata.

Generalmente l’approssimazione non può avvenire oltre al centro della frase. In questo caso
il sistema effettuerà autonomamente una limitazione al centro della frase.
C_PTP L’approssimazione di un punto viene indicata nel comando PTP tramite l’aggiunta della pa-
rola chiave C_PTP:
PTP PUNTO4 C_PTP
Anche la frase di approssimazione PTP viene effettuata in modo temporalmente ottimale,
cioè durante l’approssimazione almeno un asse si muove con il valore limite programmato
per accelerazione o velocità. Contemporaneamente viene assicurato per ogni asse che i mo-
menti dei riduttori e motori ammessi non vengano superati. Il profilo di traslazione superiore
impostato come standard garantisce inoltre un’esecuzione del movimento con velocità ed
accelerazione invariata.

paragrafo [Profilo di traslazione superiore].
Il seguente esempio mostra l’effetto dell’istruzione di approssimazione e della variabile

$APO.CPTP. La traiettoria percorsa è rappresentata in Fig. 29 nel piano XY. Ne risulta parti-
colarmente anche che in caso di movimenti PTP il TCP non viene spostato su una retta tra
i punti di destinazione.
91 di 214
DEF UEBERPTP ( )

DECL AXIS HOME

HOME={AXIS: A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}

PTP {POS:X 1159.08,Y -232.06,Z 716.38,A 171.85,B 67.32,C

162.65,S 2,T 10}
;Approssimazione del punto

PTP {POS:X 1246.93,Y -98.86,Z 715,A 125.1,B 56.75,C 111.66,S 2,T
10} C_PTP
PTP {POS:X 1109.41,Y -0.51,Z 715,A 95.44,B 73.45,C 70.95,S 2,T

10}
;Approssimazione di due punti

$APO.CPTP=20
PTP {POS:X 1296.61,Y 133.41,Z 715,A 150.32,B 55.07,C 130.23,S
2,T 11} C_PTP
PTP {POS:X 988.45,Y 238.53,Z 715,A 114.65,B 50.46,C 84.62,S 2,T
11} C_PTP
PTP {POS:X 1209.5,Y 381.09,Z 715,A -141.91,B 82.41,C -159.41,S

2,T 11}
PTP HOME
END
92 di 214
x=1296,61
y=133,41
x=1246,93
y=--98,86
x=1209,5
y=381,09
x=1159,08
y=--232,06
x=1109,41
y=--0,51
x=988,45
y=238,53
Fig. 29 Esempio per approssimazione PTP--PTP
Siccome la traiettoria di un movimento PTP generalmente né è una retta, né si trova in un

piano spaziale, a rigor di termini non è possibile rappresentarla come in Fig. 29.
Nonostante il fatto che il valore Z di tutti i punti dell’esempio sia uguale, non ogni punto della
traiettoria di movimento si trova nel piano z=715 mm. La traiettoria raffigurata è quindi
soltanto una proiezione della traiettoria effettiva nel piano XY.
93 di 214
3.5.2 Approssimazione LIN--LIN

Per il movimento continuo lungo delle traiettorie complesse è necessario effettuare un’ap-
prossimazione anche tra delle frasi singole lineari. I diversi movimenti di orientamento nelle
frasi LIN devono essere raccordati in modo continuo.
Come profilo di approssimazione il controllo calcola una traiettoria parabolica poiché

questa forma di profilo approssima ottimamente la traiettoria delle frasi singole sfruttando
al massimo le riserve di accelerazione nell’area di approssimazione.
Inizio di Per la determinazione dell’inizio di approssimazione esistono tre variabili predefinite (vedi
approssima- Tab. 19):
zione
Variabile Tipo di Unità Significato Parola chiave
dati nel comando
$APO.CDIS REAL mm Criterio di distanza traslatorio C_DIS
$APO.CORI REAL _ Distanza di orientamento C_ORI
$APO.CVEL INT % Criterio di velocità C_VEL
Tab. 19 Variabili di sistema per la determinazione dell’inizio di approssimazione
Criterio di Alla variabile $APO.CDIS può essere assegnata una distanza traslatoria. Se l’approssima-
distanza zione viene triggerata su questa variabile, allora il controllo abbandona il profilo della frase
singola esattamente quando la distanza fino al punto di destinazione è inferiore al valore in
$APO.CDIS.
Criterio di Alla variabile $APO.CORI può essere assegnata una distanza di orientamento. Il profilo della
orientamento frase singola viene abbandonato in questo caso esattamente quando l’angolo di orienta-
mento dominante (oscillazione o rotazione dell’asse longitudinale dell’utensile) è inferiore
alla distanza stabilita in $APO.CORI fino al punto di approssimazione programmato.
Criterio di Alla variabile $APO.CVEL può essere assegnata una percentuale. Questo valore indica a
velocità quale percentuale della velocità programmata ($VEL) viene iniziato il processo di approssi-
mazione nella fase di frenatura della frase singola. Viene analizzato quel componente di tra-
slazione, oscillazione e rotazione che raggiunge durante il movimento il valore di velocità pro-
grammato oppure si avvicina di più.
Þ Quanto maggiori sono il valori in $APO.CDIS, $APO.CORI o $APO.CVEL

tanto prima viene iniziata l’approssimazione.
All’interno del sistema può essere eventualmente ridotta l’approssimazione
(centro della frase, criterio di simmetria), ma mai aumentata.
C_DIS L’approssimazione viene attivata aggiungendo una della parole chiavi C_DIS, C_ORI o
C_ORI C_VEL all’istruzione LIN oppure LIN_REL.
C_VEL
Per un migliore chiarimento viene riportato il seguente esempio in combinazione con Fig. 30:
94 di 214
DEF UEBERLIN ( )

DECL AXIS HOME

HOME={AXIS: A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}

PTP {POS: X 1159.08,Y -232.06,Z 716.38,A 171.85,B 67.32,C

162.65,S 2,T 10}
;Approssimazione del punto secondo il criterio di distanza

$APO.CDIS=20
LIN {X 1246.93,Y -98.86,Z 715,A 125.1,B 56.75,C 111.66} C_DIS
LIN {X 1109.41,Y -0.51,Z 715,A 95.44,B 73.45,C 70.95}
;Approssimazione di due punti

LIN {X 1296.61,Y 133.41,Z 714.99,A 150.32,B 55.07,C 130.23}
C_ORI
LIN {X 988.45,Y 238.53,Z 714.99,A 114.65,B 50.46,C 84.62} C_VEL
LIN {X 1209.5,Y 381.09,Z 715,A -141.91,B 82.41,C -159.41}
PTP HOME
END
x=1296,61
y=133,41
x=1246,93
y=--98,86
x=1209,5
y=381,09
x=1159,08
y=--232,06
x=1109,41
y=--0,51
x=988,45
y=238,53
Fig. 30 Esempio per approssimazione LIN--LIN
95 di 214
La posizione alla quale il profilo di approssimazione sbocca nella successiva frase LIN
viene calcolata automaticamente dal controllo. Se $ACC e $VEL sono identici per entrambi
le frasi singole e le lunghezze delle frasi sono sufficienti, la parabola di approssimazione
è simmetrica alla bisettrice tra le due frasi singole. In caso di frasi singole brevi, l’inizio
dell’approssimazione viene limitato alla metà della lunghezza frase. La velocità viene
ridotta in modo che un arresto preciso eventualmente successivo possa essere sempre
rispettato.
I passaggi tra le frasi singole ed il profilo di approssimazione sono costanti e avvengono in

modo tangenziale. Ciò consente un passaggio “morbido” che non affatica la meccanica,
poiché i componenti di velocità sono sempre costanti.
Il profilo nell’area di approssimazione generato dal controllo è indipendente da modifiche
dell’override le quali sono ammesse in qualsiasi momento del movimento.
96 di 214
3.5.3 Approssimazione CIRC--CIRC ed approssimazione CIRC--LIN
L’impostazione per l’approssimazione tra frasi CIRC ed altri frasi CP (LIN oppure CIRC) è
quasi identica all’approssimazione tra due frasi LIN. Sia il movimento di orientamento che
il movimento traslatorio devono essere raccordati senza salti di velocità da un profilo di frase
singola nell’altro. L’inizio di approssimazione viene anche in questo caso definito tramite le
variabili $APO.CDIS, $APO.CORI o $APO.CVEL la cui interpretazione viene effettuata in
modo completamente identico alle frasi LIN. L’impostazione del criterio di approssimazione
desiderato avviene anche tramite le parole chiavi C_DIS, C_ORI o C_VEL (vedi 3.5.2).

paragrafo [Approssimazione LIN--LIN].
L’approssimazione CIRC--CIRC viene illustrata tramite un esempio e la traiettoria di movi-

mento raffigurata (vedi Fig. 31):
DEF UEBERCIR ( )

DECL AXIS HOME;---------- Inizializzazione ---------

HOME={AXIS: A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}

PTP {POS: X 980,Y -238,Z 718,A 133,B 66,C 146,S 6,T 50}
; Orientamento variabile riferito allo spazio
; Approssimazione secondo il criterio di distanza
$APO.CDIS=20
CIRC {X 925,Y -285,Z 718},{X 867,Y -192,Z 718,A 155,B 75,C 160}
C_DIS
; Orientamento costante riferito allo spazio

; Punto di destinazione stabilito tramite indicazione dell’angolo
; Nessuna approssimazione possibile a causa dell’arresto del
processo avanzato tramite $OUT
$ORI_TYPE=#CONST
CIRC {X 982,Y -221,Z 718,A 50,B 60,C 0},{X 1061,Y -118,Z 718,A
-162,B 60,C 177}, CA 150 C_ORI
$OUT[3]=TRUE
; Orientamento variabile riferito alla traiettoria

; Approssimazione secondo il criterio di orientamento
$ORI_TYPE=#VAR
$CIRC_TYPE=#PATH
CIRC {X 963.08,Y -85.39,Z 718},{X 892.05,Y 67.25,Z 718.01,A
97.34,B 57.07,C 151.11} C_ORI
97 di 214
; Movimenti circolari relativi
; Approssimazione secondo il criterio di velocità

$APO.CVEL=50
CIRC_REL {X -50,Y 50},{X 0,Y 100} C_VEL
; Approssimazione secondo il criterio di distanza

$APO.CDIS=40
CIRC_REL {X -50,Y 50},{X 0,Y 100} C_DIS
CIRC_REL {X -50,Y 50},{X 0,Y 100}
PTP HOME
END
x=980
y=--238
150_
y=100 y=100 y=100
x=867
y=--192
Fig. 31 Esempio per approssimazione CIRC--CIRC
A causa della richiesta di passaggi tangenziali in caso dell’approssimazione con frasi CIRC
generalmente non è possibile calcolare un profilo di approssimazione simmetrico. La
traiettoria di approssimazione consiste quindi in due segmenti parabolici che si raccordano
in modo tangenziale e che sboccano contemporaneamente in modo tangenziale nelle frasi
singole (vedi Fig. 32).
98 di 214
Appros--
simazione
LIN--CIRC
Fine di approssimazione
Inizio di approssimazione
Fig. 32 Profilo di approssimazione in caso di frasi LIN--CIRC
In caso dell’approssimazione CIRC, l’interpolazione avviene per principio riferita

allo spazio. L’orientamento di partenza è sempre l’orientamento che verrebbe
raggiunto nel punto di approssimazione. Se vengono percorse due frasi di
approssimazione con orientamento riferito alla traiettoria, il riorientamento
nell’area di approssimazione avviene comunque riferito allo spazio.
99 di 214
3.5.4 Approssimazione PTP--traiettoria

Esiste la possibilità dell’approssimazione per frasi di movimento PTP specifiche per asse e
per frasi di movimento di traiettoria cartesiane. Il movimento PTP offre i seguenti vantaggi:
G E’ in linea di massima più veloce di quella cartesiana, soprattutto nelle vicinanze di
posizioni singolari.
G Consente al contrario dell’interpolazione cartesiana un cambio di configurazione, ad es.
un passaggio dalla zona base alla zona sopratesta o un’oscillazione attraverso la
posizione distesa del polso.
La traiettoria precisa di un movimento PTP non è prevedibile poiché il robot sceglie il

percorso più veloce. La traiettoria viene inoltre influenzata lievemente da alcuni fattori
(come ad es. la velocità di avanzamento).
I vantaggi derivanti dall’interpolazione specifica per asse possono però essere sfruttati pie-
namente soltanto se è possibile un passaggio continuo tra frasi specifiche per asse e frasi
cartesiane, perché nel caso di un arresto preciso la maggior parte del tempo guadagnato
altrove viene nuovamente persa.
La programmazione dell’approssimazione di traiettoria PTP avviene in modo completa-
mente analogo ai procedimenti illustrati finora. L’area di approssimazione viene stabilita nel
modo seguente:
Approssimazione PTP ® traiettoria

Approssima- L’inizio dell’approssimazione viene rilevato tramite il criterio PTP $APO.CPTP in maniera
zione PTP ® usuale (vedi 3.5.1). Per la successiva frase di movimento può essere indicato esplicitamente
traiettoria un criterio di approssimazione (C_DIS, C_ORI, C_VEL) che stabilisce l’inizio della frase
CP.
Ciò avviene tramite la sequenza di istruzioni:
PTP PUNTO1 C_PTP C_DIS
LIN PUNTO2
Se nella frase PTP manca un’indicazione per il criterio di approssimazione richiesto nella
frase CP, allora viene usato C_DIS come valore default per il rilevamento dell’inizio della
frase CP.
Il profilo di un’approssimazione PTP--traiettoria oppure traiettoria--PTP è un movimento

PTP. Una determinazione esatta della traiettoria di approssimazione quindi non è possibile.
Esempio:
Se è necessaria una traiettoria precisa, ad es. un movimento CP parallelamente al tavolo,
occorre prestare attenzione con la combinazione CP--PTP durante l’approssimazione
quando questa traiettoria viene abbandonata. Lo stesso vale per un movimento PTP--CP
per accedere a questa traiettoria.
P3
Programma:
CP--PTP
...
LIN P1
LIN P2 C_DIS
PTP P3 P1 P2
...
In questo caso sorge il problema che il movi-
mento di approssimazione non è prevedibile.
Una collisione col tavolo sarebbe possibile.
Tavolo
100 di 214
Per affrontare il problema di cui sopra e per CP--CP--PTP P3

evitare un arresto preciso occorre inserire un
altro movimento CP (P2_HILF).
P2_HILF
Programma:
... P1
LIN P1
LIN P2 C_DIS P2
LIN P2_HILF C_DIS
PTP P3
...
Tavolo
Approssimazione traiettoria ® PTP

Approssima- Per la frase CP vale il criterio di approssimazione programmato, per la frase PTP si ricorre
zione traiet- a $APO.CPTP.
toria®PTP Una sequenza di istruzioni potrebbe essere:
CIRC HILF PUNTO1 C_VEL
PTP PUNTO2
L’approssimazione CP--PTP può essere però garantita soltanto se nessuno degli assi
robot ruota più di 180˚ nella frase della traiettoria e se non cambia lo Status S perché
queste variazioni di posizione non sono prevedibili al momento della programmazione del
profilo di approssimazione. Se un tale cambio di configurazione avviene nella frase della
traiettoria prima dell’approssimazione (variazione di S o T), la frase della traiettoria viene
portata a termine come una frase singola raggiungendo il punto di destinazione
programmato e viene emesso il messaggio errore “Approssimazione CP/PTP non
eseguibile” che può essere resettato. L’utente dovrebbe allora suddividere la frase CP in
diverse frasi singole in modo che la frase singola prima dell’approssimazione CP--PTP sia
sufficientemente breve da poter escludere una variazione di S o T in tutti gli assi del robot.

paragrafo [Comandi di movimento].
Nell’esempio seguente è stata programmata un’approssimazione PTP--LIN, un’approssima-

zione LIN--CIRC e un’approssimazione CIRC--PTP (vedi Fig. 33):
101 di 214
DEF UEBERB_P ( )

DECL AXIS HOME

HOME={AXIS: A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}

PTP {POS: X 1281.55,Y -250.02,Z 716,A 79.11,B 68.13,C 79.73,S
6,T 50}
PTP {POS: X 1209.74,Y -153.44,Z 716,A 79.11,B 68.13,C 79.73,S

6,T 50} C_PTP C_ORI
LIN {X 1037.81,Y -117.83,Z 716,A 79.11,B 68.13,C 79.73}
$APO.CDIS=25
LIN {X 1183.15,Y -52.64,Z 716,A 79.11,B 68.13,C 79.73} C_DIS
CIRC {POS: X 1134,Y 53.63,Z 716},{X 1019.21,Y 124.02,Z 716,A
79.11,B 68.12,C 79.73}
CIRC {POS: X 1087.47,Y 218.67,Z 716},{X 1108.78,Y 267.16,Z 716,A

79.11,B 68.12,C 79.73} C_ORI
PTP {POS: X 1019.31,Y 306.71,Z 716,A 80.8,B 68,C 81.74,S 6,T
59}
PTP HOME
END
CIRC LIN PTP x

(C_ORI) (C_DIS) (_PTP C_ORI)
PTP CIRC LIN x=1281,55
y=--250,02
x=1209,74
y=--153,44
x=1183,15
y=--52,64
x=1108,78 x=1134
y=267,16 y=53,63
HP
x=1087,47
y=218,67
HP
x=1037,81
x=1019,31 x=1019,21 y=--117,83
y=306,71 y=124,02
Fig. 33 Approssimazione PTP--traiettoria e approssimazione traiettoria--traiettoria
102 di 214
3.5.5 Cambio utensile durante l’approssimazione

Questa funzionalità è disponibile per tutte le combinazioni di frasi singole PTP, LIN e CIRC.
E‘ possibile cambiare un utensile in modo virtuale anche durante l’approssimazione, ciò si-
gnifica che un utensile viene acquisito due volte in modo differente. Una pistola ha ad es. una
distanza dal pezzo di 5 cm in “TOOL1” e di 10 cm in “TOOL2”.
Esempio
In questo esempio è richiesto che all’inizio del movimento di approssimazione da P1 a
P2 l’utensile TOOL_DATA1[1] venga sostituito con TOOL_DATA[2].
$TOOL=TOOL_DATA[1]
PTP P0_TOOL1; il punto viene acquisito con l’utensile TOOL_DATA[1]
LIN P1_TOOL1 C_DIS; il punto viene acquisito con l’utensile TOOL_DATA[1]
$TOOL=TOOL_DATA[2]
LIN P2_TOOL2; il punto viene acquisito con l’utensile TOOL_DATA[2]
TOOL2
brida
TOOL1 TOOL1
inizio approssimazione 1
P2_TOOL2
P0_TOOL1 P1_TOOL1
TOOL2
termine approssimazione 2
P1_TOOL2
P0_TOOL2
inizio approssimazione 2
Il cambio utensile avviene in questo esempio durante l’approssimazione, cioè la posizione

cartesiana salta all’inizio della frase intermedia dall’inizio approssimazione 1 all’inizio approssi-
mazione 2; gli angoli degli assi, come anche la posizione cartesiana e la velocità della flangia
vengono mantenuti costanti durante tutto il movimento. Il salto nella posizione TCP carte-
siana viene eliminato soltanto durante il movimento dal termine approssimazione 2 a
P2_TOOL2 in modo che la traiettoria non percorra il collegamento lineare nello spazio da
P1_TOOL1 a P2_TOOL2, ma una parte della traiettoria programmata con arresto preciso per
TOOL2.
103 di 214
3.6 Apprendimento di punti

L’integrazione del procedimento “Teach--In” è una qualità essenziale di un linguaggio di pro-
grammazione robot.
!--carattere Programmare nel KRL semplicemente un carattere ! come tieniposto per le coordinate da
acquisire in un secondo tempo:
PTP !
LIN ! C_DIS
CIRC ! ,CA 135.0
Per quanto riguarda il controllo, le relative coordinate possono essere trasferite nel pro-
gramma tramite il softkey “Touch Up” dopo aver premuto il softkey “Modificare”. Le coordi-
nate attuali vengono scritte direttamente nella struttura selezionata nel codice SRC, ad es.:
PTP {POS:X 145.25,Y 42.46,Z 200.5,A -35.56,B 0.0,C 176.87,S 2,T 2}
LIN {X -23.55,Y 0.0,Z 713.56,A 0.0,B 34.55,C -90.0} C_DIS
CIRC {X -56.5,Y -34.5,Z 45.56,A 35.3,B 0.0,C 90.0},{X 3.5,Y 20.30,
Z 45.56,A 0.0,B 0.0,C 0.0}, CA 135.0
Durante l’apprendimento di coordinate cartesiane viene impiegato sempre il

sistema di coordinate base ($BASE) attualmente valido nel sistema come sistema
di riferimento. Occorre quindi assicurarsi che durante l’apprendimento sia
impostato sempre il sistema di coordinate base che verrà usato per il movimento.
Il KR C... permette ancora un’altra variante di apprendimento: Se viene programmata

un’istruzione di movimento con una variabile che NON è dichiarata nella sezione delle
dichiarazioni, ad es.:
PTP PUNTOSTART
Dopo aver premuto il softkey “Modificare” e “Var” viene richiesto di selezionare la struttura
desiderata. Dopodiché viene dichiarata nella relativa lista dati automaticamente una varia-
bile PUNTOSTART e ad essa vengono assegnate le coordinate attuali rispetto al $BASE at-
tuale, ad es.:
DECL FRAME PUNTOSTART={X 15.2,Y 2.46,Z 20.5,A -35.5,B 9.0,C 16.87}
Se la lista dati non è stata creata appare il relativo messaggio di errore.
Ulteriori informazioni sulle liste dati sono contenute nel capitolo [Liste dati].
Se un’istruzione di movimento è stata creata tramite i moduli inline, i punti acquisiti tramite
il modulo possono essere usati in un secondo tempo anche in un’istruzione di movimento
KRL:
I punti vengono depositati nella relativa lista dati col nome indicato nel modulo e un prefisso
X (quindi per i nomi dei punti nei moduli inline sono ammessi soltanto max. 11 caratteri
invece di 12).
E’ possibile quindi richiamare il punto P7 nel modulo inline
successivamente come XP7 in un’istruzione KRL:

LIN XP7
Anche qui occorre osservare che in entrambi i casi dev’essere usato il medesimo sistema
di coordinate base in modo da raggiungere lo stesso punto!!
104 di 214
3.7 Parametri di movimento (CmdMotionParam)

Questa funzione consente la modifica del tunnel di sorveglianza per la sorveglianza di colli-
sione. In questo modo può essere stabilità la sensibilità per la sorveglianza di collisione.
Dopo il richiamo di questo comando viene aperto il seguente modulo inline:
I valori stabiliti nei dati macchina (“C:\Programmi\KRC\MaDa\Steu\$custom.dat”) vengono

utilizzati come valori default. In alternativa, l’utente può stabilire differenti livelli di sensibilità
per diversi movimenti e processi.
Come alternativa l’utente stesso può stabilire di quanto il momento nominale può divergere
dal momento reale. In caso di superamento il robot viene arrestato.
Esempio
Nel modulo inline è stato stabilito per gli assi A1¼A6 il 50%. Se il momento reale differisce
di più del 50% del momento massimo dal momento nominale calcolato, il robot viene
arrestato e viene emesso un relativo messaggio nella finestra dei messaggi.
MMax
+50% di MMax
Tunnel di sorveglianza
Momento (reale)
effettivo
--50% di MMax
Momento
nominale
0
La sorveglianza non fornisce una garanzia contro il danneggiamento dell’utensile

in caso di collisione, ma riduce i danni.
Ulteriori informazioni per quanto riguarda la sorveglianza di collisione sono contenute nel
Manuale di programmazione nella documentazione [Configurazione] nel capitolo
[Configurazione del sistema esperto].
105 di 214
106 di 214
4 KRL assistent
4 KRL assistent
I pacchetti tecnologici KUKA contengono le funzioni più importanti per abituali applicazioni
di robot. Funzioni speciali che non sono contenute nei pacchetti tecnologici KUKA possono
essere realizzate dall’utente tramite la programmazione diretta del sistema robot in “KRL”,
il “KUKA Robot Language”.
Per rendere possibile la programmazione effettiva di funzioni speciali anche ad utenti che
non utilizzano spesso questo linguaggio di programmazione è stato integrato il “KRL
assistent”.
Il “KRL assistent” offre all’utente la programmazione supportata da sintassi. Dopo la sele-
zione del comando KRL desiderato vengono fornite delle indicazioni di accompagnamento
comando sotto forma di maschere. I contenuti di queste maschere vengono confermati o
modificati. Tutti i contenuti possono sempre essere modificati successivamente.
Comando
Per la programmazione di un comando di movimento occorre selezionare un programma

o caricarlo nell’editor. Delle informazioni dettagliate sulla stesura e la modifica di un
programma sono contenute nel capitolo [Generalità per quanto riguarda i programmi
KRL], paragrafo [Stesura ed editazione di programmi].
Fare attenzione alla posizione del

cursore di editazione. La riga di pro-
gramma creata da Voi sarà inserita
come nuova riga sotto il cursore.
Aprire il menù tramite il tasto menù “Istruzione”. Selezionare “KRL assistent”. Appare la
seguente immagine:
Ultima istruzione
Movimento
Muoviparams
Logica
Uscita analog.
Commento
KRL assistent
Qui è possibile scegliere tra i comandi di movimento proposti.
107 di 214
4.1 Indicazioni di posizione
Il tieniposto “!”
Il segno “!” è un tieniposto. Serve per la stesura di un programma di movimento senza

conoscere la posizione esatta dei punti che determinano più tardi la traiettoria del robot.
All’esecuzione più tardi, il programma viene arrestato su questo punto e si può registrare il
punto come descritto in seguito:
Conferma Se durante l’esecuzione successiva del programma nella finestra dei messaggi
appare “Istruzione non permessa” , cancellare questo messaggio tramite il softkey
“Conferma”.
Istruzione non permessa
Spostare il sistema robot nella posizione desiderata.
Premere ora il softkey “Touch Up”. Osservare l’avviso nella finestra di messaggio.
La registrazione della posizione viene indicata nella finestra di messaggio.
Presa posizione attuale “{POS: X 1620, Y 0, Z, 1910, A 0, B 90, C 0, S 2, T 2}”
Conferma Anche questo messaggio può essere cancellato premendo il softkey “Conferma”.
Indicazione della posizione tramite delle variabili
Invece del tieniposto può essere inserito anche un nome di variabile valido. Una lista delle
parole chiave riservate per KRL che non possono essere utilizzate è contenuta nella
[KRL Reference Guide].
Il sistema robot dovrebbe essere spostato già prima della programmazione di questa
funzione nella posizione desiderata.
Delle informazioni sul movimento manuale del robot sono contenute nel Manuale d’uso
nella documentazione [Operazione], nel capitolo [Spostamento manuale del robot].
Se il nome immesso non dovesse essere ancora conosciuto nel sistema appare il softkey
“VAR” nella barra softkey. Tramite esso viene richiesto di assegnare un formato dati al nome.
Dopo la sua conferma cambia la barra softkey:
108 di 214
4 KRL assistent (segue)
La barra softkey è disponibile soltanto se oltre al file “.SRC” esiste anche una lista dati
“.DAT”.
Dopo aver azionato uno dei softkey “E6POS”, “POS”, “FRAME”, “E6AXIS” o “AXIS”, la
posizione attuale del sistema robot viene registrata nel formato dati selezionato. Ciò viene
confermato tramite un avviso nella finestra di messaggio.
Le coordinate attuali sono registrate nel punto KUKA01
Conferma Questo messaggio può essere cancellato azionando il softkey “Conferma”.
Registrazione della posizione tramite “Touch Up”
Prima di poter registrare in un programma delle posizioni tramite “Touch Up”, al controllo
devono essere comunicati i dati sulla posizione del sistema di coordinate robot valido
nonché i dati dell’utensile e del pezzo valido.
A questo scopo occorre eseguire la sequenza INI all’inizio del programma.
Il sistema robot dovrebbe essere spostato già prima della programmazione di questa
funzione nella posizione desiderata.
Premere il softkey “Touch Up” per registrare la posizione attuale del sistema robot.
La registrazione della posizione viene confermata tramite un avviso nella finestra di

messaggio.
00:01 0 Presa posizione attuale “{POS: X 1620, Y 0, Z, 1910, A 0, B 90, C 0, S 2, T 2}”
Conferma Questo messaggio può essere poi cancellato azionando il softkey “Conferma”.
Indicazione manuale della posizione
Oltre alla possibilità di registrare delle posizioni già raggiunte è possibile anche indicare
manualmente dei punti spaziali.
Premere a questo scopo il softkey “{ ? }” dopo che appare il modulo inline. Cambia l’assegna-
zione della barra softkey:
Dopo aver selezionato un formato dati azionando il relativo softkey, la posizione attuale viene
registrata nel modulo inline.
109 di 214
Tramite le funzioni di editazione queste indicazioni di posizione possono essere modificate

secondo le proprie richieste.
L’Operatore geometrico “:”
Con l’operatore geometrico “:” vengono collegate delle indicazioni di posizione del tipo POS
e FRAME. Ciò è necessario sempre quando dev’essere spostata ad es. l’origine di un sis-
tema di coordinate di un valore correttivo.
Ulteriori informazioni al riguardo sono contenute nel capitolo [Variabili e dichiarazioni],

paragrafo [Manipolazione dei dati] sotto “Operatore geometrico”.
110 di 214
4.2 Posizionamento [PTP]

Il posizionamento del sistema robot avviene in questo caso sul percorso più veloce tra due
punti nella zona di lavoro. Poiché il movimento inizia e finisce contemporaneamente in tutti
gli assi è necessaria la sincronizzazione degli assi. Il percorso del robot non può essere
previsto esattamente.
Utilizzando questo comando non è possibile prevedere esattamente il percorso del

robot. Nelle vicinanze di ostacoli all’interno della zona di lavoro persiste perciò
pericolo di collisione. Il comportamento di traslazione del robot dev’essere
sperimentato nella vicinanza di ostacoli con velocità ridotta!
Tieniposto per indicazione di

posizione
Indietro
Espressioni geometriche per

l’indicazione di posizione,
cartesiano

specifico per asse
posizione
Commutazione tra PTP, LIN e CIRC
Commutazione tra PTP e PTP_REL
Continua Indietro
Approssimazione tra due
movimenti PTP
Approssimazione tra PTP e
LIN o istruzioni CIRC. Criteri:
distanza (DIS), velocità (VEL)
ed orientamento dell’utensile/
pezzo (ORI)
Registrare posizione attuale
111 di 214
Tieniposto per indicazione

di posizione
Indietro

cartesiano

specifico per asse
Commutazione tra PTP_REL e PTP
Continua Indietro
Approssimazione tra due
movimenti PTP
pezzo (ORI)
112 di 214
4.3 Movimento rettilineo [LIN]

Il posizionamento del sistema robot avviene in questo caso sul percorso più breve tra due
punti nella zona di lavoro, su una retta. Gli assi del sistema robot vengono sincronizzati in
modo da mantenere continuamente costante la velocità di avanzamento su questa retta.

di posizione
Indietro

cartesiano

di posizione
Commutazione tra LIN, CIRC e PTP
Commutazione tra LIN e LIN_REL
Continua Indietro

pezzo (ORI)
113 di 214

posizione
Indietro

cartesiano
Commutazione tra
LIN_REL e LIN
Continua Indietro

pezzo (ORI)
114 di 214
4.4 Movimento circolare [CIRC]

Il posizionamento del sistema robot avviene in questo caso lungo una curva nella zona di
lavoro, definita da un punto iniziale, un punto ausiliario e un punto finale. Gli assi del sistema
robot vengono sincronizzati in modo da mantenere continuamente costante la velocità di
avanzamento su questa curva.

posizione
Indietro

cartesiano

di posizione
Commutazione tra CIRC, PTP e LIN
Commutazione tra CIRC e CIRC_REL
Indicazione dell’angolo da percorrere;

priorità maggiore di quella del punto finale
Continua Indietro

pezzo (ORI)
115 di 214

di posizione
Indietro

cartesiano
Commutazione tra CIRC e CIRC_REL
Indicazione dell’angolo da percorrere;

priorità maggiore di quella del punto finale
Continua Indietro

pezzo (ORI)
116 di 214
5 Controllo dell’esecuzione del programma
5 Controllo dell’esecuzione del programma

5.1 Diramazioni di programma
5.1.1 Istruzione di salto
La forma più semplice della diramazione di programma è quella dell’istruzione di salto
incondizionato. Essa viene effettuata in ogni caso senza rispettare una determinata
condizione. Tramite l’istruzione
GOTO GOTO MERKER
il puntatore di programma salta sulla posizione MERKER. La posizione dev’essere però

definita con
MERKER:
in un punto qualsiasi del programma. L’istruzione di salto stessa non permette delle
deduzioni alla struttura di programma creata con essa. Per questo motivo il nome
dell’indicatore di salto dovrebbe essere scelto in modo da rendere più chiara l’azione di salto
provocata. Esiste ad es. una differenza se si scrive
GOTO INDICATORE_1
oppure
GOTO STOPCOLLA
Siccome l’istruzione GOTO conduce velocemente a una pessima strutturazione

dei programmi e a una loro ambiguità, e dato che ogni istruzione GOTO può essere
sostituita da un’altra istruzione di loop si sconsiglia di impiegare eccessivamente
il GOTO.
Un esempio di “GOTO” è contenuto in questo capitolo nel paragrafo [Loop] sotto

“Loop non respingente”.
APPUNTI:
117 di 214
5.1.2 Salto condizionato

IF L’istruzione IF strutturata permette la formulazione di istruzioni condizionate e la scelta tra
due alternative. Nella forma generale l’istruzione è
IF Condizione di esecuzione THEN

Istruzioni
ELSE
Istruzioni
ENDIF
La condizione di esecuzione è un’espressione di Boole. Se la condizione di

esecuzione è soddisfatta, viene eseguito il blocco THEN. Altrimenti è possibile eseguire il
blocco ELSE oppure rinunciare al blocco ELSE. Una rinuncia significa l’immediato
abbandono della diramazione.
E’ ammesso un numero qualsiasi di istruzioni. Le istruzioni possono anche essere ulteriori
istruzioni IF. E’ possibile quindi un intercalamento di blocchi IF. Ogni istruzione IF
dev’essere sempre chiusa con il relativo ENDIF.
Nella seguente sequenza di programma avviene lo spostamento sulla posizione HOME se
l’ingresso 10 si trova su FALSE. Se l’ingresso 10 è settato, dapprima viene settata l’uscita
1 e raggiunto il punto 1 se il valore della variabile A è maggiore di quello di B. Indipendente-
mente da A e B e con ingresso 1 non settato viene in ogni caso aumentata la variabile A di
1 e in seguito raggiunta la posizione HOME:
¼
INT A,B
¼
IF $IN[10]==FALSE THEN
PTP HOME
ELSE
IF A>B THEN
$OUT[1]=TRUE
LIN PUNTO1
ENDIF
A=A+1
PTP HOME
ENDIF
¼
APPUNTI:
118 di 214
5 Controllo dell’esecuzione del programma (segue)
5.1.3 Smistatore
Se esistono più di 2 alternative, la programmazione può avvenire o con una costruzione IF
intercalata o -- in maniera molto più confortevole -- con lo smistatore SWITCH.
SWITCH L’istruzione SWITCH è un’istruzione di selezione per diversi rami di programma. Ad un criterio
di selezione viene assegnato prima dell’istruzione SWITCH un determinato valore. Se questo
Identificativo valore corrisponde ad un identificativo di blocco, allora il relativo ramo di programma viene
dei blocchi eseguito e il programma salta all’istruzione ENDSWITCH senza tener conto dei successivi
identificativi di blocco. Se nessun identificativo di blocco corrisponde al criterio di selezione,
viene eseguito un blocco DEFAULT, se esistente. Altrimenti viene continuato con l’istruzione
che segue l’istruzione ENDSWITCH.
E’ ammesso assegnare ad un ramo di programma più identificativi di blocco. Al contrario non
è opportuno utilizzare più volte un identificativo di blocco poiché viene considerato sempre
soltanto il primo ramo di programma con il relativo identificativo di blocco.
I tipi di dati ammessi del criterio di selezione sono INT, CHAR e ENUM. Il tipo di dati del criterio
di selezione e quello dell’identificativo di blocco devono corrispondere.
L’istruzione DEFAULT può anche mancare, ma dev’essere unica all’interno di un’istruzione
SWITCH.
Tramite l’istruzione SWITCH è ad es. possibile richiamare diversi sottoprogrammi in base ad
un numero di programma. Il numero di programma potrebbe ad esempio essere applicato
dal PLC agli ingressi digitali del KR C... (vedi paragrafo 6.3 per quanto riguarda l’istruzione
SIGNAL). In questo modo è disponibile come criterio di selezione sotto forma di un valore
Integer.
DEF MAIN()
¼
SIGNAL PROG_NR $IN[1] TO $IN[4]
;Il PLC deposita ora il numero di programma
;desiderato nella variabile INT PROG_NR
¼
SWITCH PROG_NR
CASE 1 ;se PROG_NR=1
PARTE_1()
CASE 2 ;se PROG_NR=2
PARTE_2()
PARTE_2A()
CASE 3,4,5 ;se PROG_NR=3, 4 o 5
$OUT[3]=TRUE
PARTE_345()
DEFAULT ;se PROG_NR<>1,2,3,4 o 5
ERROR_UP()
ENDSWITCH
¼
END
Il programma CELL (CELL.SRC) presente come standard nel controllo è strutturato in

modo simile.
119 di 214
5.2 Loop
La prossima struttura di base per il controllo dell’esecuzione del programma sono i loop che
contengono l’esecuzione ripetuta di una o più istruzioni fino al presentarsi di una determinata
condizione. I loop vengono distinti in base alla forma della condizione e alla posizione
dell’interrogazione per la continuazione.
Un salto dall’esterno in una struttura di loop non è ammesso e viene rifiutato dal
controllo (messaggio di errore).
5.2.1 Loop di conteggio

I loop di conteggio vengono eseguiti finché una variabile di conteggio supera o è inferiore
tramite aumento o diminuzione ad un determinato valore finale. Nel KRL a questo scopo è
disponibile l’istruzione FOR. Con
FOR FOR Contatore = Start TO Fine STEP Larghezza di passo

Istruzioni
ENDFOR
è possibile programmare in modo molto chiaro un determinato numero di esecuzioni.

Come valore Start e valore Fine del contatore occorre indicare un’espressione del tipo
Integer. Le espressioni vengono analizzate una volta prima dell’inizio del loop. La variabile
INT Contatore (dev’essere stata dichiarata precedentemente) viene preimpostata col
valore start e aumentata o abbassata dopo ogni esecuzione di loop della larghezza di passo.
La larghezza di passo non dev’essere una variabile e non dev’essere uguale a zero.
Se non viene indicata nessuna larghezza di passo, assume il valore standard 1. Anche dei
valori negativi sono ammessi per la larghezza di passo.
Per ogni istruzione FOR deve esistere un’istruzione ENDFOR. Il programma viene proseguito
dopo la conclusione dell’ultima esecuzione di loop con la prima istruzione dopo ENDFOR.
Il valore del contatore può essere utilizzato sia all’interno che anche all’esterno del loop.
All’interno dei loop serve ad es. come indice attuale per l’elaborazione di campi. Dopo l’uscita
dal loop il contatore presenta il valore assunto per ultimo (quindi Fine+Larghezza di
passo).
Nel seguente esempio vengono settate per prima le velocità degli assi
$VEL_AXIS[1]...$VEL_AXIS[6] su 100%. In seguito vengono inizializzati i componenti di
un campo bidimensionale con i valori calcolati. Il risultato è rappresentato in Tab. 20.
120 di 214
DEF FOR_PROG()
¼
INT I,J
INT CAMPO[10,6]
¼
FOR I=1 TO 6
$VEL_AXIS[I] = 100 ;tutte le velocità degli assi su 100%
ENDFOR
¼
FOR I=1 TO 9 STEP 2
FOR J=6 TO 1 STEP -1
CAMPO[I,J] = I*2 + J*J
CAMPO[I+1,J] = I*2 + I*J
ENDFOR
ENDFOR
;I ha ora il valore 11, J il valore 0
¼
END
Indice I =
1 2 3 4 5 6 7 8 9 10
6 38 8 42 24 46 40 50 56 54 72
5 27 7 31 21 35 35 39 49 43 63
4 18 6 22 18 26 30 30 42 34 54
J =
3 11 5 15 15 19 25 23 35 27 45
2 6 4 10 12 14 20 18 28 22 36
1 3 3 7 9 11 15 15 21 19 27
Tab. 20 Risultato del calcolo dell’esempio 5.2
APPUNTI:
121 di 214
5.2.2 Loop respingente

WHILE Il loop WHILE richiede all’inizio della ripetizione una condizione di esecuzione. E’ un loop
respingente poiché non viene eseguito neanche una volta se la condizione di esecuzione non
è soddisfatta dall’inizio. La sintassi del loop WHILE è:
WHILE Condizione di esecuzione

Istruzioni
ENDWHILE
La condizione di esecuzione è un’espressione logica e può essere una variabile di

Boole, un riferimento a funzione di Boole oppure una operazione logica con un risultato di
Boole.
Il blocco di istruzioni viene eseguito se la condizione logica ha il valore TRUE, cioè se la
condizione di esecuzione è soddisfatta. Se la condizione logica ha il valore FALSE, il
programma viene proseguito con l’istruzione successiva a ENDWHILE. Ogni istruzione
WHILE per questo motivo dev’essere terminata con un’istruzione ENDWHILE.
L’utilizzo di WHILE viene illustrato nell’esempio 5.3.
DEF WHILE_PR()
¼
INT X,W
¼
WHILE $IN[4] == TRUE ;Esecuzione mentre l’ingresso 4 è settato
PTP PALLET
$OUT[2] = TRUE
PTP POS_2
$OUT[2] = FALSE
PTP HOME
ENDWHILE
¼
X = 1
W = 1
WHILE W < 5; ;Esecuzione mentre W è minore di 5
X = X * W
W = W + 1
ENDWHILE
;W ora è 5
¼ ;X ora è 1S2S3S4 = 24
W = 100
WHILE W < 100 ;Esecuzione mentre W è minore di 100
$OUT[15] = TRUE W = W + 1
ENDWHILE
¼ ;Loop non viene mai eseguito, W rimane 100
END
APPUNTI:
122 di 214
5.2.3 Loop non respingente

REPEAT Il contrario del loop WHILE è costituito dal loop REPEAT. In caso di REPEAT viene richiesta
soltanto alla fine del loop una condizione di arresto. Per questo motivo i loop REPEAT
vengono in ogni caso eseguiti una volta anche se la condizione di arresto è già soddisfatta
prima dell’inizio del loop.
REPEAT
Istruzioni
UNTIL Condizione di arresto
La condizione di arresto è analogamente alla condizione di esecuzione del loop

WHILE un’espressione logica che può essere una variabile di Boole, un riferimento a
funzione di Boole oppure una operazione logica con un risultato di Boole:
DEF REPEAT_P()
¼
INT W
¼
REPEAT
PTP PALETTE
$OUT[2]=TRUE
PTP POS_2
$OUT[2]=FALSE
PTP HOME
UNTIL $IN[4] == TRUE ;Esecuzione finché venga settato
l’ingresso 4
¼
X = 1
W = 1
REPEAT
X = X * W
W = W + 1
UNTIL W == 4 ;Esecuzione finché W diventi uguale a 4
;W ora è 4
¼ ;X ora è 1S2S3S4 = 24
W = 100
REPEAT
$OUT[15] = TRUE
W = W + 1
UNTIL W > 100 ;Esecuzione finché W diventi maggiore 100
¼ ;almeno 1 esecuzione di loop, cioè
;W ora è 101, l’uscita 15 è settata
END
123 di 214
Con WHILE e REPEAT si dispone di uno strumento molto potente per la programmazione
strutturata con il quale è possibile sostituire la maggior parte delle istruzioni GOTO.
La sequenza di istruzioni
¼
X = 0
G = 0
MERKER:
X = X + G
G = G + 1
IF G > 100 THEN
GOTO PRONTO
ENDIF
GOTO MERKER:
PRONTO:
¼
può essere realizzata con REPEAT in modo molto più elegante:
¼
X = 0
G = 0
REPEAT
X = X + G
G = G + 1
UNTIL G > 100
¼
APPUNTI:
124 di 214
5.2.4 Loop continuo

LOOP Con l’istruzione LOOP è possibile programmare dei loop continui:
LOOP
Istruzioni
ENDLOOP
L’esecuzione ripetuta di questo blocco di istruzioni può essere terminata soltanto con
l’istruzione EXIT.
Ulteriori informazioni per quanto riguarda l’istruzione Exit sono contenute nel
prossimo paragrafo.
5.2.5 Termine anticipato di esecuzioni di loop

EXIT Con l’istruzione EXIT è possibile terminare ogni loop anticipatamente. Richiamando EXIT
all’interno del blocco di istruzioni del loop, le esecuzioni di loop vengono immediatamente
terminate e il programma viene proseguito dopo l’istruzione di fine loop.
Determinando delle condizioni di arresto o di esecuzione adatte, l’istruzione EXIT spesso
non è necessaria in loop REPEAT o WHILE. Per il loop continuo, EXIT costituisce però l’unica
possibilità per terminare le esecuzioni di loop. Riportiamo in seguito un esempio al riguardo:
DEF EXIT_PRO()
PTP HOME
LOOP ;Start del loop continuo
PTP POS_1
LIN POS_2
IF $IN[1] == TRUE THEN
EXIT ;Arresto, se l’ingresso 1 è settato
ENDIF
CIRC HELP_1,POS_3
PTP POS_4
ENDLOOP ;Fine del loop continuo
PTP HOME
END
APPUNTI:
125 di 214
5.3 Istruzioni di attesa

WAIT Con l’istruzione WAIT è possibile provocare l’arresto del programma fino al presentarsi di una
determinata situazione. Si distingue tra l’attesa fino al presentarsi di un determinato evento
e la determinazione di tempi di attesa.
5.3.1 Attesa fino al presentarsi di un evento

Con l’istruzione
WAIT FOR Condizione
è possibile arrestare l’esecuzione del programma fino al presentarsi dell’evento specificato

con Condizione:
G Se l’espressione logica Condizione è già TRUE al richiamo di WAIT, l’esecuzione del
programma non viene arrestata (ma viene comunque provocato l’arresto del processo
avanzato).
G In caso di Condizione FALSE, l’esecuzione del programma viene arrestata finché
l’espressione assuma il valore TRUE.
Esempi:
WAIT FOR $IN[14] ;attesa finché l’ingresso 14 è TRUE
WAIT FOR BIT_1 == FALSE ;attesa finché la var. BIT_1 = FALSE
Il compilatore non è in grado di riconoscere quando l’espressione, a causa di una

formulazione errata, non può mai assumere il valore TRUE. In questo caso
l’esecuzione del programma viene arrestata continuamente poiché l’interpreter
aspetta una condizione irrealizzabile.
5.3.2 Tempi di attesa

L’istruzione WAIT SEC serve per la programmazione di tempi di attesa in secondi:
WAIT SEC Tempo
Tempo è un’espressione REAL aritmetica con la quale viene indicata la durata in secondi
durante la quale l’esecuzione del programma dev’essere interrotta. Se il valore è negativo
non avviene nessuna attesa.
Esempi:
WAIT SEC 17.542
WAIT SEC TEMPO*4+1
APPUNTI:
126 di 214
5.4 Arresto del programma

HALT Per interrompere l’esecuzione del programma ed arrestare l’elaborazione, programmare
l’istruzione
HALT
L’istruzione di movimento eseguita per ultima viene però ancora completata. L’esecuzione
del programma può essere continuata soltanto premendo il tasto start. In seguito viene
eseguita l’istruzione successiva ad HALT.
Caso speciale:
In una routine di interrupt, l’esecuzione del programma viene arrestata
tramite un’istruzione HALT soltanto dopo l’esecuzione completa del
processo avanzato (vedi paragrafo 8 Interrupt).
Eccezione: Alla programmazione di un istruzione BRAKE avviene immediatamente
l’arresto.
APPUNTI:
127 di 214
5.5 Conferma di messaggi

CONFIRM Con l’istruzione
CONFIRM V_Numero
è possibile confermare i messaggi resettabili sotto controllo di programma. Dopo la conferma

avvenuta con successo, il messaggio specificato col numero di gestione V_Numero non è
più presente.
Dopo l’annullamento di un segnale stop viene ad esempio emesso sempre un messaggio
di conferma. Prima di poter continuare il lavoro esso dev’essere confermato. Il seguente
sottoprogramma riconosce e conferma questo messaggio automaticamente se è
selezionato il modo operativo giusto (non il funzionamento in manuale) e se la condizione
di stop è stata effettivamente eliminata (poiché un programma robot non può essere avviato
se è presente un messaggio di conferma, il sottoprogramma deve trovarsi in un submitfile):
DEF AUTO_QUIT()
INT M
DECL STOPMESS MLD ;tipo di struttura predefinito per
messaggi stop
IF $STOPMESS AND $EXT THEN ;verificare messaggio stop e
modo operativo
M=MBX_REC($STOPMB_ID,MLD) ;leggere stato attuale in MLD
IF M==0 THEN ;verificare se conferma può avvenire
IF ((MLD.GRO==2) AND (MLD.STATE==1)) THEN
CONFIRM MLD.CONFNO ;conferma di questo messaggio
ENDIF
ENDIF
ENDIF
END
APPUNTI:
128 di 214
6 Istruzioni di immissione/emissione
6 Istruzioni di immissione/emissione
6.1 Generalità
Il KR C... conosce 1026 ingressi e 1024 uscite. Nell’armadio di controllo standard KUKA sono
disponibili per l’utente sul connettore X11 (modulo MFC) i seguenti ingressi ed uscite:
Ingressi 1 ¼16
Uscite 1 ¼16 (applicabili max. 100 mA; 100% simultaneità)
Uscite 17 ¼20 (applicabili max. 2 A; 100% simultaneità)
Come opzione possono essere progettati ulteriori ingressi/uscite ad es. tramite bus di
campo.
Gli ingressi possono essere letti, le uscite lette e scritte. Si accede ad essi tramite le variabili
di sistema $IN[Nr] oppure $OUT[Nr]. Le uscite non utilizzate possono essere utilizzate
come merker.
Gli ingressi e le uscite del modulo MFC possono essere smistati nel file “IOSYS.INI” in altri
aree.
Per motivi di sicurezza tutte le istruzioni di immissione/emissione e gli accessi alle

variabili di sistema per immissione/emissione provocano un arresto del processo
avanzato.
Accessi a variabili di sistema per l’immissione/emissione non provocano nessun arresto
del processo avanzato se precedute dall’istruzione CONTINUE.

paragrafo [Processo avanzato del calcolatore].
APPUNTI:
129 di 214
6.2 Ingressi/uscite binari

Se gli ingressi/le uscite vengono richiamati singolarmente si parla di ingressi/uscite binari.
Le uscite binarie possono avere soltanto 2 stati: Low oppure High. Per questo motivo
vengono trattate come variabili del tipo BOOL.
Le uscite possono essere settate di conseguenza con le variabili di sistema
$OUT[Nr] = TRUE e possono essere resettate con
$OUT[Nr] = FALSE.
Lo stato di un ingresso $IN[Nr] può essere letto in una variabile di Boole o usato come
espressione logica in istruzioni di esecuzione programma, istruzioni interrupt o istruzioni
trigger.
Ulteriori informazioni sono contenute nel capitolo [Controllo dell’esecuzione del pro-
gramma], capitolo [Trattamento interrupt], capitolo [Trigger -- Azioni di commuta-
zione riferite alla traiettoria].
Le sequenze di istruzioni
BOOL INTERRUTTORE
⋮
INTERRUTTORE = $IN[6]
IF INTERRUTTORE == FALSE THEN
⋮
ENDIF
e
IF $IN[6] == FALSE THEN
⋮
ENDIF
hanno quindi lo stesso significato.
SIGNAL Nel KR C... è inoltre possibile assegnare dei nomi a singoli ingressi o uscite. A questo scopo
serve la dichiarazione di segnale. Essa deve trovarsi come tutte le dichiarazioni nella sezione
delle dichiarazioni del programma. Si può quindi anche programmare
SIGNAL INTERRUTTORE $IN[6]
⋮
IF INTERRUTTORE == FALSE THEN
⋮
ENDIF
La variabile Interruttore viene dichiarata internamente come BOOL.
Gli ingressi e le uscite del sistema possono essere richiamati anche con $IN e $OUT. Le
uscite del sistema sono però protette da scrittura.
L’ingresso 1025 è sempre TRUE, l’ingresso 1026 è sempre FALSE. Questi ingressi
vengono utilizzati ad es. nei dati macchina come variabili “Dummy”. E’ ammesso un utilizzo
multiplo.
130 di 214
6 Istruzioni di immissione/emissione (segue)
Le modalità per settare ingressi/uscite sono illustrate nell’esempio 6.1:
DEF BINSIG ( )
EXT BAS (BAS_COMMAND:IN,REAL:IN )
DECL AXIS HOME
SIGNAL ARRESTO $IN[16]
SIGNAL SINISTRA $OUT[13]
SIGNAL CENTRO $OUT[14]
SIGNAL DESTRA $OUT[15]
HOME={AXIS: A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}

SINISTRA=FALSE
CENTRO=TRUE ;in posizione centrale
DESTRA=FALSE
WHILE ARRESTO==FALSE ;Arresto, se l’ingresso 16 è settato

IF $IN[1] AND NOT SINISTRA THEN ;l’ingresso 1 è settato
PTP {A1 45}
SINISTRA=TRUE ;in posizione sinistra
CENTRO=FALSE
DESTRA=FALSE
ELSE
IF $IN[2] AND NOT CENTRO THEN ;l’ingresso 2 è settato
PTP {A1 0}
SINISTRA=FALSE
CENTRO=TRUE ;in posizione centrale
DESTRA=FALSE
ELSE
IF $IN[3] AND NOT DESTRA THEN ;l’ingresso 3 è settato
PTP {A1 -45}
SINISTRA=FALSE
CENTRO=FALSE
DESTRA=TRUE ;in posizione destra
ENDIF
ENDIF
ENDIF
ENDWHILE
PTP HOME
END
Settando gli ingressi 1, 2 o 3, il robot può essere spostato in tre diverse posizioni. Se il robot
ha raggiunto la posizione desiderata ciò viene indicato tramite il settaggio delle relative uscite
13, 14 o 15.
Poiché queste uscite indicano sempre la posizione attuale del robot, con l’interrogazione
IF $IN[1] AND NOT $OUT[13] THEN

⋮
ENDIF
può essere anche evitato che il robot tenti ad ogni esecuzione del loop While nuovamente
di spostarsi sulla posizione già raggiunta. Il robot si muove quindi soltanto se è settato un
ingresso (cioè istruzione per lo spostamento nella posizione desiderata) e se l’uscita corri-
spondente non è settata (cioè il robot non si trova ancora in questa posizione) (vedi Tab. 21).
Settando l’ingresso 16 viene terminato il loop While e con ciò il programma.
131 di 214
$OUT[Nr]
$IN [Nr] AND NOT $OUT[Nr]
TRUE FALSE
TRUE FALSE TRUE
$IN[Nr]
FALSE FALSE FALSE
Tab. 21 Tavola di verità per un’operazione “AND NOT”
APPUNTI:
132 di 214
6.3 Ingressi/uscite digitali

6.3.1 Dichiarazione di segnali
Con la dichiarazione di segnali è possibile, oltre all’assegnazione di un nome ai singoli
ingressi/uscite, anche un raggruppamento di diversi ingressi o uscite binari in un segnale
digitale. Con l’istruzione
SIGNAL OFF $OUT[10] TO $OUT[20]
possono ad es. essere richiamate come parola 11 bit le uscite da 10 a 20 tramite la variabile
OFF dichiarata internamente come Integer.
L’uscita digitale dichiarata in questo modo può essere descritta tramite ogni possibile
assegnazione Integer alla variabile OFF, ad es.:
OFF = 35
OFF = ’B100011’
OFF = ’H23’
G Gli ingressi e le uscite devono essere indicati nella dichiarazione di segnali in modo
completo e in ordine crescente.
G Possono essere raggruppati in un segnale digitale un massimo di 32 ingressi oppure
uscite.
G Un’uscita può essere contenuta in diverse dichiarazioni di segnale.
Se le uscite da 13 a 15 dell’esempio 6.1 vengono raggruppate in una variabile POSIZIONE,

risulta il seguente programma modificato:
133 di 214
DEF BINSIG_D ( )

EXT BAS (BAS_COMMAND:IN,REAL:IN )
DECL AXIS HOME
SIGNAL ARRESTO $IN[16]
SIGNAL POSIZIONE $OUT[13] TO $OUT[15]

HOME={AXIS: A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}

POSIZIONE=’B010’ ;in posizione centrale
WHILE ARRESTO==FALSE ;Arresto, se l’ingresso 16 è settato
IF $IN[1] AND (POSIZIONE<>’B001’) THEN ;ingresso 1 settato

PTP {A1 45}
POSIZIONE=’B001’ ;in posizione sinistra
ELSE
IF $IN[2] AND (POSIZIONE<>’B010’) THEN ;ingresso 2 settato
PTP {A1 0}
POSIZIONE=’B010’ ;in posizione centrale
ELSE
IF $IN[3] AND (POSIZIONE<>’B100’) THEN;ingresso 3 settato
PTP {A1 -45}
POSIZIONE=’B100’ ;in posizione destra
ENDIF
ENDIF
ENDIF
ENDWHILE
PTP HOME
END
Ulteriori informazioni sono contenute in questo capitolo, paragrafo [Ingressi digitali

predefiniti].
APPUNTI:
134 di 214
6.3.2 Settaggio di uscite nel punto di destinazione

Appena il robot ha raggiunto il punto di destinazione di una frase di movimento è possibile
settare fino a 8 uscite con riferimento al processo principale e senza arresto del processo
avanzato. A questo scopo serve la seguente istruzione:
$OUT_C[uscita] = Espressione booleana
Argomento Tipo di Significato

dati
Uscita INT Espressione aritmetica che stabilisce il numero dell’uscita
da settare. Sono a disposizione le uscite 1 ... 1024
Espressione BOOL Espressione logica che indica se la relativa uscita viene
booleana settata su “TRUE” o “FALSE”
Normalmente possono essere utilizzate le uscite 1 ... 1024. Tramite l‘appropriato settaggio
della variabile “$SET_IO_SIZE” sono disponibili 2048 oppure 4096 uscite.
Quando il puntatore avanzato raggiunge l’istruzione, viene interpretata l’espressione boo-

leana trasformandola in una costante. Al raggiungimento del puntatore principale vengono
poi settate le uscite interpretate.
Un‘assegnazione potrebbe essere ad esempio la seguente:

$OUT_C[TOOL[ex]+WELD[y]] = ((NOT(x==100)) AND (SAFE==TRUE))
Dopo l’interpretazione (puntatore avanzato), l’istruzione all’interno potrebbe essere

la seguente:
$OUT_C[5] = TRUE
In questo modo l’uscita 5 viene settata al raggiungimento del punto di destinazione

(puntatore principale) sul valore “TRUE”.
Al raggiungimento del puntatore principale, l’uscita viene settata sul relativo valore boo-
leano che era valido al momento dell’interpretazione, anche se questo valore nel frattempo
è cambiato.
Un‘istruzione “$OUT_C[x]” non ha, contrariamente a “$OUT[x]”, nessun effetto sul pro-
cesso avanzato del calcolatore.
$OUT_C[x] può essere scritto soltanto, per leggere un’uscita dev’essere utilizzato
“$OUT[x]”.
La selezione di una frase e il reset di un programma provocano la cancellazione di tutte le

assegnazioni “$OUT_C[x]” interpretate, ma non ancora settate.
135 di 214
Esempio PTP, LIN e CIRC

In caso di comandi PTP, LIN e CIRC assoluti e relativi, l’uscita viene settata immediatamente
dopo il relativo comando di movimento:
PTP P1
$OUT_C[10]=TRUE
$OUT_C[11]=FALSE
$OUT_C[12]=TRUE
LIN P2
Se sul punto “P1” avviene un arresto preciso, in quel momento vengono settate le
uscite 10 ... 12 secondo le loro definizioni.
Se il movimento sul punto “P1” avviene invece con approssimazione, le uscite 10 ... 12
vengono settate soltanto quando è stato raggiunto il centro dell’area di approssima-
zione. Se l’approssimazione non è possibile, le uscite vengono settate nel punto “P1”.
Nei modi di esecuzione programma “Single--Step” (MSTEP) e “I--Step” (ISTEP), sul punto
P1 viene effettuato dapprima un arresto del processo avanzato. Le uscite definite vengono
settate soltanto dopo il rilascio e il nuovo azionamento del tasto start.
Anche un movimento di coincidenza frase provoca un arresto del processo avanzato. Sol-
tanto dopo il riavvio del programma, le uscite vengono settate secondo la loro definizione.
Confronto con trigger

Sia con “$OUT_C[x]”, sia con “Trigger” è possibile settare delle uscite con riferimento al pro-
cesso principale e senza arresto del processo avanzato.
$OUT_C[x]:
PTP P1 C_PTP
$OUT_C[5]=TRUE
PTP P2
Trigger:
TRIGGER WHEN DISTANCE=1 DELAY=0 DO $OUT[5]=TRUE
PTP P1 C_PTP
PTP P2
In entrambi i casi l’uscita 5 viene settata quando viene raggiunto il centro dell’area di appros-
simazione di “P1”.
Puntatore principale
Se il puntatore avanzato e quello principale sono identici, cioè se il robot attualmente non
esegue nessuna frase di movimento, l’assegnazione avviene immediatamente al raggiungi-
mento dell’istruzione “$OUT_C[]”.
PTP P1
WAIT FOR $IN[22]==TRUE
$OUT_C[12]=FALSE
PTP P2
Nell’esempio viene provocato un arresto del processo avanzato nella riga “WAIT...”, finché
l‘ingresso 22 è “FALSE”. Appena l’ingresso 22 presenta “TRUE”, l‘uscita 12 viene settata.
136 di 214
Segnale
Un’uscita può essere settata anche tramite una dichiarazione di segnale a 1 bit.
SIGNAL Test $OUT_C[7]
PTP P1
Test = TRUE
PTP P2
Nell’esempio viene settata l’uscita 7 su “TRUE”, appena il puntatore principale ha raggiunto

la frase di movimento “P1”.
“$OUT_C[x]” non è ammesso nelle seguenti condizioni:

G All’interno di programmi interrupt o dichiarazioni interrupt
G In un programma submit
G In connessione con “$CYCFLAG[x]”
G All’interno di un comando trigger
G In connessione con la correzione di variabili
APPUNTI:
137 di 214
6.4 Uscite a impulso

PULSE Con l’istruzione PULSE è possibile settare o resettare delle singole uscite per un determinato
tiempo. L’istruzione
PULSE($OUT[4],TRUE,0.7)
setta ad esempio l’uscita 4 per una durata di 0.7 secondi sul livello High. L’impulso può essere
eseguito parallelamente al programma robot (l’interpreter non viene arrestato).
Invece dell’indicazione diretta dell’uscita con $OUT[Nr] può essere utilizzata anche un
variabile di segnale.
Ulteriori informazioni sono contenute in questo capitolo, paragrafo [Ingressi/uscite

binari].
Le durate di impulso che possono essere realizzate sono da 0.012 fino a 231 secondi. La
matrice è di 0.1 secondi. Il controllo arrotonda tutti i valori a un decimo.
G Si può programmare contemporaneamente un massimo di 16 uscite a impulso.

G Possono essere programmati sia impulsi High che impulsi Low.
G In caso di “RESET programma” oppure “Abbandonare programma”, l’impulso viene
interrotto.
G Un impulso presente può essere influenzato da degli interrupt.
G Le uscite di impulso possono essere programmate anche sul livello del controllo.
G L’istruzione PULSE provoca un arresto del processo avanzato. Soltanto
nell’istruzione TRIGGER viene eseguita in modo che accompagni la traiettoria.
Un impulso NON viene interrotto in caso di

G EMERGENZA, stop comando o stop errore,
G raggiungimento della fine del programma (istruzione END),
G rilascio del tasto start, se l’impulso è stato programmato prima della prima
istruzione di movimento e se il robot non ha ancora raggiunto la coincidenza
frase.
138 di 214
Nel prossimo programma sono contenuti alcuni esempi per quanto riguarda l’applicazione
dell’istruzione PULSE:
DEF PULSIG ( )

DECL AXIS HOME
INT I
SIGNAL OTTO $OUT[13]

HOME={AXIS: A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}
FOR I=1 TO 16
$OUT[I]=FALSE ;settare tutte le uscite su LOW
ENDFOR

PULSE ($OUT[1],TRUE,2.1) ;impulso viene direttamente per 2.1s
OTTO=TRUE ;settare l’uscita 13 su TRUE

PTP {A3 45,A5 30}
PULSE (OTTO,FALSE,1.7) ;impulso LOW per 1.7s sull’uscita 13
;impulso soltanto dopo movimento
WAIT SEC 2
FOR I=1 TO 4
PULSE ($OUT[I],TRUE,1) ;di seguito le uscite 1-4
WAIT SEC 1 ;per 1s su High
ENDFOR
;applicazione riferita alla traiettoria di un impulso

TRIGGER WHEN DISTANCE=0 DELAY=50 DO PULSE ($OUT[8],TRUE,1.8)
LIN {X 1391,Y -319,Z 1138,A -33,B -28,C -157}
PTP HOME
CONTINUE ;impedire arresto del processo
;avanzato per l’uscita 15
PULSE ($OUT[15],TRUE,3) ;impulso viene direttamente (nel
;processo avanzato)
;sull’uscita 16
PULSE ($OUT[16],TRUE,3) ;impulso soltanto dopo movimento HOME
END ;e rimane ancora dopo END
Osservare in questi esempi attentamente a partire da quando gli impulsi programmati sono
presenti sulle uscite: in linea di massima l’istruzione PULSE porta sempre ad un arresto del
processo avanzato del calcolatore. L’impulso è dunque presente soltanto dopo il termine del
movimento.
Esistono due modi per evitare l’arresto del processo avanzato:
G Programmazione di un’istruzione CONTINUE direttamente prima dell’istruzione PULSE
G Utilizzo dell’istruzione PULSE in un’istruzione TRIGGER (azione di commutazione riferita
alla traiettoria)

paragrafo [Processo avanzato del calcolatore] (CONTINUE) e capitolo [Trigger –
Azioni di commutazione riferite alla traiettoria] (TRIGGER)
139 di 214
6.5 Ingressi/uscite analogici

Oltre agli ingressi/uscite binari, il KR C... riconosce anche ingressi/uscite analogici. Tramite
dei sistemi bus opzionali, il KR C... mette a disposizione 8 ingressi analogici e 16 uscite
analogiche. Le uscite possono essere lette o scritte con le variabili di sistema
$ANOUT[1]...$ANOUT[16], gli ingressi possono essere soltanto letti con le variabili
$ANIN[1]...$ANIN[8].
ANIN Gli ingressi e le uscite analogici possono essere richiamati sia in modo statico che anche
ANOUT dinamico, cioè tramite l’interrogazione continua al ciclo di interpolazione (attualmente
12 ms). Mentre la lettura e la scrittura statica avviene come nel caso dei segnali binari tramite
la semplice assegnazione di valori, per l’elaborazione ciclica si usano le istruzioni speciali
ANIN ed ANOUT.
6.5.1 Uscite analogiche

I valori di emissione per le 16 uscite analogiche del KR C... si trovano tra --1.0 ¼ +1.0 e sono
normalizzati sulla tensione di uscita di ±10.0 V. Se il valore di emissione supera i limiti ±1.0,
il valore viene tagliato.
Per settare un canale analogico occorre semplicemente assegnare un valore alla relativa
variabile $ANOUT:
$ANOUT[2] = 0.5 ;il canale analogico 2 viene settato su +5V
oppure
REAL V_COLLA
⋮
V_COLLA = -0.9
$ANOUT[15] = V_COLLA ;il canale analogico 15 viene settato su -9V
Queste assegnazioni sono statiche poiché il valore del canale alimentato cambia soltanto
quando alla relativa variabile di sistema $ANOUT[Nr] viene assegnato in modo esplicito un
nuovo valore.
Spesso però è opportuno che una determinata uscita analogica venga ricalcolata continua-
mente durante l’esecuzione del programma all’interno di un determinato tempo ciclo. Questa
emissione analogica dinamica avviene con l’istruzione ANOUT. Con l’istruzione
ANOUT ON FILO = 0.8 * V_FILO
è possibile ad es. modificare l’uscita analogica specificata con la variabile di segnale FILO
tramite una semplice assegnazione di valore alla variabile V_FILO. La tensione sulla relativa
uscita segue quindi la variabile V_FILO.
La variabile FILO dev’essere naturalmente dichiarata prima tramite la dichiarazione
SIGNAL, ad es.:
SIGNAL FILO $ANOUT[2]
Con
ANOUT OFF FILO
l’emissione analogica ciclica viene terminata.
L’espressione aggiornata in modo ciclico che dev’essere indicata per il calcolo del valore di
emissione analogico non deve superare una certa complessità. La sintassi ammessa è
quindi limitata ed orientata alla tecnologia. La sintassi completa è
ANOUT ON ANOUT ON Nome segnale = Fattore * Elemento di regolazione
á± Offsetñ áDELAY=tñ áMINIMUM=U2ñ áMAXIMUM=U2ñ
per l’avvio dell’emissione analogica ciclica oppure
ANOUT OFF ANOUT OFF Nome segnale
per terminarla. Il significato dei singoli argomenti è riportato in Tab. 22
140 di 214

dati
Nome REAL Variabile di segnale che specifica l’uscita analogica
segnale (dev’essere dichiarata come SIGNAL). L’indicazione
diretta di $ANOUT[Nr] non è ammessa.
Fattore REAL Fattore qualsiasi che può essere una variabile, un nome
di segnale oppure una costante.
Elemento di REAL Tramite l’elemento di regolazione l’uscita analogica viene
regolazione influenzata. Può essere una variabile o un nome di
segnale.
Offset REAL Come opzione può essere programmato un offset per
l’elemento di regolazione. L’offset dev’essere una
costante.
t REAL Tramite la parola chiave DELAY e un’indicazione di tempo
positiva o negativa in secondi è possibile come opzione
emettere il segnale di uscita calcolato ciclicamente in
modo ritardato (+) oppure anticipato (--).
U1 REAL La parola chiave MINIMUM stabilisce la tensione minima
presente sull’uscita. I valori ammessi sono compresi tra
--1.0 ... 1.0 (che corrisponde a --10V ... +10V). Il valore mi-
nimo dev’essere minore del valore massimo se vengono
utilizzati entrambi i valori.
Come valore sono ammessi anche una variabile,
una componente strutturale o un elemento array.
U2 REAL La parola chiave MAXIMUM stabilisce la tensione massima
presente sull’uscita. I valori ammessi sono compresi tra
--1.0 ... 1.0 (che corrisponde a --10V ... +10V). Il valore
massimo dev’essere maggiore del valore minimo se ven-
gono utilizzati entrambi i valori.
Come valore sono ammessi anche una variabile,
una componente strutturale o un elemento array.
Tab. 22 Argomenti nell’istruzione ANOUT
I parametri opzionali “Minimum” e “Maximum” non sono disponibili nei moduli Inline poiché
vengono utilizzati esclusivamente per la tecnologia “Applicazione di colla”.
141 di 214
In questo esempio è stato definito sia un valore minimo che un valore massimo. Le relative
impostazioni sono “MINIMUM=0.3” e “MAXIMUM=0.95”.
10 000
Maximum
Tensione analogica [mV]
8 000
UFilo [mV]
6 000
4 000
Minimum
2 000
UStandard [mV]
0 100 200 300 400 500
Velocità di avanzamento [mm/s]
Fig. 34 Tensione analogica in base alla velocità di avanzamento
APPUNTI:
142 di 214
6.5.2 Ingressi analogici

Gli 8 ingressi analogici del KR C... possono essere letti tramite le variabili $ANIN[1] fino a
$ANIN[8] per mezzo di una semplice assegnazione di valore ad una variabile REAL:
REAL PEZZO
⋮
PEZZO = $ANIN[3]
oppure
SIGNAL SENSORE3 $ANIN[3]
REAL PEZZO
⋮
PEZZO = SENSORE3
I valori in $ANIN[Nr] variano tra +1.0 e --1.0 e rappresentano una tensione di entrata da
+10V fino a --10V.
ANIN Per la lettura ciclica di ingressi analogici serve l’istruzione ANIN. Tramite essa è possibile
leggere contemporaneamente fino a 3 ingressi analogici. La lettura avviene nel ciclo di inter-
polazione.
Con la sequenza di istruzioni
SIGNAL SENSORE3 $ANIN[3]
REAL PEZZO
⋮
ANIN ON PEZZO = 1 * SENSOR3
è possibile quindi leggere in modo ciclico l’ingresso analogico 3, e con l’istruzione
ANIN OFF SENSOR3
la lettura può essere terminata.
Occorre osservare che contemporaneamente possono essere attive max. 3 istruzioni

ANIN ON. E’ ammesso accedere in entrambe le istruzioni alla medesima interfaccia
analogica o descrivere la medesima variabile.
La sintassi completa per la lettura ciclica di un ingresso analogico è:
ANIN ON ANIN ON Valore = Fattore * Nome segnale á± Offsetñ
Il termine della sorveglianza ciclica viene iniziato con

ANIN OFF ANIN OFF Nome segnale
Il significato degli argomenti è riportato in Tab. 23.

dati
Valore REAL Il Valore può essere una variabile o un nome di segnale
(di uscita). In Valore viene depositato il risultato della
lettura ciclica.
Nome REAL Variabile di segnale che specifica l’ingresso analogico
segnale (dev’essere dichiarata come SIGNAL). L’indicazione
diretta di $ANIN[Nr] non è ammessa.
Fattore REAL Fattore qualsiasi che può essere una variabile, un nome di
segnale oppure una costante.
Offset REAL Come opzione può essere programmato un offset. L’offset
può essere una costante, una variabile o un nome di
segnale.
Tab. 23 Argomenti nell’istruzione ANIN
143 di 214
Nel seguente esempio sono illustrate le istruzioni per l’immissione e l’emissione analogica.
Tramite la variabile di sistema $TECHIN[1] ed un sensore che segue la traiettoria e che è
collegato ad un ingresso analogico è ad es. possibile effettuare una correzione della
traiettoria durante il movimento. La variabile $VEL_ACT che contiene sempre la velocità di
avanzamento attuale può essere utilizzata, ponderata con i relativi fattori, per un’emissione
analogica proporzionale alla velocità, quindi ad es. per comandare la quantità di colla durante
la spalmatura.
DEF ANSIG ( )

DECL AXIS HOME
INT I
SIGNAL COLLA $ANOUT[1] ;apertura ugello per colla
SIGNAL CORREZIONE $ANIN[5] ;sensore che segue la traiettoria

HOME={AXIS: A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}
FOR I=1 TO 16
$ANOUT[I]=0 ;settare tutte le uscite su 0V
ENDFOR

PTP HOME ;movimento SAK
$ANOUT[3] = 0.7 ;uscita analogica 3 su 7V
IF $ANIN[1] >= 0 THEN ;applicazione di colla soltanto, se

;l’ingresso analogico 1
;ha tensione positiva
PTP POS1
;correzione della traiettoria secondo il segnale sensore con

;l’aiuto della variabile di sistema $TECHIN
ANIN ON $TECHIN[1] = 1 * CORREZIONE + 0.1
;emissione analogica proporzionale alla velocità

;variabile di sistema $VEL_ACT contiene la velocità di
;avanzamento attuale
ANOUT ON COLLA = 0.5 * $VEL_ACT + 0.2 DELAY = -0.12
LIN POS2
CIRC POSAUSILIA,POS3
ANOUT OFF COLLA
ANIN OFF CORREZIONE
PTP POS4
ENDIF
PTP HOME
END
144 di 214
6.6 Ingressi digitali predefiniti

Il controllo mette a disposizione 6 ingressi digitali che possono essere letti tramite le variabili
di segnale $DIGIN1...$DIGIN6. Gli ingressi fanno parte dei normali ingressi utente. Pos-
sono avere una lunghezza di 32 bit e un’uscita strobe corrispondente.
La progettazione degli ingressi digitali avviene nei dati macchina: “/mada/steu/$ma-
schine.dat”. Con una dichiarazione di segnale vengono determinate dapprima l’area e
la dimensione dell’ingresso digitale:
SIGNAL $DIGIN3 $IN[1000] TO $IN[1011]
Tramite le altre variabili di sistema $DIGIN1CODE...$DIGIN6CODE, $STROBE1...$STROBE6
e $STROBE1LEV...$STROBE6LEV vengono determinati l’interpretazione del segno, le uscite
strobe corrispondenti e il tipo del segnale strobe:
DECL DIGINCODE $DIGIN3CODE = #UNSIGNED ;senza segno
SIGNAL $STROBE3 $OUT[1000] ;determinare uscita strobe
BOOL $STROBE3LEV = TRUE ;strobe è un impulso high
Un’uscita strobe è un’uscita del KR C... con un determinato impulso che congela il segnale
di un apparecchio esterno (ad es. trasduttore di velocità angolare) per la lettura.
Mentre diversi ingressi digitali possono accedere al medesimo ingresso, i segnali strobe
NON devono descrivere la medesima uscita.
Il range di valori di $DIGIN1...$DIGIN6 dipende dalla lunghezza bit definita e dall’interpreta-

zione del segno (#SIGNED oppure #UNSIGNED):
12 bit con segno (#SIGNED) Range di valori: --2048¼2047
12 bit senza segno (#UNSIGNED) Range di valori: 0¼4095
Gli ingressi digitali possono essere letti o in modo statico tramite una normale assegnazione
di valore:
INT NUMERO
⋮
NUMERO = $DIGIN2
DIGIN oppure in modo ciclico con un’istruzione DIGIN:
INT NUMERO
⋮
DIGIN ON NUMERO = FATTORE * $DIGIN2 + OFFSET
⋮
DIGIN OFF $DIGIN2
Contemporaneamente sono ammesse 6 istruzioni DIGIN ON. Nell’istruzione DIGIN ON è
possibile anche accedere a dei segnali di ingresso analogici (ad es. come FATTORE). La
sintassi è completamente analoga all’istruzione ANIN ON:
DIGIN ON DIGIN ON Valore = Fattore * Nome segnale á± Offsetñ
DIGIN OFF DIGIN OFF Nome segnale
Il significato dei singoli argomenti è descritto in Tab. 24.
145 di 214

dati
Valore REAL Il Valore può essere una variabile o un nome di segnale
(in uscita). In Valore viene depositato il risultato della
lettura ciclica.
Nome REAL Variabile di segnale che specifica l’ingresso digitale. Sono
segnale ammesse soltanto $DIGIN1¼$DIGIN6.
Fattore REAL Fattore qualsiasi che può essere una variabile, un nome di
segnale o una costante.
Offset REAL Come opzione può essere programmato un offset. L’offset
può essere una costante, una variabile o un nome di
segnale.
Tab. 24 Argomenti nell’istruzione DIGIN
APPUNTI:
146 di 214
7 Sottoprogrammi e funzioni
7 Sottoprogrammi e funzioni
Affinché per delle sezioni di programma uguali e ricorrenti possa essere ridotto il lavoro di
scrittura durante la programmazione come anche la lunghezza del programma, sono stati
introdotti dei sottoprogrammi e delle funzioni come costrutti di linguaggio.
Un effetto dei sottoprogrammi e delle funzioni non da sottovalutare in caso di programmi
piuttosto grandi è la riutilizzabilità di algoritmi una volta annotati in altri programmi e in
particolare l’impiego di sottoprogrammi per la strutturazione del programma. Questa
strutturazione può portare ad una struttura gerarchica in modo che dei singoli
sottoprogrammi richiamati da un programma superiore eseguono dei processi parziali in
modo completo e trasmettono i risultati.
7.1 Dichiarazione
Un sottoprogramma o una funzione è una parte di programma a se stante con intestazione
del programma, sezione delle dichiarazioni e sezione delle istruzioni che può essere
richiamata da una posizione qualsiasi nel programma principale. Dopo l’esecuzione del
sottoprogramma o della funzione avviene un ritorno al comando successivo al richiamo del
sottoprogramma (vedi Fig. 35).
Da un sottoprogramma o una funzione possono essere richiamati ulteriori sottoprogrammi
e/o funzioni. La profondità di annidamento ammessa è di 20. Superandola viene emesso il
messaggio di errore “TROPPI PROGRAMMI SELEZIONATI”. Il richiamo ricorsivo di
sottoprogrammi o funzioni non è permesso, cioè un sottoprogramma o una funzione non
possono richiamare sé stessi.
DEF Tutti i sottoprogrammi vengono dichiarati, in modo identico ai programmi principali, con
l’istruzione DEF più il nome e terminati con END, ad es.:
DEF UNTERPR()
¼
END
PROG.SRC
DEF PROG() ;Programma principale

¼
UNTERPR() ;Richiamo sottoprogramma
¼
UNTERPR() ;Richiamo sottoprogramma
¼
END ;Fine programma principale
DEF UNTERPR() ;Sottoprogramma

¼
END ;Fine sottoprogramma
Fig. 35 Richiamo sottoprogramma e ritorno
147 di 214
Una funzione è una specie di sottoprogramma, il nome del programma è però allo stesso
tempo una variabile di un determinato tipo di dati. In questo modo il risultato della funzione
può essere trasferita ad una variabile tramite semplice assegnazione di valore. Durante la
DEFFCT dichiarazione di funzioni con la parola chiave speciale DEFFCT dev’essere indicato quindi
oltre al nome della funzione anche il tipo di dati della funzione. Una funzione viene terminata
con ENDFCT. Poiché una funzione deve trasmettere un valore, questo valore dev’essere
specificato prima dell’istruzione ENDFCT con l’istruzione RETURN. Esempi:
DEFFCT INT FUNZIONE()
¼
RETURN(X)
ENDFCT
Locale Per principio si distingue tra sottoprogrammi o funzioni locali e globali. In caso di
sottoprogrammi o funzioni locali, il programma principale e i sottoprogrammi/funzioni si
trovano nello stesso file SRC. Il file ha il nome del programma principale. Il programma
principale si trova nelle frasi sorgenti sempre al primo posto, mentre i sottoprogrammi e le
funzioni seguono in ordine e numero qualsiasi dopo il programma principale.
Globale Dei sottoprogrammi/funzioni locali possono essere richiamati soltanto all’interno del file SRC
nel quale sono stati creati. Se i richiami di sottoprogrammi/funzioni devono essere possibili
anche da altri programmi, essi devono essere globali, cioè devono essere memorizzati in un
file SRC proprio. Di conseguenza ogni programma è un sottoprogramma se viene richiamato
da un altro programma (programma principale, sottoprogramma o funzione).
G Nei sottoprogrammi oppure nelle funzioni locali sono note tutte le variabili dichiarate
nella lista dati del programma principale. Le variabili dichiarate nel programma
principale (file SCR) sono delle cosiddette “Variabili Runtime” e possono essere
utilizzate soltanto nel programma principale. Il tentativo di utilizzare queste variabili
nel sottoprogramma comporta un relativo messaggio di errore.
In sottoprogrammi o funzioni globali, le variabili dichiarate nel programma principale
non sono note.
G Nel programma principale non sono note le variabili dichiarate in sottoprogrammi o
funzioni.
G Un programma principale non può accedere a sottoprogrammi o funzioni locali di un
altro programma principale.
G Il nome di sottoprogrammi/funzioni locali può essere composto da un max. di 24
caratteri. In caso di sottoprogrammi/funzioni globali il nome dev’essere composto da
un max. di 20 caratteri (a causa delle estensioni).
GLOBAL Affinché il sottoprogramma sia conosciuto al programma principale, il sottoprogramma
dev’essere definito come GLOBAL, ad es.: Global Def PROG_2( ). Se non è definito
come GLOBAL, tutti i nomi e percorsi dei sottoprogrammi esterni e delle funzioni da richia-
mare come anche i parametri utilizzati devono essere resi riconoscibili al compiler tramite
la dichiarazione EXT oppure EXTFCT. Indicando la lista di parametri (vedi 7.2) è determinata
in modo univoco anche lo spazio di memoria necessario. Esempi:
EXT PROG_3()
EXTFCT FUNZIONE(REAL:IN)
Nel caso della stesura di un nuovo programma si lavorerà sempre con GLOBAL. La possibi-
lità di rendere noto un sottoprogramma ad un programma principale con EXT è qui riportato
perché nella versione precedente di KRL ciò era possibile esclusivamente con EXT, cioè
GLOBAL non esisteva.
In Fig. 36 è rappresentata la differenza tra sottoprogrammi o funzioni globali “normali”, glo-

bali “GLOBAL” e locali: PROG è un programma principale, LOCAL è un sottoprogramma lo-
cale e LOCALFUN è una funzione locale del programma principale PROG. PROG_2FUN e
PROG_3 sono una funzione globale “GLOBAL” e un sottoprogramma globale “GLOBAL”.
PROG_1 è un sottoprogramma globale “normale”.
148 di 214
7 Sottoprogrammi e funzioni (segue)
PROG.SRC PROG_1.SRC
DEF PROG() DEF PROG_1()

EXT PROG_1 ¼
¼ END
A=A*LOCALFUN()
LOCAL()
¼
PROG_3() PROG_2FUN.SRC
¼
PROG_1()
¼ GLOBAL DEFFCT INT PROG_2FUN()
END EXT PROG_1()
¼
PROG_1()
DEF LOCAL() ¼
¼ ENDFCT
G=PROG_2FUN()
H=5+LOCALFUN()
¼
END PROG_3.SRC
DEFFCT INT LOCALFUN() GLOBAL DEF PROG_3()

¼ ¼
ENDFCT END
Fig. 36 Differenza tra sottoprogrammi locali, globali e globali “GLOBAL”
In questa figura è riconoscibile che il programma Prog_1 che non è dichiarato come GLOBAL
dev’essere reso noto nel programma principale Prog con EXT. I programmi e le funzioni
Prog_2 e Prog_3 dichiarati come GLOBAL possono essere richiamati invece nel pro-
gramma principale senza EXT.
149 di 214
7.2 Richiamo e passaggio di parametri

Il richiamo di un sottoprogramma avviene semplicemente tramite l’indicazione del nome del
sottoprogramma e parentesi tonde. Ha dunque l’aspetto di un’istruzione (vedi cap. 1.1), ad
es.:
SOTTOPROG1()
Un riferimento a funzione è una forma particolare di un’assegnazione di valore. Una funzione
quindi non può mai trovarsi da sola, ma il valore della funzione dev’essere assegnato sempre
nell’ambito di un’espressione di una variabile dello stesso tipo di dati, ad es.:
INTVAR = 5 * INTFUNZIONE() + 1
REALVAR = REALFUNZIONE()
Nei sottoprogrammi oppure nelle funzioni locali sono note tutte le variabili dichiarate nella
lista dati del programma principale. In sottoprogrammi globali invece queste variabili non
Lista di sono note, tranne nel caso in cui le variabili siano state dichiarate come GLOBAL. Tramite
parametri una lista di parametri possono però essere passati anche dei valori a sottoprogrammi e fun-
zioni globali.
Il passaggio con delle liste di parametri è spesso opportuno anche in sottoprogrammi e
funzioni locali poiché in questo modo può essere fatta una chiara distinzione tra programma
principale e sottoprogramma/funzione: delle variabili dichiarate nel programma principale
(file SRC) vengono utilizzate soltanto lì, tutti i passaggi a sottoprogrammi e funzioni (locali
e globali) avvengono tramite delle liste di parametri. Grazie a questa programmazione
strutturata gli errori di programmazione vengono ridotti notevolmente.
Per il passaggio di parametri esistono due metodi diversi:
G Call by value (IN)
In caso di questo tipo di passaggio viene trasferito un valore dal programma principale
ad una variabile del sottoprogramma o della funzione. Il valore trasferito può essere una
costante, una variabile, un riferimento a funzione oppure un’espressione. Se esistono
diversi tipi di dati viene effettuato un adattamento, se possibile.
G Call by reference (OUT)
Tramite “Call by reference” viene passato soltanto l’indirizzo di una variabile del
programma principale al sottoprogramma oppure alla funzione. Il sottoprogramma
richiamato oppure la funzione può ora sovrascrivere l’area di memoria tramite un
proprio nome di variabile e di conseguenza modificare il valore della variabile nel
programma principale. I tipi di dati devono quindi essere identici, un adattamento del
tipo non è possibile in questo caso.
In Fig. 37 è illustrata la differenza tra questi due metodi. Mentre la variabile X in caso di “Call
by value” rimane invariata nel programma principale a causa delle aree di memoria separate,
in caso di “Call by reference” viene sovrascritta tramite la variabile NUMERO nella funzione.
150 di 214
X Call by value
15 GLOBAL DEFFCT INT QUA-
15 DRATO(NUMERO:IN)
15 NUMERO INT NUMERO
225 NUMERO=NUMERO*NUMERO
225 RETURN(NUMERO)
DEF PROG() ENDFCT
INT X,Y,E
¼
X=5*3
Þ X=15
Y=QUADRATO(X) Y= 225
;Y=225 E=15
E=Y/X
¼
END 15
225
X,NUMERO Call by reference
15
225 GLOBAL DEFFCT INT QUA-

DRATO(NUMERO:OUT)
INT NUMERO
NUMERO=NUMERO*NUMERO
RETURN(NUMERO)
ENDFCT
Þ X=225
Y= 225
E=1
Fig. 37 Differenza tra “Call by value” e “Call by reference”
“Call by value” viene indicato nell’intestazione del sottoprogramma o della funzione tramite
la parola chiave IN dopo ogni variabile nella lista di parametri. “Call by reference” si ottiene
indicando OUT. OUT è anche l’impostazione default. Esempio:
DEF CALCOLA(X:OUT,Y:IN,Z:IN,B)
Se il sottoprogramma globale o la funzione globale da richiamare non sono dichiarati come
GLOBAL, allora durante la dichiarazione Extern nel programma principale dev’essere
indicato quale tipo di dati devono avere le relative variabili e quale metodo di passaggio
dev’essere utilizzato. OUT è l’impostazione default. Esempio:
EXTFCT REAL FUNZ1(REAL:IN,BOOL:OUT,REAL,CHAR:IN)
L’utilizzo di IN e OUT viene illustrato in base al seguente esempio. Il sottoprogramma e la
funzione sono globali.
151 di 214
DEF PROG()
EXT CALCOLA (INT:OUT,INT:IN,INT:IN)
EXTFCT REAL FUNZ1(REAL:IN,REAL:OUT,REAL:OUT,REAL:IN,REAL:OUT)
INT A,B,C
REAL D,E,F,G,H,X
A = 1
B = 2
C = 3
D = 1
E = 2
F = 3
G = 4
H = 5
CALCOLA (A,B,C)
;A è ora 11
;B è ora 2
;C è ora 3
X = FUNZ1(H,D,E,F,G)
;D è ora 3
;E è ora 8
;F è ora 3
;G è ora 24
;H è ora 5
;X è ora 15
END
DEF CALCOLA(X1:OUT,X2:IN,X3:IN) ;SP globale
INT X1,X2,X3
X1=X1+10
X2=X2+10
X3=X3+10
END
DEFFCT REAL FUNZ1(X1:IN,X2:OUT,X3:OUT,X4:IN,X5:OUT);funzione
globale
REAL X1,X2,X3,X4,X5
X1 = X1*2
X2 = X2*3
X3 = X3*4
X4 = X4*5
X5 = X5*6
RETURN(X4)
ENDFCT
In caso di passaggio di un campo, esso dev’essere dichiarato nuovamente nel sottopro-

gramma o nella funzione, però senza l’indice. Al riguardo viene riportato il seguente esempio
nel quale i valori di un campo X[] vengono raddoppiati (la funzione è globale):
152 di 214
DEF ARRAY ( )
EXT BAS (BAS_COMMAND:IN,REAL:IN)
INT X[5] ;dichiarazione campo
INT I
EXT DOPPEL (INT[]:OUT)
BAS (#INITMOV,0)
FOR I=1 TO 5
X[I]=I ;inizializzare array X[]
ENDFOR ;X[1]=1,X[2]=2,X[3]=3,X[4]=4,x[5]=5
DOPPEL (X[]) ;richiamare sottoprogramma con parametri campo

;X[1]=2,X[2]=4,X[3]=6,X[4]=8,X[5]=10
END
DEF DOPPEL (A[]:OUT)

INT A[] ;nuova dichiarazione del campo
INT I
FOR I=1 TO 5
A[I]=2*A[I] ;raddoppiamento dei valori del campo
ENDFOR
END
Neppure durante il passaggio di campi multidimensionali vengono indicati degli indici, però
la dimensione del campo dev’essere specificata tramite virgole, esempi:
A[,] per campi bidimensionali
A[,,] per campi tridimensionali
APPUNTI:
153 di 214
154 di 214
8 Trattamento interrupt
8 Trattamento interrupt
Impiegando dei robot in impianti di produzione complessi sussiste la necessità che il robot
possa reagire in modo mirato ed immediatamente a determinati eventi esterni o interni e che
possano essere effettuate delle azioni parallelamente al processo del robot. Ciò vuol dire che
occorre interrompere un programma robot in corso ed avviare un programma oppure una
funzione di interruzione. Dopo l’esecuzione del programma di interruzione, il programma
robot interrotto dev’essere ripreso se non dichiarato altrimenti.
Questa interruzione oppure l’avvio mirato di un programma viene reso possibile tramite
l’istruzione interrupt. Essa permette all’utente di reagire per ogni programma ad un evento
che non si presenta in modo temporalmente sincrono all’esecuzione del programma.
Degli interrupt possono essere provocati da
G dispositivi come sensori, unità periferiche, ecc.,
G messaggi errore,
G dall’utente, o tramite
G circuiti di sicurezza.
Ad esempio dopo aver premuto il pulsante di emergenza può essere richiamata una routine
di interrupt che resetta determinati segnali di uscita (programma predisposto
IR_STOPM.SRC).
APPUNTI:
155 di 214
8.1 Dichiarazione
Prima di poter attivare un interrupt devono essere definite le possibile cause di interruzione
e la relativa reazione del sistema.
INTERRUPT Ciò avviene tramite la dichiarazione interrupt dove ad ogni interruzione occorre assegnare
una priorità, un evento e la routine di interrupt da richiamare. La sintassi completa è:
INTERRUPT DECL Priorità WHEN Evento DO Sottoprogramma
Per quanto riguarda il significato degli argomenti vedi Tab. 25.

dati
Priorità INT Espressione aritmetica che indica la priorità dell’interru-
zione. Sono disponibili i livelli di priorità 1...39 e 81...128.
I valori 40...80 sono riservati per un’assegnazione auto-
matica di priorità tramite il sistema.
L’interruzione del livello 1 ha la massima priorità.
Evento BOOL Espressione logica che definisce l’evento
dell’interruzione. Sono ammessi:
S una costante di Boole
S una variabile di Boole
S un nome di segnale
S un confronto
Sotto-- Nome del programma interrupt che dev’essere eseguito
programma al presentarsi dell’evento.
Tab. 25 Argomenti nella dichiarazione interrupt
L’istruzione
INTERRUPT DECL 4 WHEN $IN[3]==TRUE DO UP1()
dichiara ad es. un interrupt della priorità 4 che richiama il sottoprogramma UP1() appena
l’ingresso 3 va su High.
La dichiarazione interrupt è un’istruzione. Non deve quindi trovarsi nella sezione delle
dichiarazioni!
Un interrupt viene riconosciuto soltanto a partire dal livello di programma sul quale è stato
dichiarato. Su livelli di programma superiori l’interrupt non viene riconosciuto nonostante l‘at-
tivazione. Ciò significa che un interrupt dichiarato in un sottoprogramma non è noto nel pro-
gramma principale (vedi Fig. 38).
GLOBAL Se l’interrupt viene invece dichiarato come GLOBAL, allora può essere dichiarato in un sotto-
programma qualsiasi e non perde la sua validità abbandonando questo livello (vedi Fig. 38).
GLOBAL INTERRUPT DECL 4 WHEN $IN[3]==TRUE DO UP1()
156 di 214
8 Trattamento interrupt (segue)
G Una dichiarazione può essere sovrascritta in qualsiasi momento da una nuova.

G Un interrupt GLOBALE si distingue da un interrupt normale per il fatto che rimane va-
lido anche dopo l’uscita dal sottoprogramma nel quale è stato dichiarato.
G Possono essere dichiarati allo stesso tempo max. 32 interrupt.
G Nella condizione interrupt non si deve accedere a delle variabili o componenti di
struttura.
G Non è consentito passare delle variabili del tempo di esecuzione come parametri della
routine di interrupt tranne nel caso in cui si tratti di variabili GLOBAL o variabili dichia-
rate nella lista dati.
Programma principale
DEF MAIN()
⋮
INTERRUPT DECL 1 ¼
INTERRUPT DECL 3 ¼ Sottoprogramma
⋮
UP()
DEF UP()
⋮
⋮
END
GLOBAL INTERRUPT DECL 23
¼
INTERRUPT DECL 2 ¼
⋮
END
Validità interrupt 1,3,23
Validità interrupt 2
Fig. 38 Ambito di validità di un interrupt in funzione del luogo e tipo di dichiarazione
APPUNTI:
157 di 214
8.2 Attivazione di interrupt

Attivare Dopo la dichiarazione, un interrupt è per il momento disattivato. Con l’istruzione
interrupt
INTERRUPT ON 4
viene attivato l’interrupt con la priorità 4, con
INTERRUPT ON
vengono attivati tutti gli interrupt. Soltanto dopo l’attivazione può avvenire una reazione
all’interruzione definita. L’evento di interruzione viene ora sorvegliato in modo ciclico.
Triggerato al L’evento viene sorvegliato in modo triggerato al fronte di salita, cioè un interrupt viene avviato
fronte di salita soltanto se la condizione logica passa dallo stato FALSE allo stato TRUE, non nel caso in cui
la condizione fosse già TRUE al momento dell’attivazione.
Per motivi di tempo di calcolo possono essere attivati contemporaneamente soltanto 16

interrupt. Ciò dev’essere osservato in particolare in caso dell’attivazione globale di tutti gli
interrupt.
Disattivare Nello stesso modo dell’attivazione viene effettuata anche la disattivazione di singoli o di tutti
interrupt gli interrupt:
INTERRUPT OFF 4
oppure
INTERRUPT OFF
Disabilitare / Tramite le parole chiavi ENABLE e DISABLE, degli interrupt attivati possono essere abilitati
Abilitare o disabilitati singolarmente o globalmente.
L’istruzione di disabilitazione permette la protezione di determinati parti del programma
dall’interruzione. Un interrupt disabilitato viene riconosciuto e memorizzato, ma non viene
eseguito. Soltanto dopo l’avvenuta abilitazione, gli interrupt presenti vengono eseguiti
nell’ordine della loro priorità.
DISABLE 4
oppure
DISABLE
Non avviene nessuna reazione ad un evento memorizzato se l’interrupt viene disattivato
prima dell’avvio. Se un interrupt si presenta più volte mentre è disabilitato, dopo la sua abilita-
zione viene eseguito soltanto una volta.
I presupposti per l’avvio di un interrupt sono:

S L’interrupt dev’essere dichiarato (INTERRUPT DECL ¼)
S L’interrupt dev’essere attivato (INTERRUPT ON)
S L’interrupt non dev’essere disabilitato
S Il relativo evento dev’essersi presentato (triggerato al fronte di salita)
Priorità In caso di comparsa contemporanea di interrupt viene eseguito dapprima l’interrupt con la
priorità maggiore e in seguito gli interrupt di priorità inferiore. Il livello di priorità 1 ha la
massima priorità, il livello 128 la minore.
Al riconoscimento di un evento viene memorizzata la posizione attuale del robot e viene
richiamata la routine di interrupt. L’interrupt presentatosi come anche tutti gli interrupt di
priorità inferiore vengono disabilitati per l’intera durata dell’esecuzione. Al ritorno dal
programma interrupt viene annullata la disabilitazione implicita anche per l’interrupt attuale.
L’interrupt può quindi ora essere di nuovo eseguito alla ricomparsa (anche durante il
programma interrupt). Per evitare ciò, l’interrupt dev’essere disabilitato o disattivato in modo
esplicito prima del ritorno.
158 di 214
Un interrupt può essere interrotto dopo il primo comando nel programma interrupt da degli
interrupt di priorità maggiore. Nel primo comando il programmatore ha dunque la possibilità
di evitare ciò disabilitando/disattivando uno o tutti gli interrupt. Se un interrupt nel programma
interrupt si disattiva da solo, naturalmente l’esecuzione viene portata a termine.
Dopo la conclusione di un interrupt con priorità maggiore, il programma interrupt interrotto
viene proseguito dal punto dove è stato interrotto.
G E’ possibile passare dei parametri IN ad un programma interrupt.

G Se un programma interrupt locale deve restituire un parametro, la variabile
dev’essere dichiarata nella lista dati del programma principale. In caso di programmi
interrupt globali occorre lavorare con la lista dati $CONFIG.DAT.
G Delle modifiche di $TOOL e $BASE nel programma interrupt sono efficaci soltanto lì
(funzionamento a comando).
G Nel programma interrupt non esiste il processo avanzato del calcolatore poiché gira
su livello di comando, cioè viene eseguito frase per frase (Þ Delle istruzioni
$ADVANCE non sono ammesse). Dunque non è possibile l’approssimazione.
Casi speciali:
S Degli interrupt sulle variabili di sistema $ALARM_STOP e $STOPMESS vengono eseguiti

anche nel caso di errore, cioè nonostante l’arresto del robot le istruzioni interrupt
vengono eseguite (nessun movimento).
S Durante un arresto di controllo può essere riconosciuto ogni interrupt dichiarato ed

attivato. Dopo un riavvio, gli interrupt presenti vengono eseguiti secondo la loro priorità
(se sono abilitati) e in seguito il programma viene proseguito.
Un movimento del robot in corso non viene interrotto al richiamo di un programma interrupt.
Durante l’esecuzione del programma interrupt vengono ancora effettuati tutti i movimenti
preparati nel programma interrotto. Se il programma interrupt durante questo periodo è stato
eseguito completamente, il programma interrotto viene ripreso senza arresto dei movimenti,
cioè senza prolungamento del tempo di esecuzione. Se invece l’operazione interrupt non è
terminata, il robot si ferma fino a quando, dopo il ritorno, sarà preparato e continuato il
prossimo movimento.
Se nel programma interrupt stesso si trovano delle istruzioni di movimento, allora il
programma interrupt si ferma sulla prima istruzione di movimento fino a quando il processo
avanzato del programma principale sarà eseguito.
L’impiego di istruzioni interrupt e l’utilizzo delle variabili di sistema speciali vengono illustrati
in base al seguente esempio. Durante un movimento lineare vengono continuamente
sorvegliati due sensori (sugli ingressi 1 e 2). Appena un sensore rivela un pezzo (va su High),
viene richiamato un programma interrupt memorizzando la posizione del pezzo e settando
una relativa uscita. Il movimento del robot non viene interrotto. In seguito i pezzi riconosciuti
vengono nuovamente raggiunti.
159 di 214
DEF INTERRUP ( )

DECL AXIS HOME
POS PEZZO[2]
INT I

HOME={AXIS: A1 0,A2 -90,A3 90,A4 0,A5 30,A6 0}
FOR I=1 TO 16
$OUT[I]=FALSE ;resettare tutte le uscite
ENDFOR
INTERRUPT DECL 10 WHEN $IN[1]==TRUE DO SAVEPOS (1 )
INTERRUPT DECL 11 WHEN $IN[2]==TRUE DO SAVEPOS (2 )

PTP {X 1320,Y 100,Z 1000,A -13,B 78,C -102}
INTERRUPT ON ;attivare tutti gli interrupt

LIN {X 1320,Y 662,Z 1000,A -13,B 78,C -102} ;percorso di ricerca
INTERRUPT OFF 10 ;disattivare interrupt 10
INTERRUPT OFF 11 ;disattivare interrupt 11
PTP HOME
FOR I=1 TO 2
IF $OUT[I] THEN
LIN PEZZO[I] ; movimento su pezzo riconosciuto
$OUT[I]=FALSE
PTP HOME
ENDIF
ENDFOR
END
;----------- Programma interrupt ----------

DEF SAVEPOS (NR :IN ) ;pezzo riconosciuto
INT NR
$OUT[NR]=TRUE ;settare merker
PEZZO[NR]=$POS_INT ;memorizzare posizione
END
Oltre al pacchetto base (BAS.SRC) è presente come standard nel controllo anche un file
IR_STOPM(). Questo sottoprogramma esegue in caso di errore alcune istruzioni
fondamentali. Ne fa parte oltre ad alcune azioni specifiche della tecnologia anche il
riposizionamento del robot sulla traiettoria di movimento. Mentre il robot rimane sulla
traiettoria dopo che è stato premuto il pulsante di EMERGENZA, in caso di dispositivi di
protezione che riguardano direttamente l’operatore (come ad es. porta di protezione) da
parte dell’hardware viene provocato un arresto che non segue la traiettoria.
Si consiglia quindi di implementare nella sezione di inizializzazione dei Vostri programmi
sempre la seguente sequenza (si trova come standard nel fold BAS INI):

INTERRUPT ON 3
160 di 214
Nel file IR_STOPM() viene predisposto con l’istruzione PTP $POS_RET il riposizionamento
e quindi viene nuovamente creata la coincidenza frase.
Ulteriori variabili di sistema utili per il lavoro con degli interrupt sono riportate in Tab. 26. Le
posizioni si riferiscono sempre ai sistemi di coordinate attuali nel processo principale.
Specifico per Cartesiano Descrizione

asse
$AXIS_INT $POS_INT Posizione nella quale è stato avviato l’interrupt
$AXIS_ACT $POS_ACT Posizione attuale
$AXIS_RET $POS_RET Posizione nella quale è stata abbandonata la traiet-
toria
$AXIS_BACK $POS_BACK Posizione del punto di partenza della traiettoria
$AXIS_FOR $POS_FOR Posizione del punto di destinazione della traiettoria
Tab. 26 Variabili di sistema utili per il trattamento interrupt
Le posizioni ¼_BACK e ¼_FOR dipendono in caso di movimenti approssimati dalla posizione

del processo principale. Vedi al riguardo Fig. 39 fino a Fig. 40.
$POS_RET
$POS_INT
$AXIS_RET P2
$AXIS_INT
$POS_FOR
$AXIS_FOR
P1 P3
$POS_BACK $POS_ACT
$AXIS_BACK $AXIS_ACT
Fig. 39 Variabili di sistema interrupt in caso di punti con arresto preciso
P2
$POS_INT $POS_RET
$AXIS_INT $AXIS_RET
$POS_FOR
$AXIS_FOR
$POS_BACK $POS_ACT
$AXIS_BACK $AXIS_ACT
P1 P3
Fig. 40 Variabili di sistema interrupt in caso di interrupt in un’area di approssimazione
161 di 214
8.3 Arresto di movimenti in corso

BRAKE Se i movimenti del robot ancora in corso al momento del presentarsi di un interrupt devono
essere arrestati, si usa l’istruzione BRAKE nel programma interrupt. Se si programma senza
parametro
BRAKE
ciò provoca una frenatura del movimento con i valori di accelerazione di avanzamento/degli
assi programmati. Il comportamento è lo stesso che nel caso dell’azionamento del tasto
STOP. La traiettoria di movimento programmata non viene abbandonata in questo caso.
Con l’istruzione
BRAKE F
(brake fast) è possibile ottenere uno spazio di frenata più breve. Il robot in questo caso viene
frenato con la massima decelerazione lungo la traiettoria.
L’istruzione BRAKE deve trovarsi soltanto in un programma interrupt. In altri programmi

provoca un arresto errore.
L’istruzione BRAKE non deve necessariamente avvenire direttamente dopo il richiamo ma

può trovarsi in una posizione qualsiasi all’interno del programma interrupt. Il suo effetto
dipende dal fatto se al momento della sua esecuzione viene ancora effettuato un movimento
del programma interrotto. Se il robot è fermo, l’istruzione non ha nessun effetto. Un
movimento ancora in corso del programma interrotto viene arrestato col modo di frenatura
programmato. Il comando BRAKE non sostituisce però l’istruzione HALT se l’esecuzione del
programma dev’essere arrestata. L’esecuzione del programma interrupt viene ripresa con
l’istruzione successiva soltanto dopo l’arresto avvenuto del robot.
Dopo il ritorno al programma interrotto, un movimento arrestato con

BRAKE o BRAKE F nel programma interrupt viene ripreso!
APPUNTI:
162 di 214
8.4 Annullamento di routine di interrupt

Nell’esempio 8.1 vengono rilevati durante il movimento del robot tramite 2 iniziatori un
massimo di 2 oggetti e le loro posizioni vengono registrate per poterle raggiungere in un
secondo tempo.
Il percorso di ricerca viene in ogni caso effettuato completamente anche se i due oggetti sono
già stati riconosciuti. Per risparmiare tempo è opportuno interrompere il movimento
immediatamente dopo che è stato riconosciuto il numero massimo di pezzi.
RESUME L’interruzione di un movimento robot è possibile nel KR C... tramite l’istruzione
RESUME
RESUME annulla tutti i programmi interrupt in corso e anche tutti i sottoprogrammi in corso
fino al livello sul quale è stato dichiarato l’interrupt attuale.
Come l’istruzione BRAKE, anche RESUME è ammessa soltanto in un programma interrupt.

Al momento dell’istruzione RESUME, il puntatore avanzato non si deve trovare sul livello sul
quale è stato dichiarato l’interrupt, ma almeno un livello più basso.
Poiché il percorso di ricerca dev’essere annullato con RESUME, il movimento di ricerca

dev’essere programmato in un sottoprogramma. Ciò avviene nel seguente esempio in
MOVEP(), il sottoprogramma interrupt si chiama IR_PROG().
E’ importante che in sottoprogrammi che devono essere interrotti con RESUME, il processo
avanzato venga arrestato prima dell’ultima riga. Soltanto in questo modo può essere
garantito che il puntatore avanzato al momento di RESUME non si trovi sul livello sul quale
è stato dichiarato l’interrupt. In MOVEP() ciò è stato realizzato con l’assegnazione
$ADVANCE=0.
Nel programma interrupt stesso viene arrestato il movimento di ricerca tramite BRAKE,
appena sono stati riconosciuti 4 pezzi da un sensore sull’ingresso 1, ed infine esso viene
annullato con l’istruzione RESUME (poiché oltre a IR_PROG() viene terminato anche
MOVEP()). Senza l’istruzione BRAKE verrebbe ancora effettuato il movimento di ricerca nel
processo avanzato.
Dopo RESUME il programma principale viene proseguito con l’istruzione successiva al
richiamo del sottoprogramma, quindi $ADVANCE=3 (resettare processo avanzato).
163 di 214
DEF SEARCH ( )
DECL AXIS HOME
INTERRUPT ON 3 ;gestione errori standard
HOME={AXIS: A1 0,A2 -90,A3 90,A4 0,A5 30,A6 0}
INTERRUPT DECL 11 WHEN $IN[1] DO IR_PROG ( )
I[1]=0 ;settare contatore predefinito su 0
INTERRUPT ON 11
MOVEP ( ) ;movimento lungo il percorso di ricerca
$ADVANCE=3 ;resettare processo avanzato
INTERRUPT OFF 11
GRIP ( )
PTP HOME
END
;-------- Sottoprogramma ------------
DEF MOVEP ( ) ;sottoprogramma per il movimento lungo il
;percorso di ricerca
PTP {X 1232,Y -263,Z 1000,A 0,B 67,C -90}
LIN {X 1232,Y 608,Z 1000,A 0,B 67,C -90}
$ADVANCE=0 ;arrestare processo avanzato
END ;
;------ Programma interrupt ---------
DEF IR_PROG ( ) ;memorizzare posizione dei pezzi
;INTERRUPT OFF 11
I[1]=I[1]+1
POSITION[I[1]]=$POS_INT ;memorizzazione della posizione
IF I[1]==4 THEN ;vengono riconosciuto 4 pezzi
BRAKE ;arresto del movimento
RESUME ;annullamento di IR_PROG & MOVE
ENDIF
;INTERRUPT ON 11
END
;-------- Sottoprogramma ------------l
DEF GRIP ( ) ;afferrare i pezzi riconosciuti

INT POS_NR ;variabile di conteggio
FOR POS_NR=I[1] TO 1 STEP -1
POSITION[POS_NR].Z=POSITION[POS_NR].Z+200
LIN POSITION[POS_NR] ;spostarsi 200mm sopra pezzo
LIN_REL {Z -200} ;avvicinarsi perpendicolarmente al pezzo
; afferrare pezzo
LIN POSIZIONE[POS_NR] ;movimento verso l’alto
LIN {X 634,Y 1085,Z 1147,A 49,B 67,C -90}
; depositare pezzo
ENDFOR
END
164 di 214
Se sussiste il pericolo che un interrupt venga avviato erroneamente due volte a causa di
sensori sensibili, ciò può essere evitato disattivando l’interrupt nella prima riga del
programma interrupt. Però in questo caso anche un interrupt effettivamente presente non
può più essere riconosciuto durante l’elaborazione dell’interrupt. Prima del ritorno
l’interrupt dev’essere riattivato -- se deve rimanere attivo.
Se, come nell’esempio sopra, un movimento viene interrotto con RESUME, il movimento
successivo non dovrebbe essere un movimento CIRC, poiché il punto iniziale è ogni volta
un altro (Þ cerchi diversi).
Per la ricerca programmata nell’esempio 8.2, gli ingressi vengono interrogati nel ciclo di inter-
polazione (attualmente 12 ms). Esiste un’imprecisione massima di circa 12 ms moltiplicata
per la velocità di avanzamento.
“Misurazione Per evitare questa imprecisione occorre non collegare l’iniziatore agli ingressi utente ma
veloce” utilizzare degli ingressi speciali (4 disponibili) sul connettore periferico X11. Questi ingressi
possono essere attivati tramite le variabili di sistema $MEAS_PULSE[1]...MEAS_PULSE[4]
(tempo di risposta 125 ms).
All’attivazione dell’interrupt non dev’essere presente l’impulso di misurazione, altrimenti
appare un relativo messaggio di errore.
APPUNTI:
165 di 214
8.5 Utilizzo di flag ciclici

Nell’istruzione per la dichiarazione interrupt non sono ammesse delle operazioni logiche.
Per poter definire degli eventi complessi occorre quindi lavorare con dei flag ciclici poiché
soltanto questi permettono un aggiornamento continuo.
Con la sequenza
⋮
$CICFLAG[3] = $IN[1] AND ([$IN[2] OR $IN[3])
INTERRUPT DECL 10 WHEN $CICFLAG[3] DO IR_PROG()
INTERRUPT ON 10
⋮
è dunque possibile sorvegliare contemporaneamente 3 ingressi ed effettuare una opera-
zione logica tra di loro.

[Variabili di sistema e file di sistema].
APPUNTI:
166 di 214
9 Trigger -- Azioni di commutazione riferite alla traiettoria
9 Trigger -- Azioni di commutazione riferite alla traiettoria

Al contrario delle funzionalità interrupt indipendenti dal movimento, alcuni casi di applica-
zione richiedono delle azioni di commutazione che vengono avviate in base alla traiettoria
di movimento. Tali casi di applicazione sono ad es.:
G Chiusura ed apertura della pinza di saldatura per la saldatura a punti
G Inserimento/disinserimento della corrente di saldatura per la saldatura ad arco
G Inserimento/disinserimento della corrente di volume per incollatura o sigillatura
Nel KR C... queste azioni di commutazione riferite alla traiettoria vengono rese possibile
dall’istruzione TRIGGER. Parallelamente al prossimo movimento del robot è possibile con
TRIGGER eseguire un sottoprogramma in base ad un criterio di percorso, effettuare un’asse-
gnazione di valore ad una variabile o un’istruzione PULSE oppure settare un’uscita.
9.1 Azione di commutazione al punto di partenza o al punto di destinazione

della traiettoria
TRIGGER Se viene desiderata un’azione di commutazione riferita al punto di partenza o di destinazione
di un movimento, occorre programmare prima della relativa istruzione di movimento (PTP,
LIN o CIRC) un’istruzione TRIGGER con la seguente sintassi:
TRIGGER WHEN DISTANCE=Punto di commutazione DELAY=Tempo

DO Istruzione PRIO=Priorità
Gli argomenti sono descritti più in dettaglio nella seguente tabella.

dati
Punto di INT In caso di frasi singole DISTANCE=0 indica il punto di
commutazione partenza e DISTANCE=1 il punto di destinazione del movi-
mento successivo. In caso di frasi di approssimazione
DISTANCE=1 indica il centro dell’arco di approssimazione
successivo.
Se la frase precedente è già una frase di approssima-
zione, allora DISTANCE=0 indica il punto di destinazione
dell’arco di approssimazione precedente.
Tempo INT Con l’indicazione DELAY è possibile ritardare o anticipare
il punto di commutazione di un determinato intervallo di
tempo. Il punto di commutazione può essere spostato
però soltanto all’interno della relativa frase.
L’unità sono i millesimi di secondo.
Istruzione L’istruzione può essere
S un richiamo di sottoprogramma
S un’assegnazione di valore ad una variabile
S un‘istruzione OUTPUT (anche Pulse).
Priorità Priorità INT Ad ogni istruzione TRIGGER con richiamo di sotto-
programma dev’essere assegnata una priorità. Sono
ammessi i valori 1...39 e 81...128. Si tratta delle stesse
priorità degli interrupt (vedi paragrafo 8).
I valori 40...80 sono riservati per un’assegnazione della
priorità automatica da parte del sistema. Programmare a
questo scopo PRIO=--1.
Tab. 27 Argomenti nell’istruzione TRIGGER
167 di 214
Con la sequenza di istruzioni

⋮
LIN PUNTO2
⋮
TRIGGER WHEN DISTANCE = 0 DELAY=20 DO $OUT[4]=TRUE
TRIGGER WHEN DISTANCE = 1 DELAY=-25 DO UP1() PRIO=-1
LIN PUNTO3
⋮
LIN PUNTO4
⋮
viene quindi settata l’uscita 4, durante il movimento lineare verso il PUNTO3, esattamente 20
millesimi di secondo dopo l’avvio del movimento e 25 millesimi di secondo prima del
raggiungimento del punto di destinazione viene richiamato il sottoprogramma UP1().
L’assegnazione di priorità avviene automaticamente tramite il sistema.
Per l’illustrazione dell’effetto differente dell’indicazione DISTANCE in frasi singole e in frasi
di approssimazione vedi Fig. 41 -- Fig. 44.
DISTANCE Ambito di DELAY

commutazione
0 0 -- 1 +
1 1 -- 0 --
0
PUNTO2 +
--
PUNTO3
1
Fig. 41 Ambiti di commutazione e valori di ritardo possibili se il punto di partenza e il
punto di destinazione sono dei punti con arresto preciso
168 di 214
9 Trigger -- Azioni di commutazione riferite alla traiettoria (segue)
0 PUNTO2 DISTANCE Ambito di

commutazione
DELAY
0 0 -- 1a +
+
1 1a -- 1b ±
1a
-- 1
1b
PUNTO3 PUNTO4
+
Fig. 42 Ambiti di commutazione e valori di ritardo possibili se il punto di partenza è un punto

con arresto preciso e il punto di destinazione è un punto di approssimazione
PUNTO2
commutazione
0 0 -- 1a +
1 1a -- 1b ±
0
+
1a
-- 1
1b
PUNTO3 PUNTO4
+
Fig. 43 Ambiti di commutazione e valori di ritardo possibili se il punto di partenza e quello

di destinazione sono dei punti di approssimazione
169 di 214

commutazione
0 0 -- 1 +
PUNTO2
1 1 -- 0 --
0
+
--
1
PUNTO3
Fig. 44 Ambiti di commutazione e valori di ritardo possibili se il punto di partenza è un punto

di approssimazione e il punto di destinazione è un punto con arresto preciso
APPUNTI:
170 di 214
9.2 Azione di commutazione in un punto qualsiasi sulla traiettoria

In caso dell’istruzione TRIGGER riferita al percorso è possibile avviare l’azione di commuta-
zione, tramite un’indicazione di distanza, in un punto qualsiasi sulla traiettoria. Questa può
essere in più spostata temporalmente come nel caso di azioni di commutazione sul punto
di partenza e quello di destinazione.
L’azione di commutazione riferita al percorso è ammessa soltanto per movimenti lungo la
traiettoria (LIN o CIRC). L’istruzione TRIGGER si riferisce in questo caso alla frase di
movimento programmata in seguito e ha la sintassi:
TRIGGER WHEN PATH = Percorso DELAY = Tempo DO Istruzione

áPRIO=Prioritàñ
Gli argomenti sono descritti più in dettaglio nella seguente tabella.

dati
Percorso INT Con Percorso viene indicata la distanza desiderata dal
punto di destinazione programmato dopo il Trigger.
Se questo punto di destinazione è un punto approssimato,
allora Percorso indica la distanza desiderata dell’azione
di commutazione dalla posizione dell’area di approssima-
zione più vicina al punto di destinazione.
Il punto di commutazione può essere anticipato tramite un
Percorso negativo fino al punto di partenza. Se il punto
di partenza è un punto di approssimazione, allora il punto
di commutazione può essere spostato fino all’inizio
dell’area di approssimazione.
Con un’indicazione positiva di Percorso è possibile uno
spostamento fino al prossimo punto con arresto preciso
programmato dopo il trigger.
L’unità sono i millimetri.
Tempo INT Con l’indicazione DELAY è possibile ritardare (+) o
anticipare (--) di un determinato intervallo di tempo il punto
di commutazione relativamente all’indicazione PATH.
Il punto di commutazione può però essere spostato
soltanto all’interno dell’ambito riportato sopra (tanto
quanto basta per raggiungere il prossimo punto con arresto
preciso. In caso di movimenti di approssimazione, il punto
di commutazione può essere anticipato al massimo fino
all’inizio di approssimazione del punto di partenza.)
L’unità sono i millesimi di secondo.
Istruzione L’istruzione può essere
S un richiamo di sottoprogramma
S un’assegnazione di valore ad una variabile
S un‘istruzione OUTPUT (anche Pulse).
Priorità Priorità INT Ad ogni istruzione TRIGGER con richiamo di sottopro-
gramma dev’essere assegnata una priorità. Sono am-
messi i valori 1...39 e 81...128. Si tratta delle stesse priorità
degli interrupt (vedi paragrafo 8).
I valori 40...80 sono riservati per un’assegnazione della
priorità automatica da parte del sistema. Programmare a
questo scopo PRIO=--1.
Tab. 28 Argomenti nell’istruzione TRIGGER
171 di 214
Sequenza di istruzioni:
⋮
LIN PUNTO2 C_DIS
TRIGGER WHEN PATH = Y DELAY= X DO $OUT[2]=TRUE
LIN PUNTO3 C_DIS
LIN PUNTO4 C_DIS
LIN PUNTO5
⋮
Poiché il punto di commutazione può essere spostato a partire dal punto di movimento prima
del quale è stato programmato e passando per tutti i punti di approssimazione successivi fino
al prossimo punto con arresto preciso è possibile uno spostamento del punto di commuta-
zione dall’inizio di approssimazione PUNTO2 fino al PUNTO5. Se in questa sequenza di istru-
zioni il PUNTO2 non fosse con approssimazione, il punto di commutazione potrebbe essere
spostato soltanto fino al punto con arresto preciso PUNTO2.
PUNTO2
--
DELAY X
-- PUNTO5
+
PATH Y<0
DELAY X
-- +
PUNTO3 PUNTO4
DELAY=0
PATH=0 PATH Y>0 +
Esempio con cifre:

X= --10, Y= --20
PUNTO2
Punto di
commutazione
DELAY= -10
PUNTO5
PATH= -20
PUNTO4
PUNTO3
Fig. 45 Ambiti di commutazione se il punto di partenza è un punto di approssimazione
172 di 214
Casi speciali:
G Movimento SAK
Se viene effettuata una selezione di frase su un movimento lungo la traiettoria, esso
avviene come movimento SAK. Siccome per questo movimento SAK il punto di partenza
è uno qualsiasi, non è opportuno utilizzarlo come punto di partenza per un’indicazione di
distanza. Se prima di un tale movimento sono programmati dei comandi TRIGGER con
indicazione PATH e se avviene una selezione frase su questi comandi, allora questi
vengono eseguiti tutti sul punto di destinazione.
G Approssimazione non possibile
Se l’approssimazione non è possibile, in questo punto avviene un movimento con arresto
preciso. Questo viene però trattato in questo contesto come un movimento di
approssimazione. Delle azioni di commutazione presenti in seguito sulla traiettoria
rimangono memorizzate e vengono avviate al punto opportuno. Però di regola non saranno
più esatte poiché ora risulta un’altra traiettoria e quindi un’altra lunghezza di traiettoria.
Delle azioni di commutazione predisposte tramite un valore PATH negativo sulla prima
metà dell’area di approssimazione possono ora essere avviate al più presto sul punto di
approssimazione:
⋮
LIN P1 C_DIS
TRIGGER WHEN PATH=-120 DELAY=0 DO UP1() PRIO=-1
TRIGGER WHEN PATH=-70 DELAY=0 DO $OUT[2]=TRUE
LIN P2 C_DIS
⋮
Nell’esempio sopra la distanza tra il punto di partenza e quello di destinazione dev’essere
di 100 mm. Se è possibile effettuare un’approssimazione su P1, allora il richiamo di
sottoprogramma UP1() viene effettuato 20 mm prima del raggiungimento del punto di
traiettoria più vicino al punto di approssimazione P1. L’uscita 2 viene settata 30 mm dopo
questo punto di traiettoria. Se su P1 non è stato possibile effettuare l’approssimazione, la
traiettoria attraversa il punto P1 sul quale avviene anche il posizionamento. Il richiamo di
sottoprogramma UP1() viene ora effettuato immediatamente dopo l’abbandono di P1 e
l’uscita 2 viene settata a distanza di 30 mm da P1.
G Interruzione di un movimento
Se un movimento viene interrotto ad es. tramite una selezione frase o un reset e non
portato a termine, allora, come in caso dell’indicazione DISTANCE, le azioni di
commutazione non ancora effettuate non verranno più eseguite ma cancellate.
G Istruzione TRIGGER riferita al percorso per un movimento PTP
Se un’istruzione PATH-TRIGGER con indicazione del percorso viene programmata con un
movimento PTP, ciò viene rifiutato dall’interpreter durante l’esecuzione.
G Approssimazione PTP -- trajettoria
Se un’istruzione PATH-TRIGGER viene programmata con un movimento il cui punto di par-
tenza è un punto di approssimazione traiettoria -- PTP, l’azione di commutazione può avve-
nire al più presto alla fine di quest’area di approssimazione perché tutta l’area di approssi-
mazione verrà effettuata come PTP.
In caso di un’area di approssimazione traiettoria -- PTP, tutte le istruzioni TRIGGER ancora
attive e non ancora commutate vengono avviate sul punto iniziale dell’area di approssima-
zione. A partire da lì viene effettuato il movimento PTP e un’assegnazione della traiettoria
non è più possibile.
173 di 214
Nel seguente esempio sono programmate sia delle azioni di commutazione con indicazione
DISTANCE, sia con indicazione PATH. I singoli punti di commutazione e la traiettoria di
movimento sono rappresentati in Fig. 46.
DEF TRIG ( )
EXT BAS (BAS_COMMAND :IN,REAL :IN)
DECL AXIS HOME
INT I
SIGNAL COLLA $OUT[3]
INTERRUPT ON 3
;accelerazioni, $BASE, $TOOL, ecc.
$APO.CDIS=35 ;stabilire distanza di approssimazione
HOME={AXIS: A1 0,A2 -90,A3 90,A4 0,A5 30,A6 0}
POS0={POS: X 1564,Y -114,Z 713,A 128,B 85,C 22,S 6,T 50}
POS1={X 1383,Y -14,Z 713,A 128,B 85,C 22}
POS2={X 1383,Y 200,Z 713,A 128,B 85,C 22}
POS3={X 1527,Y 200,Z 713,A 128,B 85,C 22}
POS4={X 1527,Y 352,Z 713,A 128,B 85,C 22}
FOR I=1 TO 16
$OUT[I]=FALSE
ENDFOR
PTP POS0
TRIGGER WHEN DISTANCE=0 DELAY=40 DO $OUT[1]=TRUE
TRIGGER WHEN PATH=-30 DELAY=0 DO UP1(2) PRIO=-1
LIN POS1
TRIGGER WHEN DISTANCE=1 DELAY=-50 DO COLLA=TRUE
TRIGGER WHEN PATH=180 DELAY 55 DO PULSE($OUT[4],TRUE,0.9)
TRIGGER WHEN PATH=0 DELAY=40 DO $OUT[6]=TRUE
LIN POS2 C_DIS
TRIGGER WHEN DISTANCE=0 DELAY=40 DO PULSE ($OUT[5],TRUE,1.4 )
TRIGGER WHEN PATH=-20 DELAY=-15 DO $OUT[8]
LIN POS3 C_DIS
TRIGGER WHEN DISTANCE=1 DELAY=-15 DO UP1 (7 ) PRIO= -1
LIN POS4
PTP HOME
END
DEF UP1 (NR :IN )
INT NR
IF $IN[1]==TRUE THEN
$OUT[NR]=TRUE
ENDIF
END
174 di 214
POS 1 2’B POS 2

$OUT[3]
30 2’
$OUT[6]
$OUT[2] 2’E
$OUT[5]
3’B
180
8
$OUT[1] $OUT[8]
20
POS 0 $OUT[4] $OUT[7]
3’
3’E
POS 3
POS 4
Fig. 46 Punti di commutazione e traiettoria di movimento riguardo all’esempio precedente
APPUNTI:
175 di 214
176 di 214
10 Liste dati
10 Liste dati
10.1 Liste dati locali
Le liste dati servono per mettere a disposizione delle dichiarazioni specifiche per programma
o anche superiori. Ne fanno parte anche le informazioni su punti, ad es. le coordinate:
G Per ogni file SRC può essere creata una lista dati. Essa ha lo stesso nome del file SRC
e termina con l’estensione “.DAT”.
G La lista dati è locale nonostante sia un proprio file.
G In una lista dati devono trovarsi soltanto dichiarazioni ed inizializzazioni.
G E’ possibile dichiarare ed inizializzare in una riga.
G Delle variabili di sistema non vengono accettate.
La dichiarazione di liste dati avviene in modo analogo alla dichiarazione di file SRC: la
DEFDAT dichiarazione viene iniziata con la parola chiave DEFDAT ed il nome del programma e
terminata con la parola chiave ENDDAT.
L’inizializzazione di variabili avviene tramite un’assegnazione di valore alla relativa variabile
direttamente nella riga della dichiarazione.
PROG_1.SRC PROG_1.DAT
DEF PROG_1 ( )
¼ DEFDAT PROG_1
HALT OTTO è all’inizio “0” INT OTTO = 0
¼ ENDDAT
OTTO = 25
¼
HALT
END
DEFDAT PROG_1
Dopo l’esecuzione del INT OTTO = 25
programma OTTO = 25 ENDDAT
Fig. 47 Inizializzazione ed assegnazione di valore a delle variabili

dichiarate in liste dati
Tramite la dichiarazione e l’inizializzazione nella lista dati esse non sono più necessarie nel
programma principale. Se alla variabile OTTO nel programma principale viene assegnato un
nuovo valore, questo viene inserito anche nella lista dati e rimane memorizzato in modo
permanente (vedi Fig. 47).
Dopo un OFF/ON del controllo verrà quindi lavorato col valore “nuovo”. Ciò è indispensabile
per la correzione online o altre correzioni di programma.
Se un programma principale dev’essere sempre avviato con lo stesso valore, alla relativa
variabile nel programma principale dev’essere assegnato il valore desiderato.
Nelle liste dati possono trovarsi le seguenti dichiarazioni:
G Dichiarazioni esterne per sottoprogrammi e funzioni che vengono utilizzati nel file SRC.
G Dichiarazioni di importazione per variabili importate.
G Dichiarazioni ed inizializzazioni di variabili che vengono utilizzate nel file SRC.
G Dichiarazioni di nomi di segnali e canali che vengono utilizzati nel file SRC.
G Dichiarazioni di tipi di dati e di enumerazione (Struc, Enum) che vengono utilizzati nella
lista dati o nel file SRC.
177 di 214
10.2 Liste dati globali

Delle variabili definite in una lista dati possono essere rese accessibili ad un programma
principale “estraneo”.
PUBLIC A questo scopo la lista dati dev’essere definita tramite la parola chiave PUBLIC opzionale
nella riga di intestazione come “pubblicamente accessibile”. Esistono due possibilità per
dichiarare la variabile:
G Una variabile viene ad es. dichiarata con INT OTTO = 0 nella lista dati e nel pro-
IMPORT gramma principale ignoto questa variabile dev’essere importata col comando Import
affinché sia accessibile.
Ad una variabile importata può essere data nel programma principale un altro nome di
quello della lista dati dalla quale è stata importata.
Se si vuole utilizzare in un programma PROG_2() la variabile OTTO della suddetta lista
dati PROG_1, allora occorre programmare accanto alla parola chiave PUBLIC nella lista
dati la seguente dichiarazione di importazione nel programma PROG_2():
IMPORT INT OTTO_2 IS /R1/PROG_1..OTTO
La variabile OTTO della lista dati PROG_1.DAT nella directory /R1 è ora sotto il nome
OTTO_2 anche nota nel programma PROG_2() (vedi Fig. 48).
DEF PROG_1 ( )
¼ DEFDAT PROG_1 PUBLIC
HALT INT OTTO = 0
¼ ENDDAT
OTTO = 25
¼
END
PROG_2.SRC
DEF PROG_2 ( )
IMPORT INT OTTO_2 IS /R1/PROG_1 .. OTTO
¼
¼
END
Fig. 48 Importazione di variabili da liste dati “estranee” con Import
178 di 214
10 Liste dati (segue)
Global G La variabile viene dichiarata come “Variabile globale” , ad es. DECL GLOBAL INT
OTTO = 0 ed è accessibile da ogni programma principale ignoto senza comando di
importazione.
Dopo aver dichiarata una variabile globale non è possibile modificare il nome della va-
riabile in un programma principale ignoto.
DEF PROG_1 ( )
¼ DEFDAT PROG_1 PUBLIC
HALT DECL GLOBAL INT OTTO = 0
¼ ENDDAT
OTTO = 25
¼
END
PROG_2.SRC
DEF PROG_2 ( )
¼
¼
END
Fig. 49 Importazione di variabili da liste dati “estranee” senza Import
La dichiarazione di una variabile globale è ammessa solo in liste dati, se viene usata in
file SRC o SUB avviene un messaggio di errore.
Nella lista dei dati del sistema predefinita e globale $CONFIG.DAT possono essere definite
variabili, strutture, canali e segnali che sono validi per più tempo e che sono significativi per
molti programmi. Le variabili in $CONFIG.DAT non devono essere dichiarate con IMPORT,
poiché sono automaticamente note a tutti i programmi applicativi.
Ulteriori informazioni per quanto riguarda $CONFIG.DAT sono contenute nel capitolo
[Variabili e dichiarazioni], paragrafo [Variabili di sistema e file di sistema].
179 di 214
180 di 214
11 Editor esterno
11 Editor esterno
Questo programma addizionale amplia il software del robot di funzioni che non sono
disponibili sull’interfaccia grafica.
Pulizia di un programma
Punti di traiettoria e parametri di movimento non calibrati vengono cancellati dalla lista
dati.
Settaggio e spostamento dei finecorsa
Manipolazioni di blocco
-- Selezionare e copiare, cancellare o tagliare un blocco.
-- Invertire la traiettoria del robot nell’area selezionata, cioè il punto programmato
precedentemente per primo del segmento di traiettoria selezionato viene raggiunto
per ultimo e il punto programmato per ultimo per primo.
-- Specchiare la traiettoria del robot nell’area selezionata nel piano XZ del sistema di
coordinate mondo.
-- Modificare i parametri di movimento (velocità, accelerazione, ecc.) nell’area selezio-
nata.
-- Spostamento di tutti i punti all’interno del segmento di traiettoria selezionato nel
sistema di coordinate pezzo (BASE), utensile (TOOL) o mondo (WORLD). Lo
spostamento o la rotazione possono essere effettuati tramite l’immissione manuale
di un offset nel relativo sistema di coordinate o tramite l’insegnamento di punti di
riferimento.
-- Spostamento specifico per asse di tutti i punti nell’area selezionata.
Adattamento dei punti di traiettoria

-- ad un altro sistema di coordinate utensile oppure
-- ad un altro sistema di coordinate pezzo
Adattamento dei punti di traiettoria

-- mentre un programma è in fase di esecuzione nel controllo, è possibile spostare
coordinate di punti nel sistema di coordinate Tool, Base e World.
181 di 214
11.1 Avvio dell’editor esterno
L’editor esterno è disponibile soltanto a partire dal gruppo utente “Esperto”.
Richiamare l’editor esterno tramite il menù “Avviamento” e l’opzione “Service” proposta.
Se la voce di menù “Avviamento” non è disponibile occorre deselezionare il programma

selezionato. Per ricordo: Selezionare a questo scopo dal menù “Edit” l’opzione “Abbando-
nare programma”.
In seguito viene visualizzato sul display l’editor esterno.
Immediatamente dopo l’avvio dell’editor appare il dialogo “file selezionati”. Selezionare a que-
sto punto con i tasti cursore “¯” e “” il file da editare. Sono disponibili tutti i file SRC della directory
R1, tranne quei file standard che sono definiti in “HotEdit.ini” (percorso “C:\Krc\Util\”).
182 di 214
11 Editor esterno (segue)
Se l‘ “Editor esterno” viene avviato come programma offline, addizionalmente sono dispo-
nibili dei campi di selezione per l’indicazione del percorso.
File selezionati
Dopo aver evidenziato il file desiderato in questo modo, esso viene caricato nell’editor
azionando il relativo softkey o il tasto Enter. La durata di questa operazione di caricamento
dipende dalla dimensione del file.
Se appare il messaggio “File *.DAT non trovato”, è stato cercato di caricare un programma
nell’editor per il quale non esiste nessuna lista dati. Questa funzione non è disponibile nella
presente versione dell’editor. Resettare il messaggio premendo il tasto Enter. Aprire il
menù “File” e selezionare l’opzione “Aprire file” per accedere alla finestra “file selezionati”.
Se il file è stato caricato con successo, il programma viene visualizzato in modo simile che
nell’editor dell’interfaccia grafica.
183 di 214
11.2 Comando
Gli elementi dell’interfaccia grafica normale si ritrovano anche su quella dell’editor esterno.
Anche qui sono disponibili tasti menù, tasti stato, softkey, una finestra di programmazione,
una finestra dei messaggi e una riga di stato.
I menù possono essere aperti alternativamente tenendo premuto il tasto “ALT” e azionando
in seguito la lettera sottolineata sul tasto menù. Per quanto riguarda la selezione di un co-
mando menù si procede in modo analogo.
Tasti stato
Tramite i tasti stato “Su” oppure “Giù” è possibile spostare il focus per righe in direzione
dell’inizio oppure della fine della lista. I tasti cursore “"” oppure “#”, nonché i tasti “PGUP”
oppure “PGDN” hanno la stessa funzione.
Focus
Focus
I tasti “PgUp” oppure “PgDn” consentono di sfogliare in avanti o indietro di una pagina. A
questo scopo occorre disattivare la funzione “NUM” oppure utilizzare una tastiera esterna.
Il contenuto della finestra dei messaggi viene cancellato.
Azionando il tasto stato “KRL”, il programma viene visualizzato come nel modo esperto con
le impostazioni “Aprire tutti i folds” e “Limited Visibility off”.
Nel campo “FOLD” viene visualizzato il comando evidenziato col focus (file ”SRC”). Nel
campo “Dati” vengono visualizzati i dati appartenenti al comando evidenziato (file ”DAT”).
184 di 214
Premendo il tasto stato “Lente --” si ritorna alla rappresentazione dell’intero programma.
Barra softkey
Questo softkey corrisponde al comando menù “Chiudi” che chiude il programma attuale, ma
lascia attivato l’editor.
Finestra dei messaggi

Nella finestra dei messaggi vengono visualizzati i messaggi rilevanti per l’editor esterno.
No.: Tipo e numero del messaggio

Tempo: Il momento in cui è stato emesso il messaggio
Messaggio: Il tipo del messaggio
Result: Indicazione dell’esito dell’operazione
Barra stato
Nella barra stato vengono visualizzate delle informazioni addizionali.
NUM: E‘ attivato l’inserimento di cifre del blocco numerico.

CAPS: Il tasto fissamaiuscole è disinserito.
185 di 214
ExtEdit: Il modulo “Editor esterno” è attivo

Palette: Il nome del programma aperto attualmente
12:56: L’ora di sistema attuale
APPUNTI:
186 di 214
11.3 Menù “File”

In questo menù sono disponibili le funzioni per la gestione dei file.
Apri
Salva
Chiudi
Esci
11.3.1 Apri
All’azionamento di questa opzione appare la finestra “file selezionati” come già descritto nel
paragrafo precedente 11.1.
11.3.2 Salva
Se il contenuto del file caricato nell’editor è stato modificato con le funzioni proposte, prima
della memorizzazione della nuova versione di questo file o prima di terminare la sessione con
l’editor viene posta la domanda se le modifiche devono essere salvate.
Sí No
Per salvare le modifiche apportate è sufficiente azionare il tasto Enter per confermare la
preselezione.
I contenuti della versione già esistente del file editato vengono in questo caso, almeno in
parte, persi in modo irrevocabile.
Per annullare l’operazione occorre dapprima premere uno dei tasti cursore per spostare il
focus sul pulsante “No”. In seguito è possibile confermare questa selezione premendo il tasto
Enter. La versione già esistente del file editato rimane in questo caso invariata.
11.3.3 Chiudi
Se il file presente nell’editor è stato modificato dal caricamento, è possibile in un primo mo-
mento salvare le modifiche (come descritto nel paragrafo 11.3.2).
Dopo che il file presente nell’editor è stato chiuso, è possibile caricare un altro file nell’editor
tramite la voce di menù “File” e l’opzione proposta “Apri” (vedi anche paragrafo 11.3.1).
187 di 214
11.3.4 Esci
Se il file presente nell’editor è stato modificato dal caricamento, è possibile in un primo mo-
mento salvare le modifiche (come descritto nel paragrafo 11.3.2).
La finestra dell’editor viene chiusa e ritorna l’interfaccia grafica del software robot.
APPUNTI:
188 di 214
11.4 Menù “Edit”

Questo menù contiene una serie di funzioni di blocco.
Per evidenziare un’area, tener premuto il tasto “SHIFT” ed azionare uno dei due tasti stato
“Su” o “Giù” oppure il relativo tasto cursore.
Area evidenziata
(selezione blocco)
ESC
La selezione di un blocco può essere nuovamente disattivata tramite il tasto “ESC”.
11.4.1 Taglia (“CTRL”--”X”)
Cancella il segmento di traiettoria selezionato dal programma e lo tiene pronto nella memoria
intermedia per l’inserimento.
11.4.2 Copia (“CTRL”--”C”)
Copia il segmento di traiettoria selezionato nella memoria intermedia e lo tiene pronto per
l’inserimento.
11.4.3 Incolla come ...
percorso originale (“CTRL”+”V”)

Inserisce il contenuto della memoria intermedia nello stesso ordine in cui è stato tagliato o
copiato.
percorso inverso
Inserisce il contenuto della memoria intermedia in ordine opposto.
L’ultimo punto di traiettoria del segmento selezionato e tagliato o copiato viene posto all’inizio
del blocco inserito, il primo punto di traiettoria alla fine.
Se è stato insegnato ad esempio il percorso per raggiungere un dispositivo, questa traiettoria
può essere semplicemente inserita anche come percorso inverso senza doverlo insegnare
addizionalmente.
189 di 214
11.4.4 Cancella
Il segmento di traiettoria selezionato viene cancellato senza essere salvato nella memoria
intermedia.
La cancellazione di un segmento di traiettoria selezionato non può essere annullata. Se per

sbaglio sono state cancellate parti del programma, chiudere il file senza salvare le
modifiche e aprirlo successivamente di nuovo.
11.4.5 Seleziona tutto
Viene selezionato l’intero programma caricato nell’editor.
APPUNTI:
190 di 214
11.5 Menù “Util”

In questo menù sono contenute delle opzioni per la manipolazione geometrica del
programma.
Spostare tramite i tasti cursore “” oppure “¯” il segno di inserimento da un campo di immis-
sione all’altro.
Tramite questo softkey è possibile salvare i valori impostati.
Questo softkey conclude l’immissione senza il salvataggio dei valori.
11.5.1 Mirror
Tramite questa funzione è possibile specchiare la posizione dei punti di traiettoria

programmati nel piano XZ del sistema di coordinate $ROBROOT. Il presupposto è che
almeno una frase di movimento sia selezionata/o.
Piano mirroring
X
Dopo la selezione dell’opzione viene aperta una finestra di dialogo dove occorre indicare il
nome del file nel quale verrà salvato il programma caricato con i punti di traiettoria specchiati.
Premendo il tasto Enter, il processo viene avviato e il programma viene salvato col nome
indicato. Questo programma può essere successivamente caricato nell’editor.
ESC Per annullare l’operazione premere invece il tasto “ESC”.
191 di 214
11.5.2 Inserimento Manuale
Tramite questa funzione è possibile spostare la posizione dei punti di traiettoria programmati nel:
-- sistema di coordinate pezzo (BASE)
-- sistema di coordinate utensile (TCP)
-- sistema di coordinate mondo (WORLD) oppure
-- specifica per asse.
Dopo la selezione di una delle possibili opzioni viene visualizzata una finestra per l’immis-
sione dei valori desiderati. In base al sistema di coordinate occorre inserire o lo spostamento
e l’orientamento oppure gli angoli degli assi.
BASE
Con ‘Shift punti in cartesiano base‘ si intende che un punto qualsiasi nello spazio viene spo-
stato in modo relativo nel sistema di coordinate di origine (WORLD) che si trova nella base
del robot. Il seguente esempio illustra lo shift punti in cartesiano BASE:
Valori di immissione =
valori relativi
--Y [mm]; --X [mm]; A+[°]
Z+
In questo esempio avrebbe

luogo uno spostamento relativo
negativo in X, Y e una rotazione
relativa positiva intorno a Z.
A+
Pnuovo
Y+
X+
Pvecchio --Xr Xvecchio
Yvecchio --Yr
ESC Il vettore di spostamento dev’essere inserito in modo numerico nel relativo campo di immis-
sione. Tramite i tasti cursore “¯ “ e “ “ è possibile spostarsi da un campo di immissione all’al-
tro. Lo spostamento viene avviato con “Istruz. Ok” e può essere annullato in qualsiasi mo-
mento tramite “Abbandona” oppure “Esc”.
Inserire i valori per lo spostamento (X, Y, Z) in [mm] e per l’orientamento (A, B, C) in [gradi]
nei campi di immissione.
192 di 214
TCP
Con ‘Shift punti in cartesiano TCP‘ si intende che un punto qualsiasi nello spazio viene spo-
stato in modo relativo con riferimento al sistema di coordinate TOOL. Il seguente esempio
illustra lo shift punti in cartesiano TCP:
Pnuovo
Zvecchio
--Zr
--Yr Y+
C°r
C°
Pvecchio X+
Yvecchio
Z+ Valori di immissione =
valori relativi
In questo esempio avrebbe luogo uno
--Y [mm]; --Z [mm]; C+[°]
spostamento relativo negativo in Y, Z
e una rotazione relativa positiva in-
torno a X [°].
Uno spostamento relativo in X non
viene preso in considerazione!
Il vettore di spostamento dev’essere inserito in modo numerico nel relativo campo di immis-
sione. Tramite i tasti cursore “¯ “ e “ “ è possibile spostarsi da un campo di immissione all’al-
tro. Lo spostamento viene avviato con “Istruz. Ok” e può essere annullato in qualsiasi mo-
mento tramite “Abbandona” oppure “Esc”.
193 di 214
WORLD
Con ‘Shift punti WORLD‘ si intende che il sistema di coordinate di origine che si trova come
standard nella base del robot viene spostato in modo relativo. Il seguente esempio illustra lo
shift punti WORLD:
valori relativi
+Y [mm]; +X [mm]; A--[°]
Z+
In questo esempio avrebbe luogo

uno spostamento relativo positivo
in X, Y e una rotazione relativa ne- Porg
gativa intorno a Z.
Z+nuovo
Y+
Pnuovo +Xr
X+
X+nuovo
+Yr A--
Y+nuovo
194 di 214
Assi
Con ‘Shift punti assi‘ si intende che un punto qualsiasi nello spazio viene raggiunto tramite un
movimento relativo degli assi. In base alla figura qui rappresentata dev’essere effettuato uno
spostamento relativo dell’asse 5.
Pvecchio
a A5 a A5 vecchio
nuovo
Pnuovo
In questo esempio avrebbe luogo una valori relativi
rotazione relativa positiva dell‘A5 [°]. +A5 [°]
Una rotazione relativa degli altri assi
non viene presa in considerazione!
La rotazione dell’asse dev’essere immessa in gradi o incrementi per il relativo asse. Tramite
i tasti cursore “¯ “ e “ “ è possibile spostarsi da un campo di immissione all’altro. Lo sposta-
mento viene avviato con “Istruz. Ok” e può essere annullato in qualsiasi momento tramite
“Abbandona” oppure “Esc”.
Inserire i valori per gli angoli degli assi (A1 ... A6) in [gradi].
Le immissioni possono essere anche effettuate in modo incrementale (E1--E6)[Inc].
Incrementi = Momenti cinetici degli azionamenti assi
195 di 214
11.5.3 Cambio blocco

Tramite questa funzione è possibile modificare dei dati di movimento nelle parti di
programma selezionate. Per ricordo: La selezione di blocchi viene effettuata tramite
l’azionamento di uno dei due tasti stato “Last” (“Su”) oppure “Next” (“Giù”) e tenendo
contemporaneamente premuto il tasto “SHIFT”.
Dopo il richiamo della funzione appare la finestra illustrata in seguito:
Spostare tramite i tasti cursore “®” oppure “¬” il segno di inserimento da un campo di
immissione all’altro.
Campi di lista vengono aperti tramite la combinazione di tasti “ALT”+“¯” oppure “ALT”+“”.
Dopo aver apportato le modifiche desiderate premere il softkey “Modificare”.
La funzione può essere annullata in qualsiasi momento azionando il softkey “Abbandona”.
11.5.4 Pulizia lista file

Dopo il richiamo di questa funzione vengono cancellati punti di traiettoria e parametri di
movimento non calibrati dal programma appartenente alla lista dati (*.DAT).
196 di 214
11.5.5 Regolazione TCP oppure BASE
Tramite questa funzione è possibile adattare il programma caricato nell’editor ad un altro

sistema di coordinate utensile (TOOL) oppure pezzo (BASE).
Dopo il richiamo della funzione appare la finestra illustrata in seguito. Come esempio è stato
scelto qui la regolazione TCP.
Vengono visualizzati tutti i programmi con i relativi punti che sono interessati dalla
regolazione Tool oppure Base.
Per poter spostare il segno di inserimento da un campo all’altro devono essere attivate le
funzioni di controllo cursore del blocco numerico. Azionare a questo scopo brevemente il
tasto “NUM”. In seguito è possibile spostare il cursore di immissione tramite il tasto “SHIFT”
da un campo all’altro.
Campi di lista vengono aperti tramite la combinazione di tasti “ALT”+“¯”, oppure “ALT”+“”.
Selezionare dal campo di lista nell’area “TargetTCPData” l’utensile al quale dev’essere

adattato il programma caricato. Nei campi di immissione “X=”, “Y=”, “Z=”, “A=”, “B=” e “C=” è
possibile anche inserire manualmente i dati nuovi dell’utensile.
Dopo aver apportato le modifiche desiderate premere il softkey “Change” (“Cambio”). La fun-
zione può essere annullata in qualsiasi momento azionando il softkey “Ende” (“Fine”).
APPUNTI:
197 di 214
11.6 Menù “HotEdit”

Il menù “HotEdit” consente lo spostamento online di coordinate di punti nel sistema di coordi-
nate Tool, Base e World durante l’esecuzione del programma. La voce di menù “Limits” per-
mette una delimitazione dello spostamento.
11.6.1 Base, TCP e World

Posizionare il cursore sulla frase di movimento da spostare oppure evidenziare più frasi di
movimento.
Dopo la selezione di una delle opzioni, sul bordo inferiore del display appare una finestra di
dialogo nella quale è possibile inserire lo spostamento (X, Y, Z) e l’orientamento (A, B, C) per
il relativo sistema di coordinate. La finestra di dialogo qui raffigurata è esemplare per le altre
finestre di dialogo.
Spostare tramite i tasti cursore “” oppure “¯” il segno di inserimento da un campo di
immissione all’altro.
Dopo aver effettuate tutte le immissioni (numeri interi) necessarie per lo spostamento, pre-
mere il softkey “Ok”.
Per terminare l’operazione senza effettuare uno spostamento di programma, premere il soft-
key “Esci”.
In seguito la finestra di dialogo viene evidenziata in grigio e vengono visualizzati due softkey
addizionali.
198 di 214
Ora è possibile l’assegnazione dei valori immessi premendo il relativo softkey. Le modifiche
dei dati non vengono ancora salvate a questo punto e possono quindi essere annullate.
Se avete cambiato idea, l’assegnazione può essere annullata. A questo scopo utilizzare il
softkey indicato a lato. Questo è disponibile soltanto dopo aver assegnato i valori. Questa
funzione è particolarmente utile se un programma si trova in esecuzione e l’effetto dello spo-
stamento puo essere osservato immediatamente.
Se lo spostamento soddisfa le richieste, la modifica delle coordinate di punto può essere sal-
vata nel file “DAT”.
Tramite il softkey “Abbandona” è possibile terminare l’immissione in qualsiasi momento
senza salvare le modifiche.
Se uno dei valori inseriti si trova fuori tolleranza, nella finestra di spostamento programma
appare un avvertimento oppure un messaggio di errore che il valore inserito supera le tolle-
ranze.
199 di 214
11.6.2 Limits
Selezionando la voce di menù “Limits” appare la finestra nella quale sono contenute e pos-
sono essere modificate le tolleranze di spostamento.
Per apportare una modifica portare il cursore tramite i tasti freccia “” oppure “¯” sul punto
desiderato ed inserire la nuova tolleranza tramite il blocco numerico.
Azionare il softkey “OK” per memorizzare i valori e per terminare l’operazione.
Per uscire senza memorizzazione azionare “Cancella”.
APPUNTI:
200 di 214
11.6.3 TTS (Sistema di coordinate di correzione)

Questa funzione serve per l’ottimizzazione di punti nello spazio tramite il treppiedi accompa-
gnante la traiettoria (TTS) e può essere utilizzata per comandi tecnologici (ad es. saldatura
sotto gas inerte, applicazione di colla). La correzione TTS è disponibile a partire dal gruppo
utente “Esperto” e può essere utilizzata in tutti i modi operativi.
Se è selezionato un programma, il menù “Avviamento” non è disponibile. Utilizzare in que-

sto caso il comando menù “Programma” --> “ConfigCorrect” che viene proposto a partire
dal livello esperto.
In seguito viene aperto l’editor esterno ed è possibile apportare le necessarie correzioni.

La correzione di punti online viene considerata soltanto se in quel momento il puntatore
avanzato o principale non ha ancora raggiunto l’istruzione.
Ad ogni correzione di punti vengono cercati nella lista dati locale (*.DAT) i punti necessari. Se
uno dei punti necessari non viene trovato, appare un messaggio di errore.
La ricerca del punto che definisce la direzione della traiettoria inizia sempre dalla posizione
nella quale si trova il punto da correggere in avanti. Ne fa eccezione il punto finale di un profilo
di saldatura o applicazione di colla, poiché in questo caso la ricerca viene effettuata nei nu-
meri di frase inferiori.
Un cambio di base tra due frasi di movimento viene ignorato.
11.6.3.1 Config Point In TTS

Selezionare nell’editor esterno il comando di movimento desiderato e richiamare il comando
“HotEdit” --> “TTS” --> “Config Point In TTS”. In seguito appare la seguente finestra sul
display.
L‘opzione “Config Point In TTS” viene proposta soltanto se è selezionata una frase di movi-
mento per saldatura o applicazione di colla.
201 di 214
Se sono selezionati più comandi di movimento, la correzione si riferisce sempre al primo

comando selezionato.
Utilizzare i tasti cursore “” oppure “¯” per spostare il focus sulla posizione desiderata. Inse-
rire i nuovi valori tramite i tasti del blocco numerico.
Asse X
L’asse X nel sistema di coordinate TTS corrisponde ad un vettore unitario lungo la tangente di
traiettoria.
+Z
+Y P2
+X
+Z
+Y
+X
In caso di comandi LIN,

l’asse X si muove lungo la
traiettoria di movimento
P1
+Z
+Y
+Z
+Y +X
+X
P2
In caso di comandi CIRC,

l’asse X si muove lungo la
P1 tangente di traiettoria
L’asse X del sistema di coordinate utensile non dev’essere parallelo alla tangente di traiet-
toria, altrimenti il sistema di coordinate di correzione non può essere formato. In questo
caso viene emesso un relativo messaggio di errore.
Asse Y
Dal vettore unitario lungo la tangente di traiettoria (+X) e l’asse X del sistema di coordinate
utensile (+XTool) si crea un piano. L’asse Y è perpendicolare a questo piano.
202 di 214
+Z
+Y
+X
+XTool P2
L’asse Y è perpendicolare al
piano che attraversa “+X” e
“+XTool”
P1
Asse Z
Dal vettore unitario lungo la tangente di traiettoria (+X) e l’asse Y (+Y) si crea un piano. L’asse
Z è perpendicolare a questo piano.
+Z
+Y
+X
P2
L’asse Z è perpendicolare al
piano che attraversa “+X” e “+Y”
P1
Correzione punti PTP, LIN
Dopo aver inserito le modifiche nei campi di immissione, premere il softkey “OK”.
softkey indicato a lato. Questo è disponibile soltanto dopo aver assegnato i valori.
Premere nuovamente il softkey “OK” e confermare la successiva domanda di sicurezza per
salvare le modifiche.
203 di 214
Sí No
Tramite il softkey “Abbandona” è possibile terminare l’immissione in qualsiasi momento.
Correzione punti CIRC

Dopo l’immissione delle modifiche assegnare le correzioni al punto ausiliario.
Selezionare con questo softkey il punto di destinazione dopo aver inserito le modifiche nei
campi di immissione.
softkey indicato a lato. Questo è disponibile soltanto dopo aver assegnato i valori.
Se lo spostamento soddisfa le esigenze, è possibile salvare la modifica delle coordinate di
punto confermando la domanda di sicurezza.
Sí No
Tramite il softkey “Abbandona” è possibile terminare l’immissione in qualsiasi momento

senza salvare le modifiche.
204 di 214
11.6.3.2 Limits--TTS
Qui è possibile stabilire i valori limite della correzione TTS. Questi valori limite vengono sor-
vegliati automaticamente durante la correzione di punti.
Le tolleranze ammesse al massimo vengono stabilite tramite il file “C:\KRC\Util\HotE-

dit.ini”. Se viene inserito un valore maggiore, appare un messaggio di errore.
Per la correzione TTS non sono opportuni dei valori limite maggiori di 5mm.
Utilizzare i tasti cursore “” oppure “¯” per spostare il focus sulla posizione desiderata. Inse-
rire la nuova tolleranza tramite i tasti del blocco numerico.
Azionare il softkey “OK” per memorizzare le tolleranze.
Se non si desiderano salvare i valori, azionare “Abbandona”.
205 di 214
11.7 Menù “ExtUtil”

Qui vengono proposte funzioni per il mirroring di assi, lo spostamento e il settaggio dei fine-
corsa software.
2 Punti
6 Punti
Questo menù è disponibile soltanto finché non è caricato nessun programma nell’editor
esterno.
11.7.1 File -- Mirror
A differenza della funzione “Mirroring” (paragrafo 11.5.1) tramite la quale è possibile rispec-
chiare dei punti di traiettoria evidenziati di frasi di movimento selezionate, la funzione “File--
Mirror” consente il mirroring di programmi di movimento completi.
Dopo l’avvio della funzione indicare dapprima il file di origine da rispecchiare.
Selezionare tramite i tasti cursore “"” oppure “#” un file per il mirroring.
Dopo aver evidenziato il file desiderato, azionare il softkey “Freccia destra”.
206 di 214
Inserire per il file rispecchiato una denominazione composta al massimo di 8 caratteri.

Tramite questo softkey si ritorna all’ultima pagina sulla quale è possibile selezionare un altro
file di origine.
Dopo aver inserito il nome del file desiderato, azionare questo softkey.
207 di 214
Ora esiste la possibilità di inserire un commento che sarà visualizzato nel navigator.
Tramite questo softkey si ritorna all’ultima pagina sulla quale è possibile inserire il nome del
file (rispecchiato) da creare.
Dopo aver inserito il commento desiderato, azionare questo softkey.
Successivamente viene creato il relativo programma. Ora è possibile sfogliare all’indietro tra-
mite il softkey “Freccia sinistra”, ad esempio per creare un altro programma o per modificare
il commento.
Inoltre esiste la possibilità di uscire dalla funzione “File--Mirror”. Utilizzare a questo scopo il
softkey “Chiudere”.
208 di 214
11.7.2 File -- Shift

Tramite questa funzione è possibile spostare la posizione dei punti di traiettoria contrasse-
gnati con l’ausilio di un vettore (2 punti), oppure spostarla e contemporaneamente ruotare il
sistema di coordinate che è alla base (6 punti).
Shift 2 punti
Per la funzione spostamento 2 punti dev’essere insegnato un file di riferimento (nome qual-
siasi; .src, .dat). In questo file di riferimento vengono depositati due punti. Questi punti defini-
scono il vettore di spostamento (X, Y, C) del quale i punti selezionati vengono spostati.
Shift 6 punti
La funzione spostamento 6 punti applica lo stesso principio. Nel relativo file di riferimento
devono essere insegnati sei punti in totale. I primi tre punti definiscono la base sorgente, gli
ultimi tre punti una base di destinazione. Per la sorgente e la destinazione occorre rilevare
i punti identici. Tramite questi valori vengono calcolate le basi. Lo spostamento e l’orienta-
mento tra la base sorgente e quella di destinazione determinano il valore del quale dev’es-
sere effettuato lo shift dei punti evidenziati.
Il vettore dev’essere già stato memorizzato in un file prima del richiamo della funzione.
Inoltre devono essere selezionate le frasi di movimento da spostare.
Dopo la selezione dell’opzione spostamento 2 punti oppure 6 punti, il programma richiede

l’indicazione del relativo file di riferimento.
A questo punto esistono le seguenti possibilità:
209 di 214
11.7.2.1 Utilizzare il file di riferimento esistente

Questo softkey consente di indicare un file di riferimento e un file da spostare.
Selezionare dapprima il file di riferimento tramite i tasti cursore ed azionare in seguito il soft-
key “Freccia destra”.
Tramite questo softkey si ritorna alla pagina precedente.
Utilizzare di nuovo i tasti cursore per evidenziare il file da spostare. Premere in seguito nuo-
vamente il softkey “Freccia destra”.
210 di 214
Il file da spostare viene successivamente caricato nell’editor. Evidenziare qui i comandi di

movimento da spostare.
Azionare nuovamente il softkey “Freccia destra”. Successivamente i punti selezionati ven-

gono spostati nel file. L’avanzamento del processo viene visualizzato sopra la finestra dei
messaggi.
Nella finestra dei messaggi viene visualizzato l’esito dell’operazione.
211 di 214
11.7.2.2 Creare un nuovo file di riferimento

Tramite questo softkey viene creato un nuovo file di riferimento. In seguito viene selezionato que-
sto nuovo programma di riferimento affinché l’operatore possa insegnare i punti necessari.
Deselezionare il programma dopo l’insegnamento ed avviare nuovamente l’editor esterno.

Procedere come descritto nel paragrafo 11.7.2.1.
212 di 214
11.7.3 Settaggio limiti software
Tramite questa funzione è possibile adattare i finecorsa software dei singoli assi ai
programmi di movimento.
A questo scopo avviare la funzione “Settaggio limiti software” e ritornare successivamente
tramite il tasto di selezione finestra all’interfaccia grafica del software robot. Lì possono es-
sere avviati i programmi di movimento i cui valori degli assi vengono monitorati in back-
ground. Dopo aver eseguito tutti i programmi rilevanti, richiamare la funzione. I valori così
rilevati possono essere settati come finecorsa software.
Le posizioni degli assi vengono monitorate in background finché la funzione “Settaggio

limiti software” è attiva.
I valori minimi e massimi che si sono presentati, nonché le posizioni attuali degli assi A1 ... A6
vengono inseriti nei relativi campi.
Tramite un checkbox è possibile contrassegnare gli assi per i quali devono essere settati i
finecorsa. Per la selezione degli assi desiderati utilizzare i tasti cursore. La barra spaziatrice
consente l’inserimento oppure il disinserimento del relativo asse. Un segno di spunta signi-
fica che per quell’ asse è possibile settare il finecorsa software.
Tramite “Reset”, i finecorsa software possono essere resettati sui loro valori originari.
Premendo il softkey “Set” vengono settati i nuovi finecorsa software degli assi selezionati.
Questa operazione può essere annullata in qualsiasi momento, anche in un secondo tempo,
premendo il softkey “Reset”.
Ai valori degli assi misurati viene sommato un valore tampone di 5°.
213 di 214
11.8 Menù “Aiuto”

In questo menù è disponibile un’interrogazione di versione, nonché un’opzione di visualizza-
zione.
11.8.1 Versione
Nella finestra dei messaggi viene visualizzato il numero di versione dell’editor esterno.
Numero di versione
11.8.2 In primo piano

Dopo la selezione di questa opzione, l’interfaccia grafica del software robot non va più in
primo piano finché si esce dall’editor.
APPUNTI:
214 di 214
Index
Simboli $VEL.CP, 78
.ERR, 13 $VEL.ORI1, 78
!, 108 $VEL.ORI2, 78
!--carattere, 104 $VEL_AXIS, 66
?, 109 $WORLD, 63, 70
:, 110
# -- carattere, 41
A
#BASE, 65, 80
#CONSTANT, 79 A10.DAT, 8
#INITMOV, 79, 80 A10.SRC, 8
#PATH, 80 A10_INI.DAT, 8
#TCP, 65 A10_INI.SRC, 8
#VAR, 79 A20.DAT, 8
$ -- carattere, 55 A20.SRC, 8
$ACC.CP, 78 A50.DAT, 8
$ACC.ORI1, 78 A50.SRC, 8
$ACC.ORI2, 78 ABS(X), 52
$ACC_AXIS, 66 Accelerazione, 78
$ADVANCE, 87 Accelerazioni degli assi, 68
$ALARM_STOP, 55, 56 ACOS(x), 52
$APO.CDIS, 94, 97 Aggregato, 38
$APO.CORI, 94, 97 Ambiguità, 74
$APO.CPTP, 91 Angolo circolare, 85
$APO.CVEL, 94, 97 ANIN, 143
$APO_DIS_PTP, 91 ANIN OFF, 143
$BASE, 63, 70 ANIN ON, 143
$CIRC_TYPE, 80, 83 ANIN/ANOUT, 140
$CONFIG.DAT, 8, 57 ANOUT OFF, 140
$CUSTOM.DAT, 56
ANOUT ON, 140
$CYCFLAG, 55
Apprendimento di punti, 104
$FLAG, 54
Approssimazione, 90
$IBUS_ON, 56
Approssimazione CIRC--CIRC, 97
$IPO_MODE, 65
Approssimazione CIRC--LIN, 97
$MACHINE.DAT, 8, 56
Approssimazione LIN--CIRC, 99
$NULLFRAME, 70
Approssimazione LIN--LIN, 94
$NUM_AX, 56
Approssimazione PTP--PTP, 91
$ORI_TYPE, 79, 83
Approssimazione PTP--traiettoria, 100
$OUT_C, 135
$POS_ACT, 64, 65 Approssimazione traiettoria--PTP, 100, 101
$PRO_MODE, 23 Aprire tutti i FOLDs, 20
$PSER, 56 Arcocoseno, 52
$ROBCOR.DAT, 8, 57 Arcoseno, 52
$ROBROOT, 63, 70 Arcotangente, 52
$SET_IO_SIZE, 135 ARCSPS.SUB, 8
$TIMER, 54 Arresto automatico del processo avanzato, 88
$TIMER_FLAG, 54 Arresto del processo avanzato, 88, 129
$TIMER_STOP, 54 Assegnazione valore, 29
$TOOL, 63, 70 ATAN2(Y,X), 52
Index -- i
Index
Attivare interrupt, 158 Connessione di frame, 43

AXIS, 40, 60, 109 Connessione logica, 48
Azione di commutazione, 171 CONTINUE, 89
Continuous Path, 78
Controllo dell’esecuzione del programma, 117
B
Copia, 15
B_AND, 49, 51
Correlatore, 13
B_EXOR, 49, 51 Correzione programma, 15
B_NOT, 49, 51 COS(X), 52
B_OR, 49, 51 Costante + riferito alla traiettoria , 80
BAS.SRC, 8, 72 Costante + riferito allo spazio, 82
BASE, 65 Criterio di distanza, 94
Bidimensionale, 36 Criterio di orientamento, 94
Bin Dec, 34 Criterio di velocità, 94
BOOL, 33, 34 CSTEP, 23
BOSCH.SRC, 8 CTRL--C, 15
BRAKE, 162 CTRL--V, 16
CTRL--X, 16
C Cursore di editazione, 107
C_DIS, 94, 97, 111

C_ORI, 94, 97, 111 D
C_PTP, 91, 111 DECL, 31
C_VEL, 94, 97, 111 DEF, 10, 147
CA, 85 DEFDAT, 177
Cambio blocco, 196 DEFFCT, 148
Cambio utensile, 103 Dichiarazioni, 10
Campi, 35 DIGIN, 145
Campo bidimensionale, 36 DIGIN OFF, 145
Campo tridimensionale, 37 DIGIN ON, 145
Campo unidimensionale, 35 Diramazioni di programma, 117
Cancella, 16 Disabilitare / Abilitare, 158
Catena cinematica, 64, 65 Disattivare interrupt, 158
Catene di caratteri, 38 Disgiunzione, 49
CELL.DAT, 8 DISTANCE, 168
CELL.SRC, 8, 9 Durata, 30
CHAR, 33, 35
Chiudere tutti i FOLDs, 20 E
Cinematiche robot ambigue, 74 E6AXIS, 40, 109
CIRC, 85, 115 E6POS, 109
CIRC !, 104 Editare, 13
CIRC REL, 115 Editor, 15
CIRC_REL, 85 Editor esterno, 181
Coincidenza frase, 73 ELSE, 118
Commenti, 28 END, 10
Compilare, 13 ENDFOLD, 20
Compilatore, 13 ENDFOR, 120
Concetto dei file, 10 ENDLOOP, 125
CONFIRM, 128 ENDWHILE, 122
Index -- ii
Index
ENUM, 40 Inizio di approssimazione, 94

Esa Dec, 34 Inserimento Manuale, 192
EXIT, 125 INT, 33
EXT, 72 Interpolazione riferita al gripper, 65
Interpolazione riferita alla base, 64
Interrupt, 156
F
Inversione, 49
File di sistema, 54
IR_STOPM.SRC, 8
Filtrare bit, 50
ISTEP, 23
Flags, 55, 166
Istruzione di salto, 117
Flags ciclici, 55
Istruzioni, 10
FLT_SERV.DAT, 8
Istruzioni di attesa, 126
FLT_SERV.SRC, 8
Istruzioni di immissione/emissione, 129
FOLD, 20
Istruzioni di movimento, 59
Fold, 20
FOLD attuale ap./ch, 20
FOR, 120
K
Frame, 40, 109 KRL assistent, 107
Funzioni, 10, 147 KUKA--Robot--Language, 107
Funzioni di blocco, 15
L
G Limits--TTS, 205
Gestione dell’orientamento, 79 LIN, 84, 113
Gestione errori, 25 LIN !, 104
GLOBAL, 179 LIN REL, 113
Globale, 148 LIN_REL, 84
GO, 23 Linguaggio macchina, 13
GOTO, 117 Lista di parametri, 150
Liste dati, 10, 177
Liste dati globali, 178
H Liste dati locali, 177
H50.SRC, 8 Locale, 148
H70.SRC, 8 Loop, 120, 125
HALT, 127 Loop continuo, 125
Loop di conteggio, 120
I Loop non respingente, 123
Loop respingente, 122
Identificativo dei blocchi, 119
IF, 118
Importo, 52 M
Incolla, 16 Manipolazione dei dati, 42
Indicazione della posizione, 109 Mascherare bit, 50
Indice, 35 MERKER, 117
Indice di campo, 35 Mirror, 191
Ingressi analogici, 143 Misurazione veloce, 165
Ingressi digitali, 145 Modi di esecuzione programma, 23
Ingressi/uscite binari, 130 Modifica di programmi, 15
Ingressi/uscite digitali, 133 Movimenti approssimati, 90
INI, 72 Movimenti circolari, 85
Index -- iii
Index
Movimenti CP, 78 PTP REL, 111

Movimenti da punto a punto, 66 PTP sincrono, 66
Movimenti lineari, 84 PTP_REL, 69
Movimenti lungo la traiettoria, 78 PUBLIC, 178
Movimento Home, 73 Pulizia lista file, 196
MSG_DEMO.SRC, 8 PULSE, 138
MSTEP, 23 Punto radice del polso, 74
Punto separatore, 38
N
R
Nascondere parti di programma, 20
Radice, 52
NEW_SERV.SRC, 8
REAL, 33, 34
Nomi, 29
Regolazione BASE, 197
Regolazione TCP, 197
O REPEAT, 123
Oggetti di dati, 31 RESUME, 163
Operando, 42
Operatore, 42 S
Operatore geometrico, 43 S e T, 73
Operatore geometrico “:”, 110 SAK, 73
Operatori aritmetici, 42 Salto condizionato, 118
Operatori bit, 49 Seno, coseno, tangente, 52
Operatori di confronto, 47 Sezione delle dichiarazioni, 10
Operatori logici, 48 Sezione delle istruzioni, 10
Operazione AND, 49 SIGNAL, 130
Operazione di anticoincidenza, 49 SIN(X), 52
Singolarità di cinematica, 73
P Sistema binario, 33
Sistema decimale, 33
P00.DAT, 8
Sistema di coordinate, 59, 70
P00.SRC, 8
Sistema di coordinate BASE, 64
Parametri di movimento, 105
Sistema di coordinate di correzione, 201
Passaggio di parametri, 150
Sistema di coordinate mondo, 63
PERCEPT.SRC, 9 Sistema di coordinate robot, 63
POS, 40, 109 Sistema di coordinate specifico per asse, 59
Posizione zero meccanica, 68 Sistema di coordinate utensile, 63
Priorità, 51, 158, 167, 171 Sistema esadecimale, 33
Priorità di operatori, 51 Sostituisci, 17
Processo avanzato, 87 Sottoprogrammi, 10, 147
Processo avanzato del calcolatore, 87 Sovrapporre bit, 50
Processo principale, 87 SPS.SUB, 8
Profilo di approssimazione, 90 SQRT(X), 52
Profilo di traslazione superiore, 67 Status, 70, 73
Programmazione del movimento, 59 Stesura di un nuovo programma, 12
PROKOR, 15 Stesura ed editazione di programmi, 12
PSTEP, 23 STRUC, 38
PTP, 66, 69, 111 Struttura del file, 10
PTP !, 104 Struttura e stesura di programmi, 7
Index -- iv
Index
Strutture, 38 Variabili e nomi, 29

Strutture predefinite, 40 Velocità, 78
SWITCH, 119 Velocità degli assi, 68
T
Taglia, 16 W
TAN(X), 52 WAIT, 126
TCP, 65 WEAV_DEF.SRC, 9
Tieniposto, 108
WHILE, 122
Timer, 54
Tipi di dati geometrici, 40
Tipi di dati semplici, 33 Z
Tipi di enumerazione, 40 Zona base, 74
Tipo di dati, 31
Zona sopratesta, 74
Tool Center Point, 66
Touch Up, 109
Trasformazione di coordinate, 60
Trasformazione di coordinate cartesiana, 60
Trasformazione in avanti, 60
Trasformazione indietro, 60
Traslazioni, 62
Trattamento interrupt, 155
Treppiedi accompagnante la traiettoria, 201
Tridimensionale, 37
Trigger, 167
Triggerato al fronte di salita, 158
TTS, 201
Turn, 70, 73
U
Unire, 13
UNTIL, 123
Uscite a impulso, 138
Uscite analogiche, 140
USER_GRP.DAT, 9
USER_GRP.SRC, 9
USERSPOT.SRC, 9
Utensile fisso, 65
V
VAR, 108
Variabile + riferito alla traiettoria, 80
Variabile + riferito allo spazio, 83
Variabile globale, 179
Variabili di sistema, 54
Variabili e dichiarazioni, 29
Index -- v

Proghbexperte r41 It

Caricato da

Informazioni sul documento

Descrizione:

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Descrizione:

Copyright:

Formati disponibili

Proghbexperte r41 It

Caricato da

Descrizione:

Copyright:

Formati disponibili

SOFTWARE

ProgHBExperte R4.1 08.01.00 it

ProgHBExperte R4.1 08.01.00 it

1 Generalità per quanto riguarda i programmi KRL . . . . . . . . . . . . . . . . . . . 7

3 Programmazione del movimento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

ProgHBExperte R4.1 08.01.00 it

3.2 Movimenti da punto a punto (PTP) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

4 KRL assistent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

5 Controllo dell’esecuzione del programma . . . . . . . . . . . . . . . . . . . . . . . . . 117

6 Istruzioni di immissione/emissione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

ProgHBExperte R4.1 08.01.00 it

7 Sottoprogrammi e funzioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147

8 Trattamento interrupt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

9 Trigger -- Azioni di commutazione riferite alla traiettoria . . . . . . . . . . . . 167

10 Liste dati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177

11 Editor esterno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

ProgHBExperte R4.1 08.01.00 it

11.5.4 Pulizia lista file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

ProgHBExperte R4.1 08.01.00 it

1 Generalità per quanto riguarda i programmi KRL

ProgHBExperte R4.1 08.01.00 it

Nella directory “KRC:\R1\SYSTEM\” si trovano i seguenti file:

Nella directory “KRC:\R1\TP\” si trovano i seguenti file:

ProgHBExperte R4.1 08.01.00 it

PERCEPT.SRC Programma per il richiamo del protocollo PERCEPTRON

Nella directory “KRC:\R1\” si trova il seguento file:

CELL.SRC Programma per il controllo di robot tramite un PLC centrale. In

ProgHBExperte R4.1 08.01.00 it

1.1.2 Concetto dei file

Ulteriori informazioni sulla stesura di un programma sono contenute in questo capitolo,

1.1.3 Struttura del file

Informazioni dettagliate su sottoprogrammi e funzioni sono contenute nel capitolo [Sotto-

ProgHBExperte R4.1 08.01.00 it

ProgHBExperte R4.1 08.01.00 it

1.2 Stesura ed editazione di programmi

I templates disponibili non possono essere creati in tutte le directory.

I differenti templates in dettaglio:

ProgHBExperte R4.1 08.01.00 it

Nome del file Estensione del file Commento

1.2.2 Editare, compilare e unire un programma

Affinché il programma rimanga chiaro e comprensibile, occorre ad es. in caso di dira-

Soltanto programmi privi di errori possono essere selezionati ed eseguiti.

ProgHBExperte R4.1 08.01.00 it

E’ possibile anche scrivere un programma KRL tramite un normale editor di testo e

In seguito un semplice programma di esempio per la determinazione delle velocità e delle

;----- Sezione delle dichiarazioni -----

;------ Sezione delle istruzioni -------

$ACC_AXIS[1]=100 ;Determinazione delle accelerazioni degli assi

PTP {A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}

PTP {A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}

ProgHBExperte R4.1 08.01.00 it

1.3 Modifica di programmi

1.3.1 Correzione programma

1.3.2.1 Funzioni di blocco

1.3.2.2 Copia (CTRL--C)

ProgHBExperte R4.1 08.01.00 it

1.3.2.3 Incolla (CTRL--V)

Selezionare ora l’opzione “Incolla”. La parte di programma selezionata precedentemente

1.3.2.4 Taglia (CTRL--X)

ProgHBExperte R4.1 08.01.00 it

G Abbandona L’azione “Cancella” viene cancellata.