richiamo modale senza spostamento asse

[LUCA XYZ]

Salve ragazzi,mi sono scritto un programma per Fanuc per poter incidere caratteri alfanumerici su metallo.
In pratica tramite l'assegnazione di una variabile il controllo passa al sottoprogramma che identifica il carattere corrispondente al valore assegnato per poi saltare alla porzione di codice che esegue il percorso in incrementale del carattere stesso. la domanda é, per poter semplificare al massimo il programma principale,c'é una possibilita di richiamare modalmente il sottoprogramma senza specificare un movimento asse,visto che il sottoprogramma è completamente in incrementale e quindi non necessita di spostamenti? praticamente vorrei solo poter scrivere per ogni riga di istruzione la variabile con assegnato il nuovo valore del carattere che segue Ciao

[torn24]

non ho capito molto il problema
ma se deve essere eseguito ad ogni spostamento usi G66 Modale
se no fai una successione di G65 senza nessun spostamento assi

[LUCA XYZ]

Per farla il più semplice possibile, mi chiedevo se esistesse una sorta di richiamo modale G66 che non utilizzasse uno spostamento asse per essere innescato ma l'assegnazione di una variabile. Ciao

[torn24]

No non esiste nessuna funzione standard che faccia questo , da quel che ne so io almeno
ma puoi sicuramente ottenere il risultato , con un altro approccio
esempio mettiamo che la macro riceva come unico parametro la lettera da incidere , come ti ho detto una successione di G65 risolvono
il problema

ESEMPIO di come vorresti fare tu

GX P1000
#100=1
#100=20

......

COME POTRESTI FARE
G65 P1000 A1
G65 P1000 A20
.......
Nel sottoprogramma macro metti tanti IF quante sono le lettere ,che saltano alla porzione di codice voluta
IF[#1EQ1]GOTO 100 (Esegue il codice per la A)
......
.....
IF[#1EQ20]GOTO 200(Esegue il codice per altra lettera)
GOTO 1000
N100
....LAVORAZIONE
GOTO 1000
N1000 M99
p.s. il linguaggio macro permette di fare molto , che permettesse tutto sarebbe esagerato

[LUCA XYZ]

Si ma difatti il programma gia funziona con il richiamo tramite M98, mi chiedevo solo se ci fosse un metodo ancora più diretto come appunto è il G66.
grazie per l'interessamento ciao

[fanuc84]

ciao potresti darmi questo programma per incidere lettere e numeri,ma come funziona
ciao grazie

[LUCA XYZ]

Ciao,il programma in sè è piuttosto semplice,praticamente nel programma principale si assegna ad una variabile un valore che corrisponde ad un carattere.Per esempio al carattere A corrisponde 1 al B 2 etc.
Nel sottoprogramma una serie di salti IF fanno saltare alla porzione di programma che esegue il percorso corrispondente al carattere tornando poi al programma principale per leggere il valore del carattere successivo e cosi via.
I caratteri sono programmati completamente in incrementale con il punto di partenza e di arrivo fissi ,cosi stabilita la posizione dell'utensile,da li comincera ad incidere facendo seguire ad ogni carattere il successivo.Un altro vantaggio della programmazione in incrementale è che moltiplicando gli spostamenti di ogni asse per una costante assegnata tramite variabile,si puo variare altezza e larghezza del carattere.
il lavoraccio sta nel programmare ogni singolo carattere...
I percorsi per i caratteri non li cedo,ma se vuoi crearti il tuo programma e non sono riuscito a spiegarmi sulla logica del programma chiedi che magari a ragionarci in due salta fuori qualcosa di meglio.

[Skyzzo]

Si ma difatti il programma gia funziona con il richiamo tramite M98, mi chiedevo solo se ci fosse un metodo ancora più diretto come appunto è il G66.
grazie per l'interessamento ciao

Ciao,intendi chiamare un sottoprogramma con un codice G e passare info????

[LUCA XYZ]

Ciao son riuscito a far funzionare il programma come intendevo,per capirsi nella prima versione il programma principale passava al sottoprogramma il valore della variabile cosi

#100=1
M98P2
#100=2
M98P2
#100=3
M98P2
etc...

Io volevo trovare il sistema per poter fornire al sottoprogramma i valori dei caratteri tutti in una volta,ordinatamente uno di seguito all'altro e in principio al programma.
Sono riuscito nell'intento creando un loop che ad ogni giro utilizzasse di volta in volta le variabili incrementando di uno il numero della stessa. praticamente cosi

O1(PROGRAMMA INCISIONE CARATTERI)

#101=1 qui si assegna alle variabili il valore dei caratteri desiderati per
#102=2 incidere i caratteri ABC l'accortezza e di utilizzare variabili dalla 101 con numerazione progressiva
#103=3

#104=0 il valore zero chiude sempre la lista delle variabili,è il valore che
interrompe il ciclo portando a termine il programma

#150=5(LARGHEZZA CARATTERE)
#160=7.5(ALTEZZA CARATTERE)
#152=.05(PROFONDITA INCISIONE)

#153=[#150/3]
#163=[#160/5]
IF[#153GT#163]THEN#173=#153
IF[#163GT#153]THEN#173=#163
IF[#163EQ#153]THEN#173=#153

T20M6(BULINO)
G61
G52X0Y3Z110
(PRIMA RIGA)
G54G0X0Y0F500
G43Z2H20D20
#140=0 da qui comincia il loop che giro dopo giro incrementa
N1 il valore della variabile da prendere in considerazione
#140=[#140+1]
#100=#[100+#140]
IF[#100EQ0]GOTO2 quando questa condizione è soddisfatta il loop si
M98P2 interrompe saltando alla fine del programma
GOTO1

N2
M165
M30

Ciao a tutti

[badade]

Ciao,
esiste la funzione G66.1!
Questa funzione è valida dalle versioni 30 in poi, non è quindi implementata nelle versioni precedenti.
Il funzionamento del G66.1 è lo stesso del G66: G66.1 è il richiamo incondizionato, G67 lo cancella.
Il richiamo è incondizionato, cioè la macro viene richiamata per ogni blocco contenente un comando nc.
O, nome file, codici N, codici G non vengono eseguiti come tali (col loro significato nc), ma vengono trattati come argomenti macro.
In pratica il G66.1 si comporta come una successione di G65 permettendo quindi di variare gli argomenti senza riscrivere il richiamo.

G66.1 P2 A B C X Y ....
X100 Y100
A45 C34

è come scrivere

G65 P2 X100 Y100 ....
G65 P2 A45 C34 ....

per il G66.1 sono valide le regole del richiamo macro generale.
Se possiedi un Fanuc serie 30/31/32 avrai la possibilità  di usare il G66.1, altrimenti dovrai ricorrere a soluzioni alternative.

Il programma da te esposto, anche se funzionante ma non mostrato completamente, è un po' ingarbugliato. Naturalmente ognuno scrive per le conoscenze che possiede e per come crede meglio.... dopo tutto ciò che importa è che il tutto funzioni (ma ci sono situazioni impreviste ....). Personalmente dico sempre di creare programmi parametrici "grezzi". Una volta testati è preferibile apportare tutte le modifiche necessarie al fine di ottenere qualcosa che sia il più semplice possibile: è la soluzione migliore? cosa ne pensano gli altri operatori? quali difetti trovano? ho considerato ogni possibile situazione? ...
Dato che hai già  un programma capace di scrivere le lettere la cosa migliore (dato il problema della ricorsione) sarebbe realizzare un
parser, un algoritmo di decifrazione atto a leggere una frase. Potresti pensare di passare al programma la frase (o la parola) e non
il singolo carattere, potresti pensare di scrivere una macro e non un programma parametrico. A me sembra che questo modo di ragionare sia più profiquo.
Una cosa del genere (argomenti e valori presi a caso): G500 A() X Y Z K T
Definisci la posizione di inizio scrittura (X Y Z ), definisci il fattore riduzione/ingrandimento (K), definisci lo stile (T).
Devi concentrarti sull'argomento A() dove le parentesi rappresentano una forma generale di scrittura che indica semplicemente la
relazione con il parser (che dovrai realizzare). Sei tu che decidi cosa fare e come implementare il tutto.
Certamente una scrittura del genere, G500 A() X10 Y10 Z-0.3 K1 T3, è da preferire all'uso di notevoli variabili e programmi.

Questo non toglie nulla al tuo programma e alle tue capacità , è solo una riflessione sulle diverse tipologie di scrittura che abbiamo
a disposizione... io implementerei cosi il programma di scrittura

[El Ventu]

Io mi sono messo a fare a tempo perso un parametrico su tornio mori seiki nl2500sy.
Il programma parte con il posizionamento (lavoro sulla faccia) parametro per altezza base scritta (in X) e centro scritta (Y), altezza carattere, larghezza definita in 0.3 volte l'altezza, un parametro definisce la larghezza totale + spazi,e questo mi da una base per la partenza in y del primo carattere.
Da li la programmazione dei caratteri è incrementale.
Non ho fatto sottoprogrammi per i caratteri, ma li ho piazzati in coda tra un numero riga e un goto che riporta al calcolo.
Mettendo un salto determinato da un altro parametro dopo il ritorno alla partenza, si passa al secondo carattere e cosi via.
Il richiamo del numero di riga della lavorazione del carattere è determinato direttamente dalla parte di programma che fa la somma in base 10 del numero pezzo.
Ad esempio,4 cifre determinate da #100,#101,#102,#103, la prima cifra richiama la parte di programma del primo carattere, con goto#100 se #100 equivale a "1" si salta a N1, che scrive la cifra 1 e avanti.
Così si evita di fare salti a sottoprogrammi,e con un solo programma richiamato a fine pezzo si fa la marcatura.

[El Ventu]

Collaudato, se interessa fatemi sapere...

[johnny86]

A me interessa, riesci a passarmelo o è protetto da copyright?