N...!... ...! Abbiamo visto che con le righe ISO si potevano ottenere tutte le funzioni di macchina.
Con le righe evolute, che non provocano direttamente nessuna funzione di macchina, si ottiene un più flessibile controllo dello svolgimento del programma, la possibilità di eseguire salti di istruzioni ecc.
Le righe evolute possono avere un numero di blocco (N...) come le righe ISO.
Le righe evolute si distinguono dalle righe ISO per il punto esclamativo che segue immediatamente l'eventuale numero di blocco.
Una riga può essere o tutta evoluta o tutta ISO. Nella stessa riga quindi NON POSSONO COESISTERE parti ISO e parti evolute.
Separatori Le righe evolute sono divise in 'campi', ognuno dei quali esegue una operazione elementare. I ;! vari 'campi' sono separati tra loro dal carattere '!' oppure ';'. La differente funzione del '!' e del ';' si vedrà alla descrizione della funzione IF (vedere più avanti paragrafo “Condizionamenti”).
I vari campi sono eseguiti nello stesso ordine in cui sono scritti. Nei paragrafi che seguono si dà il dettaglio delle istruzioni che possono costituire un campo di riga evoluta.
Definizione di parametri con calcolo di espressioni Abbiamo visto che è possibile, durante la normale programmazione ISO, assegnare a un parametro il valore che risulta dal calcolo di una espressione.
Segno Ciò è possibile anche in un campo di riga evoluta. In questo caso, dopo l'indirizzo del
di ‘=‘ parametro si deve inserire il carattere '=' e poi l'espressione. L'espressione può essere anche un semplice valore numerico. Per esempio:
N14 !X=100! significa: assegna al parametro X il valore numerico 100
N14 !X=100-2*R! significa: assegna al parametro X il valore 100 meno il diametro utensile (due volte il raggio).
Si noti che in questo caso (contrariamente a quanto accade in una riga ISO) non si ha un movimento dell'asse X alla quota 100 (o 100-2*R): l'effetto di questo campo evoluto è solo quello di assegnare al parametro X il valore 100 (o 100-2*R).
Se successivamente, in una riga ISO, si programma X<X> , si ha una riconferma del valore assegnato a X nella riga evoluta e anche il movimento fino al valore finale
Conversione cartesiane/polari e viceversa !HX=..; Con il campo: !CP! si ottiene la conversione dei parametri HX e HY, rappresentanti due HY=..; coordinate cartesiane, nei corrispondenti in coordinate polari HR (raggio) e HT (angolo CP! trigonometrico in gradi).
Dopo questo campo HR e HT contengono il risultato, HX e HY rimangono invariati. Per esempio dopo la riga:
N10!HX=1;HY=1;CP! si ottiene: HR = 1,4142... HT = 45
Con il campo: !PC! si ottiene la conversione inversa.
Per esempio dopo la riga:
N10!HR=10;HT=30;PC! si ottiene: HX = 8,6602... HY = 5
Non è necessario che HX, HY, HR, HT, siano programmati nella stessa riga che contiene CP o PC: essi possono essere programmati o determinati con calcolo anche in righe precedenti, ISO o evolute.
SALTI Sono possibili cinque tipi di salto: - salto a una riga senza ritorno (GON...) - salto a una serie di righe con ritorno (GON...-N...) - salto a sottoprogramma con ritorno GOP...) - salto ad una riga all’interno di un sottoprogramma (GOP…-N…) - salto ad una serie di righe all’interno di un sottoprogramma (GOP…-N…-N…)
Il numero di riga o il numero di programma possono essere parametrizzati (vedi paragrafo dedicato più avanti su questo capitolo).
Salto a una riga senza ritorno Questa istruzione comanda allo Z32 di saltare a un'altra riga specificata. Per es. N14 !GON64! fa saltare il CN alla riga N64. Il numero di riga da ricercare deve essere ad inizio riga e deve essere scritto esattamente con la stessa sequenza di caratteri con cui viene ricercato.
Per esempio:
%N0 X0 si deve ricercare come !GO%N0!
N 47G1... si dovrà ricercare con lo spazio intermedio: !GON 47!
/N38M6 si deve ricercare con !GO/N38!
Il salto alla riga indicata avviene immediatamente non appena viene eseguito il campo che contiene il salto.
!EB! end bloc
5.2.2
Per esempio:
N14!X=100;Y=-11,5!GON36!
viene eseguita nel seguente ordine: a) assegna al parametro X il valore 100 ; b) assegna al parametro Y il valore -11,5 ; c) salta alla riga N36
N14 !GON36! X=100! Y=-11,5!
viene eseguita così: a) salta alla riga N36 ; b) non sono variati i parametri X e Y
Questa prestazione serve, come si vedrà dopo, per condizionare l'esecuzione di campi a situazioni particolari.
Caso particolare di salto senza ritorno è la interruzione della esecuzione di una riga evoluta, ottenuta col campo: !EB!
Quando viene incontrato questo particolare campo la esecuzione della riga viene interrotta e l'esecuzione prosegue dalla riga successiva. Esempio:
... N10!IFHA>=10;EB!GON5! N11...
Se HA è minore o uguale a 10 viene eseguito lo EB e quindi il programma prosegue con la riga N11, altrimenti viene eseguito il salto a N5. (Vedere anche paragrafo “Condizionamenti” più avanti.
Agli effetti del ritorno da serie di righe, la riga in cui viene eseguito EB è da considerarsi completata (vedere prossimo paragrafo “Salto a una serie di righe con ritorno”).
Salto a una serie di righe con ritorno
Questa istruzione ordina allo Z32 di continuare l'esecuzione del programma con una serie di righe specificate: dopo l'esecuzione dell'ultima riga specificata deve proseguire con la riga successiva a quella in cui è contenuta questa istruzione. Esempio:
!GON120-N381!
chiede al CN di saltare alla riga 120 e di continuare l'esecuzione fino alla riga 381. Dopo aver eseguito la riga 381 il CN deve proseguire dalla riga successiva a quella contenente questa istruzione.
Dentro le righe richiamate possono esserci altri salti e altri richiami a serie di righe.
Non è necessario che il numero di riga fine sia maggiore del numero di riga inizio, purché la riga fine sia raggiungibile partendo dalla riga inizio.
Se la riga fine contiene un salto (deve essere con un GO...) che viene eseguito il ritorno non viene fatto.
Per esempio:
...
N10 G0 X0
...
N20 !HA=HA+1!IFHA<10;GON15!
...
N30 !GON10-N20!
N31...
Qui in N30 si ha una ripetizione delle righe da N10 a N20, e in N20 c'è un salto a N15 condizionato da un parametro: finche il salto della riga N20 viene eseguito non c'è il ritorno dalla serie di righe N10-N20, ma quando il salto non viene più eseguito (HA è diventato 10) si ha il ritorno a N31.
L'uso di questa caratteristica è da considerare riservato a programmatori esperti: in un primo tempo si consiglia di evitare salti nella riga fine di una serie di righe. Lo stesso programma precedente poteva essere più chiaramente scritto:
...
N10 G0 X0
...
N20 !HA=HA+1!IFHA<10;GON15!
N21
...
N30 ! GON10-N21 !
N31 ...
L'aggiunta della riga N21 vuota, da usare come riga fine, toglie ogni possibile equivoco sul comportamento dello Z32. Se invece la riga fine, contiene un salto implicito (per esempio un ciclo fisso o una M speciale), il ritorno dalla serie di righe viene fatto dopo l'esecuzione del sottoprogramma di servizio. Per esempio:
...
N9 G27C1
N10 G0 X50 Y10
...
N20 X65 Y20
...
N29 G27C4
N30 !GON10-N20!
N31 ...
La riga N20 contiene un salto implicito al ciclo fisso (è il c.f. 1 al primo giro e il 4 al secondo giro): al secondo giro il salto al sottoprogramma ciclo fisso viene regolarmente eseguito giro e alla fine del ciclo fisso si ha il ritorno alla riga N31.
È lecito che la riga fine coincida con la riga inizio (viene eseguita una sola riga). I salti con ritorno possono essere fatti all'interno di altri salti con ritorno fino ad una profondità di 10 livelli. Oltre il limite consentito lo Z32 dà allarme: CN 2E14 TROPPE SUBROUTINES. Sono da considerare salti con ritorno e quindi consumano un livello: - GON...-N... salto a serie di righe - GOP... salto a sottoprogramma - M speciale - G27C... ciclo fisso di sistema o utente - G27P... sottoprogramma permanente Il numero di livello è scaricato di 1 ad ogni ritorno da sottoprogramma o serie di righe, per cui è normalmente impossibile raggiungere il massimo consentito.
La G110 (macrofunzioni di svuotatura) consuma due livelli.
Nell'esempio che segue è indicato in pratica come si possono usare richiami di serie di blocchi.
Scopo del programma è di scavare una finestra rettangolare con percorso del centro fresa. Devono essere fatte due passate con incremento in Z di 5 mm.
% N0 G25XYZ T100 M6 in T100 sono già definiti F200 S1000 N1 Z0 M3 posiziona Z e start mandrino N2 G0 X0 Y0 posiziona XY a sinistra in basso N3 G1 Z<Z-5> prima discesa in Z N4 Y<Y+10> primo incremento in Y N5 X 100 prima passata in X+ N6 Y<Y+10> secondo incremento in Y N7 X0 seconda passata in XN8 !GON4-N7! ripete N9 Y0 rifila lato sinistro N10 X100 completa lato inferiore N11 Y40 rifila lato destro N12 !GON2-N11! completa seconda passata N13 M2 fine Si noti che durante l’esecuzione del salto di N12 si incontra un altro salto con ritorno: ciò significa che il programma dell'esempio ha una profondità di due livelli.
Si faccia attenzione che il ritorno da serie di righe è effettuato solo se la riga fine non contiene un salto esplicito che deve essere eseguito (con 'GO').
L'istruzione 'EB' e i salti impliciti a sottoprogrammi (cicli fissi, M speciali ...), anche se eseguiti non impediscono il ritorno da serie di righe.
Esempio di programma errato:
N1!GON10-N30!
... N10X0 N20Y10 N30!GON56! ...
Il ritorno dalla riga 30 non viene mai effettuato perché la riga viene interrotta per un salto a un'altra riga.
!GOP10!
Salti a sottoprogrammi
Con questo tipo di istruzione lo Z32 abbandona momentaneamente il programma in corso per eseguire un altro programma inserito nella memoria, ossia è 'richiamato' un sottoprogramma.
Il programma chiamato deve iniziare col solito % e deve terminare con G26 (fine sottoprogramma).
Il % iniziale del sottoprogramma non fa il reset delle condizioni memorizzate (origini, parametri, 'G', 'M' ecc.): ha il solo effetto di segnalare che è terminato un eventuale titolo del sottoprogramma e che iniziano le istruzioni operative.
Esempio:
!GOP96!
Salta al sottoprogramma 96 della memoria, lo esegue e alla fine, dopo il G26 che chiude il sottoprogramma 96, torna ad eseguire la riga successiva.
L'istruzione !GOP...! consuma un livello di salto con ritorno: sono possibili fino a 10 livelli di salto, comprensivi di: - GON...-N... - M speciali - G27C... cicli fissi di sistema e utente - G27P... sottoprogrammi permanenti
L'utilità di questo tipo di istruzione è strettamente collegata alla programmazione parametrica.
Si possono infatti mantenere in memoria una quantità di sottoprogrammi standard (da semplici figure geometriche a più complesse lavorazioni) con alcuni parametri non definiti per adattarsi alle varie condizioni in cui i sottoprogrammi verranno usati.
Sarà sufficiente che il programmatore definisca i parametri nel suo programma principale e che poi richiami il sottoprogramma voluto, senza scrivere nuove istruzioni ed utilizzando invece programmi già provati e quindi esenti da errori.
Nell'esempio che segue è descritto un semplice sottoprogramma per la rifilatura esterna di un rettangolo. I parametri da passare al sottoprogramma sono:
XA YA lati del rettangolo
XB YB quote del vertice in basso a sinistra
ZA quota di lavoro terzo asse
Si ammette che il programma principale arrivi alla istruzione che richiama il sottoprogramma con l'utensile giusto sul mandrino e che quindi siano già definiti i parametri R (raggio fresa), F (feed), S (speed).
Il sottoprogramma è generico per qualsiasi terna di lavoro (non necessariamente XYZ).
Programma principale: ... N20 XA50 YA80 XB0 YB0 ZA-20 si definiscono i parametri N21 !GOP90! ... Sottoprogramma 90: '
%N1G0AA<XB-R>AB<YB-R> posiziona sul vertice, compensa lutensile N2 G1 AC<ZA> scende col terzo asse N3 AB<AB+YA+2*R> rifila lato sinistro N4 AA<AA+XA+2*R> rifila lato superiore N5 AB<YB-R> rifila lato destro N6 AA<XB-R> G26 rifila lato inferiore e fine
Parametrizzazione dei salti a riga e a sottoprogramma Le istruzioni Z32 che permettono salti di riga e di programma sono normalmente: !GOP4! salto a sottoprogramma 4 con ritorno !GON45,3! salto alla riga N45,3 senza ritorno !GON33-N45! salto alla serie di righe N33 - N45 con ritorno Dalla versione software del 5.1.93 i numeri di riga e di sottoprogramma possono essere anche programmati con una espressione parametrica. per esempio:
Il nuovo modo di programmare il numero destinazione è caratterizzato dalle parentesi acute aperta e chiusa che racchiudono l'espressione parametrica. Senza parentesi acute è valido il modo vecchio.
Qualsiasi espressione ammessa dallo Z32 può essere contenuta tra le parentesi acute.
Nel caso di GOP il risultato dell'espressione viene preso in valore assoluto e arrotondato all'intero più vicino.
Nel caso di GON la riga destinazione deve iniziare con "N" seguito dal numero di riga, senza spazi né iniziali né intermedi.
Se il risultato dell'espressione è frazionario viene arrotondato alla 3.a cifra decimale per risultati fino a 4 interi e alla 2.a cifra decimale fino a 5 interi. Il carattere che separa gli interi dai decimali è la virgola (se la riga destinazione ha il punto decimale non viene trovata).
Gli zeri iniziali prima della virgola e finali dopo la virgola sono soppressi. Se il risultato arrotondato ha tutti zeri dopo la virgola anche la virgola decimale è soppressa.
Gli esempi che seguono mostrano alcune delle combinazioni possibili.
È possibile eseguire un salto a un sottoprogramma specificando il numero di riga iniziale o anche un numero di riga iniziale e finale. Queste prestazioni possono facilitare la scrittura di macro. Sintassi:
!GOPx-Ny! !GOPx-Ny-Nz!
Dove x è il numero di programma a cui saltare, y è il numero di riga da cui deve iniziare l'esecuzione, z è il numero di riga a cui deve terminare l'esecuzione. I tre valori x y z sono numeri oppure, se racchiusi tra parentesi acute, risultato di espressioni. Se y e z sono programmati con espressioni ci sono le solite limitazioni sulla programmazione di N nelle righe destinazione: - non devono esserci spazi o altri caratteri iniziali - non devono esserci spazi tra la N e il numero di riga - per separare i decimali deve essere usata la virgola e non il punto - i decimali non devono essere più di 3 Se P è programmato con espressione il numero deve essere intero positivo. Se non è intero il numero è arrotondato all'intero più vicino. Esempi:
!GOP3-N35! !GOP3-N35-N82! !GOP<HX>-N<HY>-N<HZ>! !GOP<1+HA>-N<(HX+42)/8>-N<HY*2>! (si spera che così non si usi mai!)
Campo G26, fine sottoprogramma per DNC Con il campo: “G26”, del tutto identico al G26 di riga ISO, che quindi determina la fine del sottoprogramma in corso con ritorno al programma chiamante si risolve un particolare problema in DNC.
Si ha un programma molto lungo, da eseguire quindi in DNC. Il programma deve poter essere interrotto in punti determinati se la logica di macchina lo richiede. La logica di macchina fornisce il parametro PAL[5]=64 se il programma deve essere interrotto.
Nel part-program da eseguire in DNC si scriverà:
...
!IF PAL[5]=64;G26!
... (continua il DNC se PAL[5] diverso da 64)
oppure:
...
!IF PAL[5]<>64;EB!G26!
... (continua il DNC se PAL[5] diverso da 64)
Come per i salti GO... se la G26 viene eseguita i campi successivi sono ignorati, e la riga non viene riconosciuta come riga finale di un salto GON...-N...
È obbligatorio che il campo G26 termini col punto esclamativo e non contenga spazi, altrimenti non viene riconosciuto e si ha un errore programma.
CONDIZIONAMENTI Con questa istruzione si ordina allo Z32 di eseguire o non eseguire i successivi campi separati da ';' fino al primo '!', a seconda che le condizioni specificate siano o no verificate.
Che significa: se il valore dell'espressione 1 è minore, uguale o maggiore (possono essere usate una o due condizioni) del valore dell'espressione 2, allora continua ad eseguire normalmente il prossimo campo (A), altrimenti salta fino al primo punto esclamativo e prosegui col campo successivo (C).
Esempi:
N12 !IF X >= 3;GON30!
Se X è maggiore o uguale a 3 salta alla riga N30, altrimenti prosegui con la prossima riga (non ci sono altri campi successivi).
N12!IFAA<>2;GON30!GON47!
Se AA è diverso (maggiore o minore) da 2 salta alla riga N30, altrimenti salta alla N47.
N12!XA=XA+1!IFXA>5;XA=5!
Incrementa XA di 1; ma se il risultato è maggiore di 5 , metti XA=5.
N12 !IF R=5;EB! R=R-1,5;IF R<5 ;R=5!GON1-N11!
Se R è 5 allora prosegui con la prossima riga (EB), altrimenti decrementi R di 1,5: se il risultato è minore di 5 riporta R al valore di 5, poi ripeti le righe da 1 a 11 col nuovo R. Questa riga permette di ripetere una serie di righe col parametro R decrescente in passi di 1,5 a partire dal suo valore originario, limitando R a un minimo di 5. Dopo l'ultima passata con R pari a 5 prosegue.
N12!IFX<10;IFY<10;EB!GON63!
Se X è minore di 10 E ANCHE Y è minore di 10 continua, altrimenti salta alla riga 63.
N1 X10
... N10 !R=R-1!IF R = 5;GON3! ... N20 !GON1-N10!
Ripeti le righe da 1 a 10. Notare che la riga fine ha un salto, condizionato a R>=5: il ritorno dalla riga 10 è fatto solo quando il ciclo è completato, ossia quando non viene eseguito il salto GON3 perché è diventato R<5.
ATTENZIONE
La condizione di '=' è verificata se i due risultati sono identici fino all'ultimo decimale. Poiché le necessarie approssimazioni di calcolo possono portare a errori sugli ultimi decimali, si consiglia sempre di usare, per quanto possibile, le condizioni '<=' o '>=' al posto del semplice '='.
Per esempio:
...
N10 Z10
N11 ...
...
N20!Z=Z-0.1!IFZ=0;GON30!
N21 ...
N22 ! GON11 !
...
N30 ...
Nella riga N20 è usata la condizione Z=0 per il salto a N30, ma il programma non funziona perché ci sono le approssimazioni. 0.1 in binario (lo Z32 esegue tutti i calcoli in binario) è un numero periodico e quindi approssimato: sottratto 100 volte a 10 può non dare esattamente zero.
Il modo giusto di programmare è di mettere nella riga N20 la condizione minore o uguale che viene sempre trovata.
LETTURA E SCRITTURA IN MEMORIA PERMANENTE Lo Z32 possiede una memoria di lavoro e una memoria permanente (spesso chiamata anche CMOS) che viene periodicamente scaricata sul disco rigido del PC (circa ogni 1 secondo).
La memoria di lavoro contiene i dati elaborati dal calcolatore nella esecuzione del programma assegnato.
La memoria permanente invece contiene tipicamente i dati scritti dall'utente per passare ordini e informazioni al calcolatore.
I dati contenuti nella memoria di lavoro sono continuamente aggiornati dal calcolatore
seguendo l'evoluzione dei valori programmati, ma vengono perduti in caso di mancanza
dell'alimentazione.
I dati in memoria permanente invece non si perdono a macchina spenta e vengono tipicamente aggiornati dall'utente.
Il microprocessore, durante l'esecuzione del programma, legge ordinatamente i dati contenuti
nella memoria permanente, li elabora e li trascrive nella memoria di lavoro. Per esempio, per
eseguire la istruzione di programma:
HA150
il calcolatore legge i caratteri "HA150" contenuti nella memoria permanente ed annota il valore 150 nella casella assegnata al parametro HA della memoria di lavoro.
I parametri descritti nel capitolo dedicato ai parametri sono quelli della memoria di lavoro: essi sono tutti inizializzati con valore zero ad ogni reset, contengono i valori via via elaborati durante l'esecuzione del programma e si perdono a macchina spenta.
Esiste la possibilità nella programmazione dello Z32 di andare a leggere i valori di parametri scritti nella memoria permanente (come caratteri alfanumerici in programmi o tabelle) e di trasferirli nelle caselle dei parametri di lavoro.
Ciò si ottiene con un campo di riga evoluta. Con l'esecuzione di questo campo lo Z32 rende uguale il parametro memorizzato in memoria permanente e il parametro di programma in esso indicati. Nel caso di ':R' viene letto da memoria permanente nel parametro di programma-pezzo. Inversamente, nel caso di ':W' viene scritto in memoria permanente da parametro oppure da espressione matematica di programma-pezzo (che nel caso più semplice può essere una costante). La memoria permanente interessata può essere: - sezione parametri - sezione origini - un parametro della descrizione utensile programmato (T) - un parametro della descrizione utensile su mandrino (S) Il nome del parametro del programma-pezzo può essere a 1 o 2 caratteri (il secondo non numerico), con le regole descritte nel paragrafo relativo ai parametri. Quello della memoria permanente è sempre a 2 caratteri se si tratta di parametri o origini, mentre può essere a 1 o 2 caratteri se si tratta della descrizione dell'utensile. Se non esiste nella sezione interessata il parametro indicato, il CN dà errore programma (CN1D14). Invece se non esiste il parametro di lavoro nella memoria del programma-pezzo esso viene creato con valore zero. Il nome del parametro in memoria permanente e del parametro in memoria di lavoro possono essere uguali o diversi (ricordarsi che in memoria di lavoro il nome del parametro non può contenere numeri). Il massimo numero scrivibile è 999999,999 (sei cifre intere e tre decimali) ; se il numero da scrivere è superiore al massimo viene scritto il massimo. Esempi: !:ROX1=HA! legge OX1 nel parametro HA !HA=50!:WOX1=HA! fa OX1=50 !:WOX1<50>! anche questa espressione fa OX1=50 !:ROX1=HA!HA=HA+5!:WOX1=HA! sposta l'origine OX1 di +5mm !:ROX1=HA!:WOX1<HA+5*X>! come sopra
Una operazione di scrittura in memoria permanente è composta di un certo numero di operazioni, che possono essere interrotte da un reset o da una caduta della tensione di alimentazione. In questo caso nel file interessato, subito dopo l'indirizzo del parametro lasciato non completo, la riga viene lasciata spezzata in due: ciò genererà un errore (CN...) in caso di successivo uso del parametro memorizzato in memoria permanente. Sarà cura dell'operatore ripristinare il parametro corretto in memoria.
Letture e scritture multiple Più parametri possono essere letti o scritti con un solo campo di riga evoluta: le varie coppie di nomi di parametri da uguagliare sono separate dal carattere ','.
Esempi:
!:RPH1=HA,H2=HB,H3=HC!
legge da sez. parametri H1, H2, H3 in HA, HB, HC
!:WSL=L,R=R!
scrive nella riga utensile sul mandrino i parametri L e R
Origine attiva Soprattutto in sottoprogrammi di uso generale, può essere utile leggere o scrivere l'origine attiva di un dato asse senza conoscere quale essa sia, ossia senza conoscerne il carattere identificatore.
Se al posto del carattere identificatore si programma il carattere '*' lo Z32 lo interpreta come 'origine attiva’.
Per esempio:
!:ROX*=HA!
legge l'origine attiva sull'asse X, per es.OX2 e la carica in HA
!:ROX*=HA!:WOX*<HA-1>!
sposta l'origine attiva dell'asse X di -1mm
Si noti che, se dopo aver attivato una origine, si cambia la sezione attiva delle origini, l'origine programmata resta quella della vecchia sezione, ma le origini lette e scritte con :R e :W sono quelle della nuova sezione, anche se si legge o scrive con '*'. Esempio:
...
N10 G37OG OX1
N11 G37OL
N12 !:ROX*=HA!
...
Nel parametro HA viene scritto il contenuto della origine LOCALE X1, mentre è attiva l'origine GLOBALE X1 .
ATTENZIONE
La scrittura di sezioni locali di parametri-origini-utensili da part-program non deve essere fatta se sulla stessa sezione locale possono agire più part-program contemporaneamente.
Posto utensile La descrizione dell'utensile contiene, dopo il carattere '#', un numero di max. due cifre che identifica il posto. Questo numero non è un parametro e quindi non è normalmente accessibile al programmatore. Esso può però essere trasferito in e da un parametro mettendo il carattere '#' come nome del parametro in memoria permanente.
Per esempio:
!:RT#=HA!:RS#=HB!
legge nel parametro HA il posto dell'utensile programmato, e in HB il posto dell'utensile sul mandrino
È possibile modificare il posto dell'utensile con:
!:WS#=HA!
modifica il posto dell'utensile sul mandrino.
ATTENZIONE
La scrittura di sezioni locali di parametri-origini-utensili da part-program non deve essere fatta se sulla stessa sezione locale possono agire più part-program contemporaneamente.
ATTENZIONE
La modifica del posto utensile è in generale una operazione da riservare al costruttore della macchina utensile nei suoi sottoprogrammi speciali. Una errata modifica del posto utensile può portare a collisioni al momento del cambio.
Lettura e scrittura in ricerca blocco In ricerca blocco la lettura e la scrittura in memoria permanente sono eseguite normalmente.
Ciò può portare a falsi giri di programma, nel caso che si leggano parametri modificati durante l'esecuzione precedente.
In questo esempio all'istruzione N1 il programma fa uso di quanto contenuto in HA per saltare o no alla riga N100. Alla riga N2 il contenuto di HA in memoria permanente è modificato per qualche ragione. Se l'esecuzione è interrotta tra N2 e N100, non sarà più possibile in ricerca blocco riprendere il programma interrotto perché alla riga N1 salterà immediatamente alla riga N100.
Se un programma deve essere interrotto e ripreso in un punto qualsiasi con minimo lavoro per l'operatore, il programma stesso dovrà contenere una traccia di quanto trovato in memoria permanente.
Si potrà costruire una struttura simile a quella illustrata al capitolo “Prestazioni speciali” paragrafo ‘Ricerca blocco con movimenti di misura’.
Funzione :L per caricare/scaricare files su disco La funzione :L (L come Load)permette di caricare in modo veloce part-program residenti su disco nella memoria operativa dello Z32.
La sintassi del comando, che è un campo di riga evoluta, è:
!:L(numero file Z32)-(nome completo file su disco)!
Esempio:
!:L 10 -C:\Z32\PPG\OP3244.PPG!
che richiede di caricare nel file 10 di Z32 il file di PC che si trova col nome completo
C:\Z32\PPG\OP3244.PPG.
Alcune regole di scrittura:
I delimitatori di campo di riga evoluta possono essere sia il carattere '!' sia il carattere ';'.
Prima e dopo ':L' possono esserci un numero qualsiasi di blank.
Il numero file da installare deve essere compreso tra 1 e 109 inclusi, altrimenti viene CN 1D14
ERRORE PROGRAMMA.
Il numero file può essere il risultato di una espressione. Esempio:
HA20
!:L<HA+1>-\Z32\PPG\FPROV.PRG!
Il file FPROV.PRG che sta nella directory \Z32\PPG viene caricato nel file n. 21.
Se il risultato dell'espressione è frazionario viene arrotondato all'intero più vicino. Per esempio:
HA13
!:L<HA/3+30>-\Z32\PPG\FPROV.PRG!
Il file FPROV.PRG che sta nella directory \Z32\PPG viene caricato nel file n. 34. Il file da installare non può essere il programma o sottoprogramma in corso, né un programma o sottoprogramma al quale si dovrà tornare. Per esempio, se siamo nel sottoprogramma 10, che è stato chiamato da sottoprogramma 5, che è stato chiamato dal programma principale 1, non sarà possibile caricare i programmi 1, 5 e 10. Invece è lecito (è lo scopo del :L) caricare il sottoprogramma 10 mentre si sta eseguendo il programma 1, e poi eseguire il 10 come sottoprogramma. Per esempio è lecita questa sequenza, inserita per esempio nel programma principale 1:
che può servire per richiamare da disco un programma lungo, sezionato in 4 parti. Tutti i caratteri stampabili tra il carattere '-' e il terminatore del campo (';' o '!'), inclusi eventuali blank, sono considerati come nome completo del file su disco. Nel nome file non possono essere compresi: - il carattere '$' che riconcatena la riga con la seguente - i terminatori ';' e '!' - caratteri con valore inferiore a 20 hex o superiore a 7f hex che danno CN 1D14 ERRORE PROGRAMMA
Sul nome file non viene fatto un controllo sintattico, ma solo alcuni controlli formali: deve essere terminato regolarmente (anche il fine riga senza terminatore non è ammesso) e deve avere un numero di caratteri tra 1 e 80 compresi.
Il file sul PC deve essere un normale file ascii (editabile con qualsiasi word-processor che generi un file senza caratteri di formattazione testo), di lunghezza non superiore a 64k. Il programma DOS di supporto provvede a fare le conversioni necessarie da formato ascii PC a formato Z32.
Il modo di caricamento del programma messo in atto dal programma DOS di supporto è un modo particolarmente veloce (si possono scrivere qualche decina di kbyte/secondo) ma per questo c'è un prezzo da pagare: il file introdotto nello Z32 non è permanente, ossia non permane dopo lo spegnimento e riaccensione del PC. D'altra parte, essendo il file permanente su disco la limitazione appare non molto importante.
ATTENZIONE
È possibile editare (con attività 5) un file introdotto con :L, ma i risultati sono validi solo finche il CN resta alimentato: non è garantito il risultato se si spegne e si riaccende il PC, il file risulta sempre nullo.
Sono stati aggiunti i seguenti messaggi errore relativi a :L:
CN 4E14 ERRORE :L FILE SU DISCO
Segnala che il programma DOS ha trovato un errore di lettura nell'accesso al file selezionato. Non c'è il dettaglio preciso dell'errore, che può essere di varia natura: file o directory inesistente,disco non pronto, errore di accesso al disco .... È compito dell'operatore rimuovere l'errore.
CN 4F14 ERRORE :L FILE Z32
Segnala che Z32 dà errore nella scrittura del file. Anche qui non c'è dettaglio preciso. L'errore può derivare da varie cause: memoria piena, file impegnato nello Z32, errore di scrittura .... Anche in questo caso è compito dell'operatore rimuovere l'errore.
CN 5014 ERRORE :L SCONOSCIUTO
Segnala un malfunzionamento nel colloquio tra Z32 e il programma di supporto. Se il programma DOS è corretto questo tipo di errore non deve mai presentarsi.
Attenzione nel caso di multiprocesso
I files di Z32 sono una risorsa comune a tutti i processi attivi, e quindi il file che viene caricato con :L può essere usato anche da processi diversi da quello che chiede il caricamento. Lo Z32, prima di caricare il file, controlla che in quel momento il file non sia impegnato (sia come programma principale che come sottoprogramma) in nessuno dei processi attivi (se è impegnato dà errore CN 4F14), ma non può prevedere le successive evoluzioni. È compito del programmatore tenere conto dell'uso del file da caricare nei vari processi.
Attenzione alla sequenza dei programmi caricati
È noto che Z32 contiene un serbatoio di istruzioni preelaborate in attesa di esecuzione, che può essere molto lungo: di recente è stato esteso a oltre 100 blocchi per consentire la previsione degli spigoli molto avanti. Nei blocchi preelaborati c'è anche l'ordine di visualizzare la riga, che viene letta, al momento della reale esecuzione, nel file presente in memoria. Se nel frattempo il file in memoria è cambiato (perché caricato con :L) la visualizzazione della riga in corso non è più significativa. Quindi, se si programma:
!:L 10 -C:\PPG\OP3244.1!GOP10!
!:L 10 -C:\PPG\OP3244.2!GOP10!
quando si eseguono le ultime righe del programma OP3244.1 si ha una visualizzazione errata perché le righe vengono lette nel file 10, che ormai contiene OP3244.2.
Sarebbe stato facile qualificare l'operazione :L come "con arresto" (che svuota il serbatoio preelaborato), ma, ricordando che l'operazione con arresto non è sempre possibile (non nella correzione raggio, nella geometria aperta, nella G98...) si sarebbe avuto l'inconveniente di dover spezzare un eventuale file lungo in punti adeguati.
È stato quindi deciso di lasciare la possibilità di visualizzazione errata (che riguarda solo la visualizzazione della riga e non la reale esecuzione in macchina) per dare una maggiore flessibilità di uso.
Ci sono due modi per eliminare l'errata visualizzazione di righe: 1)alternare la scrittura di più programmi Riesaminiamo l'esempio fatto in precedenza:
Questo accorgimento funziona se i programmi contengono funzioni con arresto (basta una M, un'attesa G4 ...) oppure se i programmi sono abbastanza lunghi (per sicurezza almeno 200 blocchi).
Naturalmente si possono interessare anche più di due programmi fino a ottenere la lunghezza voluta. 2) interporre una funzione con arresto Per esempio:
La G112 è la speciale G di sincronizzazione, ma si può usare una qualsiasi altra funzione con arresto (M, G4 ecc.).
Questo accorgimento funziona sempre, ma richiede che il programma sia spezzato in un punto adeguato, che ammetta l'arresto.
:L- per scaricare files su disco
Il comando :L- consente lo scarico di files da Z32 a disco. Esempio:
!:L-126-\FILES\ORIGINI.001!
L'esecuzione di questa riga provoca il trasferimento del file 126 di Z32 (tabella origini) dalla memoria operativa dello Z32 al file su disco di nome "ORIGINI.001" nella directory \FILES.
Notare che la differenza col normale comando :L è il segno "-" prima del numero file.
Rimangono valide tutte le modalità d'uso e gli allarmi già descritti per il comando :L con numeri positivi, salvo il fatto che si possono scaricare su disco tutti i files da 1 a 127 incluso (mentre per il carico dei programmi erano possibili solo i files da 1 a 109 incluso).
:L254 esecuzione multipla in DNC Per usufruire di questa possibilità è necessario avere i programmi di interfaccia video TERMS
o ZTERM. Si tratta della possibilità di eseguire più volte in DNC lo stesso programma o più programmi diversi, per superare la limitazione della lunghezza del singolo file.
Formato generale di programmazione:
!:L254-nome file di PC!
Questo comando somiglia al comando ":L" ma ha il numero file (obbligatorio per questa prestazione) 254.
Questo numero di file rappresenta l'ordine codificato di eseguire il part-program residente su disco in DNC e non con una installazione in memoria.
Se il numero file è 254 si ha che: - il file non viene installato nella memoria Z32 ma viene eseguito in DNC. Ciò significa che il file può avere una lunghezza qualsiasi (compatibilmente con la disponibilità del disco rigido) - si ha una immediata esecuzione del file in DNC, senza necessità di un successivo GOP... (come è richiesto nel caso di files installati in memoria)
Si possono ottenere varie prestazioni, per esempio quella di ripetere l'esecuzione di un file molto lungo in posizioni via via rototraslate.
Le righe da N2 a N8 sono ripetute 6 volte, in 6 diverse angolature distanti 30 gradi l'una dall'altra. Alcune specifiche per il file di part-program: - non deve avere in testa il carattere "%" (quindi il commento iniziale, se c'è, deve essere racchiuso entro parentesi tonde come specificato dalle norme ISO) - deve terminare con l'istruzione G26 (ritorno da sottoprogramma
Programmazione parametrica del nome file DNC Da part-program si può specificare il nome del file da eseguire in DNC con la riga evoluta:
!:L254-nomefile!
dove nomefile è una stringa ascii che specifica il path e il nome del file. Può essere utile poter variare il nome del file da eseguire in funzione di un'espressione. Ammettiamo che nella directory C:\Z32\PPG ci siano 500 diversi part-program da scegliere infunzione di un parametro (per esempio HA) che varia da 1 a 500. Per usare il nome programmabile si inserirà nel nome del file un numero da 1 a 500, per esempio:
PPG1 PPG2 … PPG499 PPG500
A questo punto, se HA contiene il numero da 1 a 500 si potrà semplicemente programmare:
!:L254-PPG<HA>!
Tra parentesi acute può anche essere contenuta un'espressione:
!:L254-PPG<HA+1-HC*2>!
L'espressione può essere interna al nome del file, oppure essere ripetuta più volte:
!:L254-PPG<HA>.DAT!
specifica nomi files PPG1.DAT, PPG2.DAT ecc.
!:L254-PPG<HA>.<HB>!
Specifica nomi file PPG1.1 (HA=HB=1), PPG20.46 (HA=20, HB=46) ecc. Alcune regole sull'espressione:
- gli zeri iniziali sono sempre omessi, se l'espressione è zero viene inserito un solo zero - se il risultato dell'espressione è negativo viene fatto il valore assoluto - se il risultato dell'espressione è frazionario viene assunto l'intero più vicino.
DNC strutturato ATTENZIONE: Questa prestazione non è concepita per una programmazione manuale, ma per applicazioni software che permettano, in modo automatico ed in ambiente di rete, una ricerca blocco (o ripristino ciclo) per zone di part-program come è permessa da Zterm sotto DOS.
Per completezza di informazione se ne dà comunque la descrizione, che comprende anche alcuni speciali codici di allarme CN aggiunti per l'occasione.
Z32 supporta uno speciale comando per DNC "strutturato" che consente di ordinare l'esecuzione parziale di un file in DNC (DNC con specifica di zona).
L'uso di questa estensione è consentito solo in ambiente di rete e con applicativi Windows appositamente sviluppati. Non funziona (genera un allarme CN) se usata con gli applicativi attuali (Zterm e Terms).
La prestazione è legata all'istruzione evoluta :L254, la cui sintassi per esteso è:
Ossia, si possono aggiungere tra parentesi quadre, dopo il nome del file su disco, i puntatori inizio e fine della zona da trasmettere, separati da un doppio segno meno. I puntatori identificano la posizione del carattere iniziale della prima e dell'ultima riga da trasmettere. Il primo carattere del file ha il puntatore = 1 (non = 0!). Se i due puntatori sono identici viene trasmessa un'unica riga. Sono accettate anche le due stringhe "START" e "END" che specificano inizio e fine file, per esempio:
I codici allarme CN legati a questa prestazione (che saranno comunicati a Z32 dallo speciale applicativo Windows) sono:
CN6514 :L CON [ ]: ERRORE SINTASSI CN6614 :L CON [ ]: PUNTATORI NON A INIZIO RIGA
CN6714 :L CON [ ]: PUNTATORI OLTRE FINE FILE
CN6814 :L CON [ ]: PUNTATORE INIZIO MAGGIORE DI FINE
:P, :D Stampa da part-program su video di stringhe e valori parametri Istruzione evoluta :P
Si può utilizzare un campo di riga evoluta con le sintassi:
!:P n1 - n2 "stringa" [espressione] ...!
:P è l'apertura del campo speciale ("P" come Print)
n1 è la posizione carattere iniziale (min 0, max 158)
- è il tratto (segno meno) di separazione tra n1 e n2 n2 è la posizione carattere finale (min n1+1, max 159) "stringa" è una stringa ascii racchiusa tra doppi apici [espressione] è un'espressione algebrica tra parentesi quadre ! è il carattere di apertura e chiusura campo (è valido anche il ";", escluso inizio riga). :Pn1-n2 sono obbligatori. n1 ed n2 individuano i caratteri delle stringhe video di visualizzazione speciale (sono disponibili due intere righe, quindi 160 caratteri al massimo. I caratteri tra n1 ed n2 compresi sono cancellati e sostituiti con i dati da visualizzare. Stringhe ed espressioni sono opzionali, possono essere ripetuti più volte in qualsiasi ordine, fino a riempire il numero di caratteri predisposto (n1-n2). Non viene mai scritto fuori dal campo delimitato da n1-n2. Se la stampa è più lunga viene troncata senza generare allarme. Le stringhe possono contenere tutti i caratteri stampabili, salvo il doppio apice che serve come delimitatore.
Le espressioni possono essere tutte quelle inseribili nel part-program.
I risultati delle espressioni sono stampati senza zeri iniziali e con un massimo di 3 cifre decimali. Il massimo risultato visualizzabile è 999999,999. Risultati superiori sono saturati al massimo senza dare allarme CN. Non ci sono spazi né prima né dopo i risultati delle espressioni. Eventualmente aggiungerli. Se n1 o n2 sono incongruenti, mancano i caratteri di delimitazione ecc. viene allarme CN 1D14. Dopo che è stato richiesta una visualizzazione con :P le visualizzazioni da logica sono congelate (anche nella zona fuori da n1-n2). Per cancellare i dati visualizzati e riprendere le eventuali visualizzazioni di dati di logica si deve programmare nel part-program un campo di riga evoluta con la forma seguente:
!:P /R!
Esempi:
!:P0-30 "HA="[HA]" HB="[HB]!
Visualizza i due parametri HA e HB, con descrizione.
!IF HA<0;:P0-60"VALORE ERRATO DI HA = "[HA]!
Visualizza solo se HA<0
!:P20-80"Risultato: "[12*4-PAR[18]+CS(HB-30)]!
Visualizza il risultato dell'espressione
Istruzione evoluta :D
La visualizzazione dei dati sul video con la istruzione di riga evoluta :P ha queste limitazioni:
-c'è un conflitto con le visualizzazioni di logica perché la stringa viene stampata nella stessa zona dello schermo - la stampa non è sincronizzata con la reale posizione del part-program, per il solito serbatoio di istruzioni preelaborate Se è necessario ovviare a queste limitazioni si può usare l’istruzione :D (mnemonico Display) al posto di :P, che mantiene la stessa sintassi della precedente e che non ha più entrambe le limitazioni sopra descritte.
La stampa di :D avviene nelle righe delle visualizzazioni speciali (quelle che si attivano con CTRLR-V) e che sono raramente utilizzate. Se sono attive le visualizzazioni CTRLR-V il contenuto di :D viene momentaneamente non presentato.
La sintassi di :D è la stessa del precedente :P.
!:D n1 - n2 "stringa" [espressione] ...!
:D è l'apertura del campo speciale ("D" come Display) n1 è la posizione carattere iniziale (min 0, max 158)
- è il tratto (segno meno) di separazione tra n1 e n2 n2 è la posizione carattere finale (min n1+1, max 159) "stringa" è una stringa ascii racchiusa tra doppi apici [espressione] è un'espressione algebrica tra parentesi quadre ! è il carattere di apertura e chiusura campo (è valido anche il ";", escluso inizio riga). :Pn1-n2 sono obbligatori. n1 ed n2 individuano i caratteri delle stringhe video di visualizzazione speciale (sono disponibili due intere righe, quindi 160 caratteri al massimo. I caratteri tra n1 ed n2 compresi sono cancellati e sostituiti con i dati da visualizzare. Se il numero di caratteri è dispari viene aggiunto un blank in coda. Stringhe ed espressioni sono opzionali, possono essere ripetuti più volte in qualsiasi ordine, fino a riempire il numero di caratteri predisposto (n1-n2). Se la stampa sconfina fuori dal campo di n1-n2 viene troncata senza generare allarme. Le stringhe possono contenere tutti i caratteri stampabili, salvo il doppio apice che serve come delimitatore. Le espressioni possono essere tutte quelle inseribili nel part-program. I risultati delle espressioni sono stampati senza zeri iniziali e con un massimo di 3 cifre
decimali. Il massimo risultato visualizzabile è 999999,999. Risultati superiori sono ridotti al massimo senza dare allarme CN. Non ci sono spazi né prima né dopo i risultati delle espressioni. Eventualmente aggiungerli Se n1 o n2 sono incongruenti, mancano i caratteri di delimitazione ecc. viene allarme CN 1D14. La cancellazione dei dati si ottiene col campo di riga evoluta !:D /R! Esempi:
!:D0-30 "HA="[HA]" HB="[HB]!
Visualizza i due parametri HA e HB, con descrizione.
!IF HA<0;:D0-60"VALORE ERRATO DI HA = "[HA]!
Visualizza solo se HA<0
!:D20-80"Risultato: "[12*4-PAR[18]+CS(HB-30)]!
Visualizza il valore dell'espressione
!IF HA>40;:D /R!
Se HA>40 cancella le visualizzazioni :D
:F Scrittura stringa su file Il funzionamento del campo è del tutto simile a quello di :P e :D, con la differenza che il risultato, anziché essere scritto a video viene "accodato" a un file di Z32.
La sintassi normale è:
!:Fnfile"stringa"[espressione]"stringa"...!
Dove: nfile = numero file di Z32 (validi da 1 a 99) stringa = stringa di caratteri alfanumerici espressione = espressione di part-program La stringa viene accodata al file richiesto, l’espressione viene calcolata e accodata al file richiesto.
Per i dettagli riferirsi alla sintassi dei campi :D e :P.
Esempio:
HA 45
!:F12"Valore nel punto 4: "[HA*2]!
Nel file 12 viene scritta la stringa:
Valore nel punto 4: 90
Ogni campo :F specifica una intera riga.
Più stringhe ed espressioni possono essere contenute nel campo, fino ad un massimo di 160 caratteri. Gli eventuali caratteri in eccesso sono ignorati.
Sono validi numeri file da 1 a 99, ma il file non può essere lo stesso che è in esecuzione automatica.
Se il file supera i 64k viene errore cmos.
Con una sintassi speciale si può ottenere la cancellazione totale del file:
!:Fnfile/R!
Esempio:
!:F90/R!
Esegue la cancellazione del file 90.
File documentazione (“DOC”) per ricerca blocco con blocco opzionale Una riga di programma che inizia col carattere “/” viene eseguita da Z32 solo se è abilitata dall’apposito selettore (blocco opzionale).
Se durante l’esecuzione lo stato del selettore non è fisso ma viene cambiato dall’operatore in funzione delle sue esigenze risulta poi impossibile la ricerca blocco perché, anche se l’operatore ricorda le scelte fatte durante l’esecuzione, è praticamente impossibile manovrare il selettore con la rapidità che sarebbe necessaria.
È stata ora introdotta la possibilità di generare un file di “documentazione”, che registra i comandi dati dall’operatore durante l’esecuzione. Queste informazioni rimangono memorizzate nel file e sono utilizzate in ricerca blocco per ripetere le scelte.
Per compatibilità col funzionamento precedente la nuova modalità di esecuzione e ricerca blocco è attivata da uno speciale comando contenuto nel part-program. Se questo comando manca il funzionamento è identico al precedente, sia in esecuzione che in ricerca blocco.
Il funzionamento del file documentazione è diverso in esecuzione, quando il file viene scritto con le scelte dell’operatore, e in ricerca blocco, quando le scelte fatte dall’operatore vengono lette dal file.
Gli eventi che coinvolgono il file documentazione sono:
- comando iniziale di attivazione - riga con blocco opzionale - inizio sezione di programma Attivazione del file “DOC” L’attivazione del file “DOC” si ha col campo di riga evoluta: !DOC>nnn! DOC è il comando di attivazione del file di documentazione > introduce il file di Z32 dove risiedono i dati di documentazione nnn è il numero file Per esempio: !DOC>102!
Richiede di attivare la documentazione nel file 102 Sono possibili numeri file da 1 a 109. È bene che l’attivazione del file DOC sia inserita a inizio programma, per coprire tutte le scelte dell’operatore. In esecuzione gli effetti di questo comando sono:
- il file destinazione viene cancellato se esiste - viene creato un file destinazione nuovo con una stringa iniziale caratteristica Esempio di stringa iniziale: DOC FILE PRG NR 004 20.08.99 18:47
Nella stringa iniziale si riconoscono questi campi: DOC FILE PRG NR stringa ascii fissa caratteristica del file DOC 004 numero di programma in corso di esecuzione
20.08.99 data, nel formato gg.mm.aa (giorno.mese.anno) 18:47 ora, nel formato hh:mm (ora:minuti)
Il file in corso di esecuzione è quello base (lanciato con scelta programma), anche se sono in corso sottoprogrammi o file DNC.
Se a inizio esecuzione è stato scelto il DNC il file in corso di esecuzione è convenzionalmente il numero 254.
In ricerca blocco gli effetti sono:
- il file destinazione viene aperto per lettura - viene controllata la parte fissa della stringa iniziale - viene controllato che il numero programma in corso di esecuzione sia lo stesso della ricerca blocco -viene controllata la lunghezza della stringa iniziale, ossia data e ora possono essere qualsiasi ma la lunghezza della riga deve essere di 34 caratteri
Se il risultato del controllo è positivo la ricerca blocco continua in modo normale, e le scelte sono lette dal file DOC, mentre se risultano errori la ricerca blocco continua in un modo speciale: non essendo coerenti i dati contenuti nel file DOC l’operatore dovrà ripetere le sue scelte ad ogni blocco opzionale.
Blocco opzionale
Durante la esecuzione il blocco opzionale viene eseguito o non eseguito a seconda dello stato del selettore esterno.
Se è attivo il file DOC (ossia se in precedenza nel programma c’era l’attivazione col campo !DOC>...!) la scelta dell’operatore viene registrata nel file DOC con una riga composta di un solo carattere, che è “0” se la riga non viene eseguita e “1” se la riga viene eseguita.
In ricerca blocco si possono avere tre casi:
-se il file DOC non è attivo la riga viene eseguita o non eseguita secondo lo stato del selettore. Il funzionamento è identico a quello che si aveva con le versioni precedenti
- se il file DOC è attivo senza errori il file DOC viene aperto e viene ripetuta la scelta fatta durante l’esecuzione. Lo stato attuale del selettore del blocco opzionale non ha effetto. Se durante la lettura dal file DOC si rilevano errori il funzionamento passa a quello del file DOC con errore come descritto al prossimo paragrafo - se il file DOC è attivo (ossia nel programma è stata incontrata l’istruzione !DOC>...!) ma con errore viene generato uno STOP (come con M0) per consentire all’operatore di ripetere la scelta. La lettura dello stato del selettore del blocco opzionale e quindi la scelta se eseguire o non eseguire la riga viene fatta quando viene premuto START per continuare la ricerca. Sezionamento programma
Il sezionamento programma, che è ottenuto con una riga che inizia col carattere “:” seguito dal numero sezione, consente una ricerca blocco molto più rapida, ma i blocchi opzionali nelle sezioni che vengono “saltate” non vengono riconosciuti né decodificati.
Deve quindi essere opportunamente gestito nel file DOC per consentire la sincronizzazione del puntatore in lettura con l’inizio sezione.
In esecuzione la riga di sezionamento genera nel file DOC una riga composta dal carattere “:” e da cinque numeri che identificano la sezione. Sono scritti anche gli eventuali zeri iniziali.
Per esempio, la riga di part-program:
:456
genera una riga nel file DOC:
:00456
In ricerca blocco la riga di sezionamento richiede nel file DOC la ricerca della riga corrispondente. La lettura delle scelte operatore riprende con le righe che seguono immediatamente la riga di sezionamento.
Se il file DOC è in errore la riga di sezionamento viene ignorata ai fini del file DOC: le scelte relative al blocco opzionale saranno comunque richieste all’operatore con uno STOP programma. Esempio di part-program e di file DOC relativo Esempio di part-program con attivazione di file DOC, installato nel file 4:
Dopo l’esecuzione di questo part-program, con blocco opzionale disabilitato, il file 102 (file DOC) è il seguente:
DOC FILE PRG NR 004 21.08.99 16:37 0 0 :04567 0
Gli “0” corrispondenti ai blocchi opzionali si trasformano in “1” se il selettore di blocco opzionale è attivo in esecuzione.
Introduzione parametri di part-program da tastiera - Istruzione INPUT Consente di richiedere un parametro all'operatore durante lo svolgimento di un part-program.
La sintassi per richiedere un parametro all'operatore (che è possibile solo da riga ISO) è:
nomeparam<IN:commento>
dove nomeparam è il nome del parametro richiesto all'operatore, commento è la stringa da presentare all’operatore a chiarimento della funzione del parametro richiesto.
Per esempio questa riga:
HA<IN:PROFONDITA' PASSATA>
Apre una finestra di dialogo con l'operatore del tipo:
<0¦ > IN:PROFONDITA' PASSATA
All’interno della finestra di dialogo viene visualizzato il valore attuale del parametro, per esempio, se HA in quel punto del programma ha valore 5,234 viene visualizzato:
<5.324¦ > IN:PROFONDITA' PASSATA
A tutti gli effetti è come se il numero stampato da Z32 nella finestra di dialogo fosse stato scritto dall'operatore.
Il cursore punta dopo l'ultima cifra del valore
L'operatore può cancellare una o più cifre e sostituirle con quelle desiderate.
Il dialogo con l'operatore avviene attraverso la riga comandi.
L'istruzione di INPUT è una istruzione "con arresto", quindi richiede, prima di essere effettuata, il completamento di tutte le istruzioni pendenti, e non può essere programmata, come tutte le istruzioni con arresto, in punti "aperti" del part-program (correzione raggio, geometria aperta ecc.).
Una volta completate le istruzioni pendenti la riga comandi viene modificata con:
<5.234¦ > IN:commento
dove il campo di 14 caratteri tra parentesi acute contiene il valore del parametro ed il cursore ed è disponibile per l'ingresso dati.
L'operatore può modificare il valore presentato oppure riempire riempire il campo con un nuovo numero da assegnare al parametro e poi premere enter. Se la sintassi è corretta il numero viene acquisito da Z32 e il part-program continua.
Durante la scrittura l'operatore ha a disposizione questi tasti speciali:
- ENTER conferma il valore vecchio come nuovo valore - BACKSPACE o FRECCIA SINISTRA cancellano l'ultima cifra e si entra nella modalità “editing” del valore: è come se tutti i caratteri residui del valore vecchio fossero stati battuti dall’operatore. - qualsiasi altro carattere provoca la cancellazione di tutto il valore vecchio presente nella finestra di input. Nella modalità “editing” valore:
- ENTER conferma valore introdotto - 0 1 2 3 4 5 6 7 8 9 + - , . sono accettati per la composizione o modifica del valore. - ESC o DEL cancellano tutto e fanno ripetere daccapo. Se il numero non è accettabile (per esempio potrebbe essere un numero con troppe cifre significative) compare un carattere "?" a destra che invita l'operatore a correggere il dato.
Collegato all'istruzione di input c’è l’allarme CN6314 <IN:...> STRINGA NON VALIDA.
L'introduzione del parametro è attiva sia in esecuzione che in ricerca blocco.
Per la ricerca blocco è interessante il collegamento delle istruzioni di INPUT col file DOC (che è attivato con l'istruzione !DOC>numerofile!). Se il file DOC non è attivo durante la ricerca blocco viene richiesto l'INPUT esattamente nello stesso modo come richiesto durante l'esecuzione. Se il file DOC è attivo durante l'esecuzione il parametro viene registrato nel file DOC in modo tale da essere disponibile per l'eventuale ricerca blocco. In ricerca blocco se il file DOC è attivo l'INPUT viene preso dal file DOC, ma se il file DOC risulta corrotto o incongruente l'INPUT viene richiesto all'operatore, come nel caso di file DOC non attivo.
PROGRAMMAZIONE STRUTTURATA Le istruzioni di Z32 che interrompono l'esecuzione sequenziale delle righe di programma sono: !GON…! Salto ad una riga senza ritorno !GON…-N…! Salto ad una serie di righe con ritorno !GOP…! Salto ad un sottoprogramma !GOP…-N…! Salto ad una riga all'interno di un sottoprogramma !GOP…-N…-N…! Salto ad una serie di righe all'interno di un sottoprogramma Le istruzioni !GON…! non possono essere eseguite all'interno di un programma eseguito in DNC. La funzionalità di queste istruzioni dà al programmatore un'ampia libertà, consentendogli di eseguire salti ovunque all'interno del suo programma (in avanti e indietro) ma è limitata, per le funzioni !GON…! a programmi residenti nella memoria operativa di Z32 e quindi a programmi di lunghezza non superiore a 64k bytes. Per questo sono state aggiunte alcune istruzioni di "programmazione strutturata" che si affiancano alle istruzioni esistenti e che possono, con qualche limitazione che vedremo, essere contenute anche in programmi eseguiti in DNC (quindi di qualsiasi lunghezza). Le istruzioni di programmazione strutturata sono caratterizzate dal fatto che la riga che le contiene inizia con i due caratteri "-" consecutivi. Sono quindi perfettamente compatibili con i programmi esistenti, che darebbero errore se contenessero questo tipo di righe. Regole comuni per tutte le istruzioni strutturate sono:
- prima e dopo "--" possono esserci un numero qualsiasi di blank - possono essere inclusi dei commenti, che sono introdotti dal carattere ";"
Struttura IF – ELSEIF – ELSE – END IF Consente l'esecuzione condizionata di serie di istruzioni. Sintassi completa:
- condizione ha tre possibili forme: 1) condizione = espressione1 confronto espressione2 l'esecuzione dello IF è condizionata al confronto tra due espressioni: - espressione1 ed espressione2 sono le espressioni possibili nella sintassi Z32 (la forma più semplice di espressione è un numero oppure un solo parametro) - confronto sono gli operatori: < minore (con segno) = uguale > maggiore (con segno) <=minore o uguale >=maggiore o uguale <> diverso 2) condizione = / l'esecuzione dello IF è condizionata dal selettore del blocco barrato 3) condizione = // l'esecuzione dello IF avviene solo in ricerca blocco -istruzioni sono un numero qualsiasi di righe eseguibili da Z32, ossia righe "ISO", righe evolute, altre istruzioni strutturate
- tra END e IF possono esserci un numero qualsiasi di blank (è riconosciuto anche ENDIF, senza blank) - il carattere ";" di chiusura e il commento seguente sono opzionali Esempio 1: --IF HA=0 ;caso 0
HB10 --ELSEIF HA=1 ..HB11 --ELSEIF HA=2
HB105 --ELSEIF HA>2 HB1000
--ELSE HB-1 --END IF
Che assegna valori diversi al parametro HB in funzione del valore del parametro HA. Esempio 2:
--IF / ;da eseguire come blocco barrato G0 Z100 T0 M6 (SCARICA IL MANDRINO) M2 (FINE PROGRAMMA)
--END IF
Interrompe l'esecuzione del programma se il selettore del blocco barrato è attivo. Da notare che la stessa funzionalità potrebbe essere ottenuta senza programmazione strutturata, anteponendo il carattere "/" alle tre istruzioni che compongono il corpo dello IF. Esempio 3:
--IF // ;in ricerca blocco HA=1 ;in ricerca blocco prende il valore 1 --ELSE HA=-1 ;valore che prende non in ricerca blocco --END IF
Assegna due valori diversi al parametro HA, a seconda che siamo o non siamo in ricerca blocco. E' evidente che anche in questo caso si potrebbe ottenere la stessa funzionalità anche senza la programmazione strutturata. Lo END IF è obbligatorio, mentre sono opzionali gli ELSEIF (che possono essere in numero qualsiasi) e lo ELSE (che normalmente chiude le alternative dello IF). Ci può essere un "nesting" di IF (ossia IF dentro un altro IF) fino a 31 livelli. Esempio:
-- IF condizione1 istruzioni 1 -- IF condizione2
istruzioni 2 -- IF condizione3 istruzioni 3
-- IF condizione4
istruzioni 4 -- END IF istruzioni 3A
-- END IF
istruzioni 2A -- END IF istruzioni 1A
-- END IF
Si consiglia di "indentare" il programma (ossia spostare a destra le istruzioni allineandole con l'IF a cui appartengono come nell'esempio) per rendere più evidente il flusso delle istruzioni ed evitare errori nella richiusura degli IF con END IF. Fare attenzione che, in programmi con molti IF uno dentro l'altro può non essere semplice trovare dove manca lo END IF.
Un salto a un sottoprogramma azzera momentaneamente il livello di IF, e il ritorno dal sottoprogramma ripristina il livello di IF presente al momento del salto.
Per esempio è perfettamente lecita una struttura di programma così:
--IF condizione1 --IF condizione2 !GOP20! --END IF --ELSEIF condizione3 istruzioni3 --END IF
se sono verificate le condizioni 1 e 2 si ha il salto al sottoprogramma 20, e al ritorno non viene eseguito lo ELSEIF, anche se la condizione3 è verificata.
E' lecito inserire un G26 (ritorno dal sottoprogramma) all'intero di un ciclo di IF. Il ritorno dal sottoprogramma ripristina comunque il livello di IF del programma al quale si fa ritorno. Per esempio è lecito in un sottoprogramma:
--IF condizione1 --IF condizione2 --IF condizione3 G26 --END IF --END IF
--END IF
In questo caso il ritorno dal sottoprogramma G26 avviene correttamente al livello 3 di IF nel sottoprogramma, i due livelli di IF più bassi sono scartati e l'esecuzione riprende nel programma o sottoprogramma chiamante al corretto livello di IF del chiamante.
Un M2 (fine programma) può essere eseguito a livello di IF non zero. Per esempio è corretto:
--IF condizione1 M2 --END IF
Se viene programmato END IF senza che ci sia un IF aperto viene allarme CN6B14 "END DI -IF NON APERTO"
Analogamente, se viene programmato ELSE o ELSEIF senza che ci sia un IF aperto viene allarme CN7314 "--ELSE O --ELSEIF DI IF NON APERTO"
Attenzione: se il file termina durante un IF che non viene eseguito si possono avere allarmi vari di difficile interpretazione. Vedere l'istruzione --OUT che aiuta la comprensione di questi casi.
Attenzione: non possono coesistere nello stesso programma o sottoprogramma istruzioni strutturate IF e istruzioni !GON…, altrimenti viene l'allarme CN 7114 INCOMPATIBILI --IF E --DO CON !GON....!
Il salto a un sottoprogramma azzera la condizione di strutturato/non strutturato, quindi è possibile da un programma con istruzioni strutturate saltare a un sottoprogramma che contiene istruzioni tipo !GON… e viceversa.
E' anche lecito, da un programma che contiene istruzioni strutturate, eseguire un salto a un sottoprogramma con specifica della riga o di una serie di righe.Per esempio sono leciti:
--IF condizione !GOP10-N35! --END IF
oppure:
--IF condizione !GOP10-N35-N70! --END IF
Da notare che nel sottoprogramma P10 sarà immediatamente eseguito il salto ad una riga o ad una serie di righe, quindi in questo sottoprogramma non saranno possibili istruzioni strutturate tipo
–IF .
Struttura DO – EXIT DO - LOOP Consente la ripetizione condizionata di una serie di istruzioni.
Sintassi completa:
-- DO ;commento istruzioni -- EXIT DO IF condizione ;commento istruzioni -- LOOP IF condizione ;commento
dove:
- condizione è costituito da espressione1 confronto espressione2 come per lo IF. Non sono ammesse le condizioni "/" e "//" che sono invece possibili per lo IF - lo EXIT DO è opzionale - il LOOP è obbligatorio - IF condizione dopo EXIT DO e dopo LOOP è opzionale - i blank tra EXIT DO IF e tra LOOP IF sono opzionali (sono accettati anche EXITDOIF, EXIT DOIF, LOOPIF) Esempi semplici:
G0 X0 Y0
--DO
X<X+5> ..Y<Y+5> --LOOP IF X<20
fa una gradinata fino a X20 Y20 (termina col movimento da Y15 a Y20)
G0 X0 Y0
--DO X<X+5> --EXIT DO IF X>=20 Y<Y+5>
--LOOP
gradinata simile alla precedente, che termina col movimento da X15 a X20, con Y=15
Un ciclo di DO consuma un livello di subroutine (come il !GOP.. e il !GON-N) e quindi viene allarme CN2E14 TROPPE SUBROUTINES se il "nesting" delle subroutines supera il massimo di 19 livelli consentiti.
Più cicli di DO possono essere uno dentro l'altro; il nesting ammesso è quello totale delle subroutines
E' lecito inserire cicli di DO a livello di IF non zero, così come è lecito inserire IF (fino a 31 livelli) dentro un ciclo di DO.
Il LOOP deve essere allo stesso livello di IF del DO al quale si riferisce, altrimenti viene errore CN 7414 "--LOOP DURANTE --IF APERTO". Per esempio:
--DO --IF condizione --LOOP ;questo loop è errato perché viene in un IF aperto: dà allarme CN7414 --END IF
Invece lo EXIT DO può essere all'interno di un livello di IF, per esempio:
--DO --IF condizione --EXIT DO --END IF --LOOP
In questo caso lo EXIT DO chiude tutti I livelli di IF e l'esecuzione riprende dopo il LOOP
Anche l'istruzione DO può essere contenuta in un programma eseguito in DNC, ma in DNC c'è una limitazione alla lunghezza delle istruzioni che sono contenute nel corpo del DO: in DNC il corpo del DO (le istruzione comprese tra DO e LOOP) non può superare i 44k, altrimenti viene allarme CN7614 "CORPO --DO TROPPO GRANDE IN DNC"
Se viene programmato LOOP senza che ci sia un DO aperto viene allarme CN6E14 "LOOP SENZA DO" Se viene programmato EXIT DO senza che ci sia un DO aperto viene allarme CN7214"EXIT SENZA DO".
Struttura GOTO – LN Consente di saltare una serie di istruzioni. Sintassi:
CNC Z32 Programmazione Cap.6 - Funzioni di programmazione strutturata
- espressione è una qualsiasi espressione eseguibile da Z32 (la più semplice è un numero) - i blank tra GOTO e LN sono opzionali (è accettato anche GOTOLN) - i ";" e i commenti sono opzionali Dopo il GOTO sono saltate tutte le istruzioni fino alla riga destinazione LN, che è caratterizzata da un'espressione di valore numerico identico a quello dell'espressione del GOTO. La riga destinazione LN può essere solo in avanti nel programma rispetto alla riga GOTO. Esempio:
Si raccomanda attenzione nel caso di espressioni che contengono valori non interi, che potrebbero dare un comportamento inaspettato.
Per esempio, non funziona:
-- GOTO LN 0.9 ;commento istruzioni -- LN 1-0.1 ;questa riga non viene trovata!
La spiegazione è che le espressioni sono valutate da Z32 in un formato floating point binario troncato (non arrotondato), e che in questo formato i semplici numeri decimali 0,9 e 0,1 sono periodici (hanno un numero infinito di decimali) e quindi sono rappresentabili solo in forma approssimata.
E' come se con notazione decimale con 4 cifre significative si volesse confrontare il numero 2/3 con 3-1/3
2/3 vale 0,6666
1/3 vale 0,3333
3-1/3 vale 0,6667, che è diverso da 0,6666.
Si consiglia quindi di usare sempre espressioni intere, oppure valori numerici espliciti, che danno un'assoluta certezza di funzionamento.
Attenzione: se il file termina senza che sia trovata la riga destinazione si possono avere allarmi vari di difficile interpretazione. Vedere l'istruzione --OUT che aiuta la comprensione di questi casi.
Attenzione: non possono coesistere nello stesso programma o sottoprogramma istruzioni strutturate DO e istruzioni !GON…, altrimenti viene l'allarme CN 7114 INCOMPATIBILI --IF E -
DO CON !GON....!
Per i dettagli, vedere la struttura IF.
DEFINE – END DEFINE Consente di inviare allo Z32 come file di sottoprogramma una serie di istruzioni.
Sintassi:
-- DEFINE P numero ;commento
istruzioni
-- END DEFINE ;commento
dove:
- numero è un intero da 1 a 119 inclusi, che definisce il file interno di Z32 dove devono essere scritte le istruzioni contenute nel DEFINE. -non è possibile sovrascrivere il programma o sottoprogramma attualmente in esecuzione né programmi ai quali si deve fare ritorno (per esempio, se si sta eseguendo il sottoprogramma 25 che è chiamato con un !GOP! dal sottoprogramma 20, che a sua volta è chiamato con un !GOP! dal programma 1, non sono scrivibili i files 1, 20, 25)
- i caratteri ";" e i commenti sono opzionali - i blank sono opzionali (sono accettati anche DEFINEP e ENDDEFINE) Esempio: -- DEFINE P32 ;ciclo fisso di foratura speciale
CICLO FISSO DI FORATURA SPECIALE %
G0 Z<Z-30>
G1 Z<Z-20>
G4 TT.3
G0 Z<Z+50>
G26
-- END DEFINE
Questa struttura è destinata soprattutto ad editor evoluti, che inseriscano in un part-program (per esempio da inviare in DNC) anche macro o cicli fissi che possono non essere reperibili tra le macro o i cicli fissi di sistema.
All'interno di un DEFINE non può essere inserito un altro DEFINE, altrimenti viene allarme CN6C14 "DEFINE GIA APERTO".
Se si definisce un sottoprogramma con numero > 119, oppure il programma o sottoprogramma in esecuzione, oppure uno dei programmi ai quali si deve fare ritorno, viene errore CN7714 "ERRORE FILE NON SCRIVIBILE".
Se il numero file è irregolare (0 o con decimali o negativo …) viene allarme CN1D14 "ERRORE PROGRAMMA"
Se si trova un END DEFINE con DEFINE non aperto viene allarme CN6A14 "DEFINE NON APERTO"
All'interno di un DEFINE possono esserci istruzioni qualsiasi, strutturate e non strutturate (ad eccezione di --OUT che serve per verificare la chiusura del DEFINE), ma anche addirittura errate, che sono completamente ignorate in questa fase di scrittura nel file di Z32. Se risulteranno errori di esecuzione saranno messi in evidenza quando il sottoprogramma sarà eseguito.
Attenzione: se manca lo END DEFINE la scrittura prosegue fino a fine file e quindi si possono avere allarmi vari di difficile interpretazione. Vedere l'istruzione --OUT che aiuta la comprensione di questi casi.
Istruzione OUT Consente di dare allarme se l'esecuzione prosegue oltre la fine del file o del programma in DNC.
Sintassi:
-- OUT
Se viene incontrata questa istruzione viene un allarme CN 1D14 "ERRORE PROGRAMMA".
L'allarme viene in ogni caso, sia che questa riga debba essere eseguita sia che questa riga debba essere saltata per corpo di IF da non eseguire o per OTO (anche dentro un DEFINE).
Scopo di questa istruzione è rendere più chiaro il fatto che c'è stato un tentativo di leggere oltre la fine del file. Se la programmazione è corretta questa riga è del tutto inutile.
Se però questa riga non viene inserita e c'è un errore di programmazione tale da proseguire la lettura del programma oltre fine file (per esempio: un IF con condizione non vera che non è chiuso dallo END IF, un GOTO a una LN che non viene trovata, un DEFINE senza un END DEFINE) si ha:
- nel caso di esecuzione da file interno, viene un errore CN1D14 ERRORE PROGRAMMA su una riga nulla, perché viene letto il carattere 04 hex di chiusura del file che non è ammesso nelle righe di un part-program -nel caso di esecuzione da file interno con file chiuso irregolarmente (mancante di carattere 04 hex) viene un errore CMOS 5, lettura oltre fine file. Nota: il file di Z32 può essere chiuso irregolarmente (mancante di carattere 04 hex) se è creato con un editor esterno, e viene inviato a Z32 con i normali mezzi di comunicazione
- nel caso di esecuzione da DNC si ha un arresto in attesa di ulteriori istruzioni In nessuno di questi casi è facile capire immediatamente che si sta leggendo oltre fine file: se si inserisce la riga --OUT, che da' un errore programma e viene evidenziata come riga errata, si ha una migliore comprensione del problema.
Questa riga deve essere inserita a fine file, dopo l'ultima istruzione eseguibile (normalmente M2 o G26). Per esempio:
M2
-- OUT
oppure:
G26
-- OUT
Istruzione WAIT La funzione strutturata "WAIT" (da usare dall'utente finale su specifiche del costruttore) ha sintassi:
--WAIT condizione
dove la condizione è del tipo: espressione1 confronto espressione2
dove espressione1 ed espressione2 sono le espressioni matematiche accettate da Z32, e confronto è espresso da una delle condizioni "<", ">=", "=", ">=", ">". Per esempio:
--WAIT PAL[20] = 0
Dove le espressioni sono ridotte al loro essenziale (un parametro e una costante).
Lo scopo di questa istruzione, che arresta la lettura del part-program fino a che la condizione non è verificata, è sincronizzare il part-program col PLC di macchina con la minima perdita di tempo.
L'istruzione WAIT è compatibile anche con profili aperti, correzione raggio ecc., ma il progettista del PLC deve prendere tutte le precauzioni necessarie che tengano conto del fatto che la lettura del part-program può essere molti blocchi avanti rispetto all'esecuzione.
Per esempio, ammettiamo di trasmettere ordini al PLC con PAL[1] e di operare il sincronismo con G112. Il part-program potrebbe essere:
G112 (svuota dalle istruzioni in corso) PAL[1]<1+8+64+256+512> (accende i bit 0,3,6,8,9) PAL[20]1 (sync) --WAIT PAL[20]=0 (il PLC conferma di aver letto i bit contenuti in
PAL[1])
Naturalmente il PLC deve operare velocemente (sezione a 2 millisecondi) per il massimo risparmio di tempo.
Subroutines temporanee Per consentire una migliore gestione dei programmi e dei sottoprogrammi, delle macro, dei cicli fissi, è stata introdotta una nuova importante risorsa per il CNC Z32: le subroutines temporanee che nel seguito per brevità chiameremo subtemp.
Questa risorsa è stata creata espressamente per l'uso nell’interfaccia utente Z-flash ma è disponibile anche per programmazione manuale.
Le subtemp sono files interni di Z32 molto simili come struttura ai files CMOS, ma con importanti differenze.
Nei paragrafi che seguono si descrivono le caratteristiche delle subtemp. 1) Una subtemp si crea con un --DEFINE ed appartiene al part-program che la genera L'unico modo per generare una subtemp è dall'interno di un part-program con l'istruzione -DEFINE S…
Per esempio:
… -- DEFINE S20 (CICLO FISSO SEMPLICE DI FORATURA) G0 Z<HA> G1 Z<HB> G0 Z<HA> G26 -- END DEFINE …
Si noterà che questo DEFINE si affianca a quello già introdotto per i files CMOS (DEFINE P…): una delle differenze sostanziali è che le subtemp sono risorse "nuove", che quindi non vanno a turbare la struttura dei files CMOS di installazioni già consolidate.
Una subtemp è generata da un part-program e ne segue la vita: è, come dice il nome, "temporanea" in quanto scompare quando il part-program cessa o, a maggior ragione, se la macchina viene spenta.
3) Sono possibili fino a 64 subtemp per ogni processo, come si cancella una subtemp
Contrariamente ai files CMOS che, una volta creati, sono accessibili da qualsiasi processo, una subtemp è accessibile solo dal part-program e dal processo che l'ha generata.
Per esempio, in una macchina multiprocesso, se sono contemporaneamente in esecuzione due part-program, uno sul processo 0 e uno sul processo 1, i due part-program possono definire due diverse subtemp con lo stesso numero (per esempio DEFINE S3) senza che le due subtemp interferiscano tra loro.
Sono possibili fino a 64 subtemp per ogni processo (numerate da 1 a 64, lo zero è escluso).
Non esiste un'istruzione specifica per cancellare una subtemp, ma in caso di necessità si può sovrascrivere una subtemp già definita con un'altra nuova. In pratica l'equivalente della cancellazione di una subtemp si può ottenere sovrascrivendo una subtemp con una nulla.
4) Lo spazio totale disponibile è 1 Mb, la singola subtemp può arrivare a max 240 kb
Lo spazio di memoria disponibile per le subtemp (comprensive di tutti i processi) è di 1Mb.
Una singola subtemp può avere una lunghezza massima di 240k.
E' da notare che le subtemp sono destinate all'uso come cicli fissi e macro di sistema, quindi nell'uso "normale" non dovrebbero essere di grande lunghezza.
5) Cautele nella cancellazione di subtemp
In prima approssimazione si consiglia, finché ciò è possibile, di non cancellare e non sovrascrivere mai le subtemp, anche se apparentemente già usate: si ricorda che per effetto dell'anticipo della lettura delle righe rispetto alla loro esecuzione, sono sempre presenti un certo numero di righe già lette ma in attesa di esecuzione.
Poiché l'operazione DEFINE è un'operazione di lettura, se si cancella immediatamente una subtemp dopo averla letta, si possono avere problemi di visualizzazione (che può risultare errata) se il vecchio file viene soprascritto con un altro.
Poiché lo spazio di 1 Mb complessivo e la possibilità di 64 subtemp per processo appaiono più che sufficienti per le necessità di part-program "normali", si consiglia di numerare le subtemp a partire da 1 in poi e di non cancellarle mai (al RESET di macchina sono comunque automaticamente cancellate).
Se ci fossero necessità diverse, si consiglia comunque di cancellare le subtemp più vecchi tra quelle che non servono più, per evitare i problemi di visualizzazione sopra descritti.
6) Nelle subtemp non è ammesso il carattere $ di concatenazione, le righe sono di 240 caratteri
All'interno di una subtemp la lunghezza massima della riga è quella standard di Z32, ossia di 240 caratteri.
Contrariamente a quello che accade per i files CMOS, una riga subtemp non può essere concatenata con un'altra riga col carattere "$".
7) Nuove istruzioni per le subtemp: !GOS…!, G27S…
Dopo essere stata installata in memoria con l'istruzione --DEFINE S… una subtemp può essere richiamata, con istruzioni analoghe a quelle che richiamano i files CMOS di Z32:
!GOS…! (analoga alla !GOP…! per i files CMOS), per esempio:
!GOS2!
per fare un salto alla subtemp come sottoprogramma (il G26 di fine subtemp provoca il ritorno al programma chiamante).
!GOS…-N…-N…! (analoga alla !GOP…-N…-N…! per i files CMOS), per esempio:
!GOS2-N1-N20!
per fare un salto alla subtemp come sottoprogramma ed eseguire una serie di righe (il raggiungimento della riga fine provoca il ritorno al programma chiamante).
G27S… (analoga alla G27P… per i files CMOS), per esempio:
G27S8
per attivare una subtemp come ciclo fisso.
Da notare che le istruzioni G27C0 e G27S0 che annullano il ciclo fisso sono bivalenti, ossia entrambe annullano sia i cicli fissi di CMOS che i cicli fissi di subtemp. In altre parole, sia per annullare un G27S… che per annullare un G27C… si può usare indifferentemente G27C0 e G27S0.
All'interno di una subtemp sono ammesse (con le stesse modalità valide per i files CMOS) le istruzioni !GON…!, !GON…-N…!, !GOP…!.
8) Le subtemp sono sempre di utente, non possono essere di sistema
Z32 ha dei meccanismi di protezione di prestazioni critiche di sistema che sono ammesse in sottoprogrammi "di sistema" (file CMOS da 128 in su) ma sono vietate nei programmi e sottoprogrammi "di utente" (tutti gli altri).
Le subtemp sono sempre di utente, quindi da una subtemp non sono utilizzabili le risorse protette di sistema.
9) Da una subtemp non si possono attivare sezioni locali di utensili, origini, parametri
All'interno di una subtemp non sono attivabili le sezioni locali utensili, origini, parametri.
Si ricorda che le sezioni locali si attivano, da un file CMOS, con le istruzioni G37TL (utensili), G37OL (origini) e G37PL (parametri); se si usano queste istruzioni in una subtemp viene allarme CN7914 ERRORE SUB TEMPORANEE.
10) La G110 (macro di vuotatura) è incompatibile con le subtemp
La G110 (macro di vuotatura) è del tutto incompatibile con le subtemp, quindi viene allarme CN7914 ERRORE SUB TEMPORANEE se la G110 è programmata all'interno di una subtemp
oppure se il chiamante della G110 è una subtemp.
11) Non è possibile la ricerca blocco con stringa all'interno di una subtemp
Non è possibile una ricerca blocco con stringa all'interno di una subtemp, ossia non c'è il corrispondente del comando P… dell'attività 3 di ricerca blocco.
![[Immagine logo società]](_borders/Banner.gif)
