Il camming, è una tecnica di controllo del moto applicabile ad assi servoassistiti e consente di risolvere applicazioni in cui uno o più assi “slave” devono percorrere spazi, anche non omogenei, rimanendo sempre in sincronismo rispetto alla posizione di un asse di riferimento chiamato “master”. L’asse master può essere un asse reale o virtuale (master simulato).
Le tipiche applicazioni sono:

• Tagli e lavorazioni al volo, sia lineari che circolari, su plastica, lamiera, cartone.
• Nel confezionamento in sostituzione delle camme meccaniche.
• Nella bobinatura di cavo, filo metallico, reggia ecc. con funzioni di guidafilo.
• Nel tessile e nell’alimentare nelle macchine “affaldatrici” per la stratificazione di tessuti o pasta alimentare.
• Nella stampa serigrafica o flexografica con clichè circolari.
• Nelle linee di “trasporto prodotto” per la spaziatura e/o la sincronizzazione dei materiali movimentati.

La posizione assoluta che deve assumere l’asse slave è sempre espressa in funzione della posizione assoluta dell’asse master e questa associazione viene inserita in una tabella specifica detta “cam table”.
La “cam table” è composta da 128 settori; ogni settore è composto da:
CodeG = istruzione operativa del settore in uso.
CodeQm = posizione incrementale del master, in unità di misura; sono accettati incrementi solo positivi.
CodeQs = posizione incrementale dello slave , in unità di misura; sono accettati incrementi sia positivi che negativi.
CodeM = codice numerico generale, utilizzabile dalla logica PLC.
CodeQma = quota master ausiliaria utilizzata con le istruzioni operative speciali.
CodeQsa = quota slave ausiliaria utilizzata con le istruzioni operative speciali.

Utilizzando le istruzioni operative codeG associate a ciascun settore della camma si può definire con quale legge di moto (accelerazione, decelerazione, velocità costante…) l’asse slave si deve muovere percorrendo lo spazio stabilito in codeQs nello stesso tempo in cui il master percorre lo spazio definito come codeQm.
Finchè il master si muove a velocità costante, lo spazio percorso dall’asse master risulta direttamente proporzionale al tempo trascorso ed essendo gli spazi codeQs e codeQm definiti sempre nello stesso intervallo di tempo anche la legge di moto applicata all’asse slave, all’interno del settore, risulta applicabile in modo direttamente proporzionale allo spazio percorso dal master nel settore; il master e lo slave risultano perciò legati in spazio tra loro. Se la velocità costante scelta per il master corrisponde alla massima sarà possibile valutare immediatamente anche quali saranno le massime accelerazioni, decelerazioni e velocità a cui verrà sottoposto l’asse slave.
Questo procedimento consente di formulare la legge di moto dell’asse slave in funzione del tempo per valutare le prestazioni dinamiche richieste dall’applicazione e di applicare poi la stessa legge di moto in funzione dello spazio percorso dal master durante l’esecuzione della camma.
Per rendere semplice il calcolo delle posizioni assolute del master e dello slave si assume che il master si muova ad una velocità costante per cui le posizioni degli assi possono essere rappresentate in un diagramma cartesiano Velocità / Tempo. Di seguito si riporta un semplice esempio di compilazione della “cam table”.

Per poter eseguire una camma come nell’esempio, bisogna compilare la “cam table” nel modo seguente:

Naturalmente QEM rimane a disposizione per aiutare i clienti nella compilazione della “cam table”.
Il device si può dividere in due parti principali:

• Un posizionatore asse slave con rampe trapezoidali o epicicloidali selezionabili.
• Un gestore camme analogiche.

Lo schema a blocchi di base è il seguente:

Nel file di configurazione (.CNF), la sezione BUS deve essere dichiarata in modo tale che siano presenti le risorse hardware necessarie all’implementazione del device CAMMING4. Devono essere presenti almeno due contatori bidirezionali ed una uscita analogica con risoluzione 16 bit. Nella sezione INTDEVICE del file .CNF deve essere aggiunta la seguente definizione:

;-------------------------------
; Dichiarazione device interni
;-------------------------------
  INTDEVICE
 
<nome_device>  CAMMING4  TCamp  CountS  CountMA  CountMB  IntL  IAZero  IntLM  IAZeroM  InG  InGInt  IoutA  Out

Dove:

;---------------------------------
; Dichiarazione devices interni
;---------------------------------
INTDEVICE
 
AsseX    CAMMING4   2  2.CNT01  2.CNT02 1.CNT01 1 2.INP01 2
2.INP02             2.INP03     5       2.AN01  2.OUT01

Esempio applicativo Si prende come esempio un device CAMMING4 configurato come nello START UP e con la parametrizzazione dell’asse (set-up) già scritto.
Nel task viene prima inizializzato il device e poi gestito un ingresso in interruzione il quale riporta il suo stato su un’uscita.
Il task verrà così svolto:

;-------------------------------------
; Gestione del device CAMMING4
;-------------------------------------
INIT AsseX                        ; Inizializza l’asse
WAIT AsseX:st_init                ; Attendi che l’asse sia inizializzato
LOOPON AsseX                      ; Aggancia il loop di regolazione
WAIT AsseX:st_loopon              ; Attendi che l’asse abbia agganciato il
                                  ; loop di regolazione
CALOFF AsseX                      ; Esci dall’eventuale calibrazione
                                  ; dell’asse
WAIT NOT AsseX:st_cal             ; Attendi che il device non sia in
                                  ; calibrazione
CNTUNLOCK AsseX                   ; Sblocca il contatore master
WAIT NOT AsseX:st_cntlock         ; Attendi che il contatore master sia
                                  ; sbloccato
CNTDIR AsseX                      ; Imposta il giusto senso di incremento
                                  ; del contatore slave
WAIT NOT AsseX:st_cntrev          ; Attendi che il contatore slave sia
                                  ; impostato nel senso di incremento
CNTUNLOCKM AsseX                  ; Sblocca il contatore master
WAIT NOT AsseX:st_cntlockm        ; Attendi che il contatore master sia
                                  ; sbloccato
CNTDIRM AsseX                     ; Imposta il giusto senso di incremento
                                  ; del contatore master
WAIT NOT AsseX:st_cntrevm         ; Attendi che il contatore master sia
                                  ; impostato nel senso di incremento
REGON AsseX                       ; Sblocca la regolazione
WAIT NOT AsseX:st_regoff          ; Attendi lo sblocco della regolazione
 
MAIN:
IF AsseX:st_int                   ; Se la linea di interrupt è attiva
  AsseX:funOut = 2                ; attiva l’uscita
ELSE
  AsseX:funOut = 1                ; disattiva l’uscita
ENDIF
 
ENDIF                             ; FINE
 
WAIT 1
JUMP MAIN
END

Il device CAMMING4 lascia all’installatore la possibilità di lavorare con risoluzioni encoder non finite impostando i dati come spazio percorso in un giro encoder (measure) e numero di impulsi giro dell’encoder (pulse).
Il rapporto tra measure e pulse è la risoluzione dell’encoder e deve avere valori compresi tra 1 e 0.000935.

Definizioni:

1. Il parametro measure viene inserito in unità di misura senza punti decimali (ad esempio 100.0 millimetri viene inserito 1000 decimi di millimetro).
2. Il parametro pulse viene inserito in bit encoder per 4 (ad esempio se ho collegato un encoder da 1024 impulsi giro, viene inserito 4096, se il parametro measure viene calcolato su un giro di encoder).

Esempio: Si deve controllare una tavola rotante che abbia la precisione di 0,1° avente un encoder da 1024 impulsi giro calettato direttamente; si imposteranno i seguenti valori:
measure = 3600
pulse = 4096

Se per l’unità di misura scelta é prevista anche la presenza di un punto decimale, le posizioni devono essere rappresentate sempre come valore intero e rappresentare lo spazio nell’unità di misura senza punto decimale. La risoluzione deve quindi essere calcolata con lo stesso metodo e nel parametro measure la grandezza senza punto decimale. Il punto decimale verrà poi inserito nei visualizzatori in fase di rappresentazione del valore (es. come proprietà nel terminale operatore). Questo parametro può assumere valori 0÷3.

Le velocità sono sempre espresse in unità di misura intere nell’unità di tempo scelta. Da questo si ricava che il device deve comunque conoscere la posizione del punto decimale dell’unità di misura e questo viene fatto con il parametro decpt.

In questo paragrafo viene descritto solamente l’utilizzo di alcuni di comandi; per le descrizioni relative a tutto il set di comandi si rimanda ai capitoli seguenti.
I due comandi principali sono quello che danno inizio ed interrompono l’esecuzione della camma: STARTCAM e STOPCAM. Esistono poi una serie di comandi dediti al controllo dell’emergenza, il loop di reazione, lo START e lo STOP all’asse.

Al comando STARTCAM, l’asse slave si aggancia al master e seguirà l’andamento descritto nella camma partendo sempre dal primo settore. Non è possibile dare uno STARTCAM durante l’esecuzione della camma (st_camex = 1); tale controllo viene lasciato al programmatore.
La camma si sgancerà automaticamente se incontrerà un istruzione di END oppure sarà possibile fermarla in rampa utilizzando il comando di STOPCAM.

Se la camma è in esecuzione (st_camex = 1), una volta ricevuto il comando di STOPCAM l’asse slave si sgancia immediatamente dal master, porta la sua velocità a zero seguendo la rampa di decelerazione impostata (parametro tdec) e rimanendo in reazione di spazio. La rampa di decelerazione è asincrona rispetto al master.

Al comando di START, l’asse slave si posiziona alla quota dichiarata nella variabile setpos con la velocità impostata in setvel; il posizionamento verrà eseguito utilizzando la rampa di accelerazione impostata nel parametro tacc e la rampa di decelerazione impostata nel parametro tdec.
Il tipo di rampa utilizzata (trapezoidale o epicicloidale) è inserita nel parametro ramptype.

Se durante il posizionamento (non durante l’esecuzione di una camma) è necessario fermare l’asse con una rampa di decelerazione, sarà sufficiente dare il comando di STOP e l’asse decelera fino a fermarsi con la rampa impostata nel parametro tdec.

Durante il posizionamento é possibile variare la velocitá dell’asse senza influenzare la posizione da raggiungere. Questa operazione può determinare un aumento o una diminuzione della velocitá, anche in più punti dello stesso posizionamento. Questa operazione viene eseguita con nuova scrittura nel parametro setvel. Il cambio di velocità è sempre disponibile tranne durante la rampa di decelerazione e uno stato apposito segnala il possibile cambio di velocità (st_chvel = 1)

Durante il posizionamento possono essere variati anche i tempi di accelerazione/decelerazione. Per esempio il device può avviare un posizionamento con una rampa molto breve e, una volta raggiunta la velocitá impostata, viene variato il parametro tacc ed eseguito un cambio di velocitá con una rampa molto lunga.
Per applicazioni particolari e in presenza di rampe trapezoidali, il tempo di rampa può essere variato anche durante una variazione di velocitá, in questo caso il nuovo tempo viene messo in esecuzione immediatamente.

Questo comando mette l’asse in condizioni di emergenza; lo stato st_emrg viene posto ad uno. Se il comando di emergenza viene inviato all’asse durante un posizionamento, il movimento viene interrotto senza rampa di decelerazione, l’uscita analogica viene impostata a zero volt e viene sganciata la reazione di spazio. Se la camma è attiva (st_camex = 1), il movimento viene interrotto senza rampa di decelerazione, l’uscita analogica viene impostata a zero volt, viene sganciata la reazione di spazio e la camma (st_camex = 0).
Con st_emrg = 1 (condizione di emergenza), non è possibile movimentare l’asse.

Con questo comando viene resettata la condizione di emergenza; l’asse entra in reazione di spazio ed attende un comando per potersi muovere (non riprende automaticamente il posizionamento interrotto).

Il comando LOOPOFF toglie la reazione di spazio senza fermare l’asse. Con st_loopon = 0 l’asse accetta i comandi di movimentazione asse ma tutti i posizionamenti saranno eseguiti senza reazione di spazio.
Un posizionamento fatto senza loop di reazione è paragonabile ad un posizionamento eseguito senza guadagno proporzionale (non viene garantito l’arrivo in posizione).

Il comando LOOPON chiude l’anello di spazio senza fermare l’asse. Con st_loopon = 1 l’asse viene movimentato utilizzando tutte le caratteristiche del controllo P.I.D.

A seguito si riporta una tabella che riassume le condizioni necessarie per avere l’asse in reazione di spazio e per eseguire dei posizionamenti.

Il movimento epicicloidale viene utilizzato per movimentare gli assi senza brusche variazioni di velocità. Il tempo di posizionamento di un asse movimentato con le rampe trapezoidali è lo stesso rispetto allo stesso asse movimentato con le rampe epicicloidali, ma le rampe epicicloidali variano il gradiente di velocità (accelerazione) con un massimo a metà della rampa stessa.
Per confronto viene mostrata la differenza dell’andamento dell’accelerazione nei due casi: con rampa lineare (trapezoidale) e con rampa epicicloidale.

Lo stesso vale anche per la rampa di decelerazione.
Il movimento epicicloidale ha la possibilità di comportarsi in modi diversi nel caso di riduzione di profilo (rtype) e nel caso di stop durante la rampa di accelerazione (stopt) se la camma non è in esecuzione (st_camex = 0).

	La riduzione del profilo viene utilizzata solamente se si sta eseguendo un posizionamento e non se si sta eseguendo una camma (st_camex = 0).

Nel caso in cui la camma non è in esecuzione (st_camex = 0) e lo spazio da percorrere sia minore di quello che consente di raggiungere la velocità impostata eseguendo le rampe di accelerazione e decelerazione, si passa nella fase chiamata “riduzione di profilo”.
È possibile mantenere fisso il tempo delle rampe, diminuendo i gradienti delle rampe e la velocità in proporzione (parametro rtype impostato a 0).

È inoltre possibile diminuire il tempo delle rampe mantenendo il gradiente di accelerazione costante e diminuire la velocità in proporzione (parametro rtype impostato a 1).

Con il parametro rtype impostato a 0 si allungano notevolmente i tempi necessari ai posizionamenti piccoli con relativa perdita di produttività della macchina, invece impostandolo a 1 si hanno nel caso di posizionamenti brevi tempi ridotti, ma mantenendo il gradiente costante si perde l'effetto benefico dell'epicicloide.

	Il tipo di stop durante le rampe viene utilizzato solamente se si sta eseguendo un posizionamento e non se si sta eseguendo una camma (st_camex = 0).

Nel caso in cui la camma non è in esecuzione (st_camex = 0) e si debba frenare l'asse durante la rampa di accelerazione con il comando di STOP si deve scegliere se far completare la rampa oppure se si vuole interrompere la rampa e di conseguenza modificare l'epicicloide.
Nel caso in cui si imposti il parametro stopt a 0 viene prima completata la rampa di accelerazione e poi eseguita la rampa di decelerazione.

Nel caso in cui si imposti il parametro stopt a 1 viene interrotta la rampa di accelerazione e iniziata immediatamente la rampa di decelerazione impostata.

Si nota immediatamente che esiste una differenza sostanziale tra il settaggio di stopt a 0 o a 1. Per fare la scelta di quale tipo di stop utilizzare, bisogna tener conto che in caso di fermata di emergenza esiste il comando di emergenza che blocca istantaneamente e senza rampa il posizionamento.

	Prima di iniziare dei posizionamenti veri e propri è necessario verificare che collegamenti elettrici ed organi meccanici non siano causa di malfunzionamenti.

Per la gestione dell'asse, il device utilizza un'uscita analogica con range ±10 V e risoluzione 16 bit con segno; con la funzione di calibrazione questa uscita analogica può essere pilotata con un valore costante con lo scopo di verificare collegamenti e funzionalità.

• Togliere la condizione di emergenza con il comando RESUME.
• Lo stato st_emrg = 0
• Abilitare lo stato di taratura asse con il comando CALON; lo stato st_cal deve quindi assumere il valore 1.
• É ora possibile impostare la tensione analogica con il parametro vout; il valore é espresso in decimi di volt (-100 ÷ 100 = -10 ÷ 10 V). Si consiglia di introdurre valori bassi (5, 10, 15 … pari a 0.5, 1, 1,5 V).
• Quando l’asse é in movimento il parametro frq indica la frequenza in Hz delle fasi del trasduttore.
• Il parametro posit che visualizza la posizione, varia indicando lo spazio compiuto dall’asse.
  Se impostando una tensione positiva il conteggio si decrementa, é necessario invertire le fasi del trasduttore o invertire la direzione nell’azionamento.
• È possibile invertire la direzione del conteggio utilizzando il comando CNTREV.
• Se con tensione di uscita uguale a zero l’asse non é fermo, agire sul parametro offset per correggere la tensione finché il movimento non si arresta. Il valore introdotto (ogni bit corrisponde a circa 0.3 mV), viene sommato algebricamente al valore dell’uscita analogica; questa operazione permette di compensare l’eventuale deriva propria del componente elettronico, sia in uscita da QMOVE che in ingresso all’azionamento. Il valore é espresso in bit con segno.
  Per un ottimale risultato della taratura l’operazione deve essere eseguita con il sistema a regime di temperatura.
• Per disabilitare lo stato di taratura inviare il comando CALOFF.
• Lo stato st_cal = 0

Il device genera il valore di tensione dell’uscita analogica sulla base di una proporzione tra la velocitá massima dell’asse e la massima tensione di uscita. La proporzionalità è ottenuta con il parametro maxvel, rappresentante la velocitá dell’asse relativa alla massima tensione analogica (10 V). Ovviamente l’asse deve avere un comportamento simmetrico rispetto al valore zero di tensione analogica, quindi la velocitá deve essere la stessa sia alla tensione massima positiva che alla massima negativa.
Prima di determinare il valore della velocitá massima, bisogna stabilire l’unità di tempo da utilizzare per la rappresentazione delle velocitá nel device; il parametro unitvel definisce l’unità di tempo della velocità (Um/min oppure Um/s).

Il metodo teorico é un calcolo eseguito sulla base della velocitá massima del motore. Una volta stabiliti i giri massimi al minuto dichiarati del motore, si ricava la velocitá massima espressa nell’unità di misura sull’unità di tempo scelti.
Introdurre il valore di velocitá massima calcolato nel parametro maxvel.

Il metodo pratico si basa sulla lettura della velocitá rilevata dal device nel parametro vel, fornendo all’azionamento una tensione nota. Per fornire la tensione all’azionamento il device deve essere posto nella condizione di calibratura come descritto nel paragrafo precedente. Se il sistema lo permette, fornire all’azionamento una tensione di 10 V e leggere il valore di velocità nel parametro vel. Se, al contrario, viene fornita una porzione della tensione in uscita (1, 2, … 5 V), calcolare la velocitá massima con una proporzione.
Introdurre il valore trovato di velocitá massima nel parametro maxvel.

	Prima di movimentare l'asse, verificare il corretto funzionamento dei dispositivi di emergenza e protezione.

Le procedure fin qui descritte hanno permesso di completare la prima fase di parametrizzazione del device. Ora é possibile eseguire una semplice movimentazione dell'asse.

• Spostare l'asse in una posizione tale per cui possa compiere un determinato spazio senza toccare i finecorsa di quota massima e minima.
• Impostare la posizione attuale dell'asse al valore zero, settando il parametro posit = 0.
• Impostare i parametri che definiscono la posizione dei finecorsa software: minpos = 0 e maxpos al valore della corsa massima dell'asse.
• Impostare il parametro che definisce il tempo impiegato dall'asse per raggiungere la velocitá massima tacc = 100. Questo parametro é espresso in centesimi di secondo (100 = 1 sec.)
• Impostare la velocitá di posizionamento con il parametro setvel.
• Impostare la quota di destinazione con il parametro setpos.
• Impostare il parametro feedfw = 1000 (100%)
• Se il device é in stato di emergenza (st_emrg = 1) dare il comando RESUME.
• Avviare il posizionamento con il comando START. In per arrestare il movimento dare il comando EMRG.

Questa prima movimentazione é stata eseguita senza la retroazione di spazio. Il posizionamento potrebbe essere stato eseguito con un certo errore introdotto dalla non linearità dei componenti o da una imperfezione nella taratura della velocitá massima. Successivamente abilitando la retroazione di spazio questo errore scompare.

Il posizionamento eseguito nel paragrafo precedente é stato realizzato senza considerare eventuali errori di posizione.
Per controllare la corretta posizione dell’asse in maniera continua ed automatica, è necessario avere un feed-back sulla posizione; per questo motivo viene introdotto l’algoritmo di regolazione PID+FF comprendente azioni di tipo proporzionale, integrale, derivativo e feed-forward; il valore dell’uscita analogica è dato dalla sommatoria delle azioni feed forward, proporzionale, integrativa e derivativa.
Senza entrare nel merito di una descrizione tecnica della teoria della regolazione, in questo paragrafo vengono descritte una serie di operazioni per regolare i parametri che influenzano questo controllo.
Per realizzare una regolazione soddisfacente è sufficiente utilizzare solamente le azioni feedforward e proporzonale; le azioni integrale e derivativa vengono utilizzate solamente per regolazioni in condizioni particolari.

Il feed-forward contribuisce a rendere il sistema più pronto nei posizionamenti, fornendo all’uscita analogica un valore di tensione proporzionale alla velocitá teorica di posizionamento. In pratica é la componente grazie alla quale sono stati eseguiti i posizionamenti del capitolo precedente.
Può essere regolato il contributo di questa azione mediante il parametro feedfw; questo parametro é espresso come porzione millesimale della velocitá teorica; quindi, per introdurre ad esempio 98.5 % è necessario impostare 985 (millesimi).

Questa azione fornisce un’uscita proporzionale all’errore di posizione istantaneo dell’asse. L’entità dell’azione proporzionale é definita dal parametro pgain che definisce la sensibilità del sistema.
Il parametro pgain viene introdotto in millesimi; il valore unitario del guadagno (1000) fornisce un’uscita analogica al massimo valore (10 V) relativamente al massimo errore di velocitá. Per massimo errore di velocitá si intende lo spazio compiuto dall’asse - alla massima velocità - per la durata del tempo di campionamento del device.

Integra l’errore di posizione del sistema nel tempo impostato nel parametro integt aggiornando l’uscita finché l’errore non viene annullato.
Più basso è il tempo di integrazione dell’errore, più veloce è il sistema nel recupero dell’errore, ma il sistema può diventare instabile tendendo ad oscillare.

Anticipa la variazione del moto del sistema tendendo ad eliminare gli overshoot del posizionamento. L’entità della variazione viene calcolata nel tempo impostato nel parametro derivt.
Più alto è il tempo di derivazione dell’errore e più veloce è il sistema nel recupero dell’errore nei transitori, ma se viene inserito un valore troppo alto il sistema diventa instabile tendendo quindi ad oscillare.

Per poter muovere l’asse slave si deve innanzitutto dichiarare la parametrizzazione dell’asse. Una volta eseguita questa fase si ipotizza di voler far muovere l’asse slave con i jog manuali utilizzando gli ingressi Inp01 per movimentare l’asse in avanti e l’ingresso Inp02 per spostarlo indietro.
Come esempio consideriamo un device configurato come nello START UP. Nel task viene prima inizializzato il device e poi gestito il jog manuale.

;----------------------------------------------------
; Gestione del jog manuale
;----------------------------------------------------
 
INIT AsseX                        ; Inizializza l’asse
WAIT AsseX:st_init                ; Attendi che l’asse sia inizializzato
LOOPON AsseX                      ; Aggancia il loop di regolazione
WAIT AsseX:st_loopon              ; Attendi che l’asse abbia agganciato il
                                  ; loop di regolazione
CALOFF AsseX                      ; Esci dall’eventuale calibrazione
                                  ; dell’asse
WAIT NOT AsseX:st_cal             ; Attendi che il device non sia in
                                  ; calibrazione
CNTUNLOCK AsseX                   ; Sblocca il contatore master
WAIT NOT AsseX:st_cntlock         ; Attendi che il contatore master sia
                                  ; sbloccato
CNTDIR AsseX                      ; Imposta il giusto senso di incremento del
                                  ; contatore slave
WAIT NOT AsseX:st_cntrev          ; Attendi che il contatore slave sia
                                  ; impostato nel senso di incremento
CNTUNLOCKM AsseX                  ; Sblocca il contatore master
WAIT NOT AsseX:st_cntlockm        ; Attendi che il contatore master sia
                                  ; sbloccato
CNTDIRM AsseX                     ; Imposta il giusto senso di incremento del
                                  ; contatore master
WAIT NOT AsseX:st_cntrevm         ; Attendi che il contatore master sia
                                  ; impostato nel senso di incremento
REGON AsseX                       ; Sblocca la regolazione
WAIT NOT AsseX:st_regoff          ; Attendi lo sblocco della regolazione
MAIN:
IF Inp01 AND Inp02                ; Se gli ingressi Inp01 e
                                  ; Inp02 sono attivi
  IF NOT AsseX:st_still           ; Se l’asse non è fermo
    STOP AsseX                    ; Ferma l’asse
  ENDIF
ENDIF
 
IF Inp01 AND NOT Inp02            ; Se l’ingresso Inp01 è
                                  ; attivo e l’ingresso
                                  ; Inp02 è disattivo
  IF AsseX:st_still               ; Se l’asse è fermo
    AsseX:setvel=AsseX:maxvel/10  ; Imposto la velocità di
                                  ; movimento manuale
    MANFW AsseX                   ; Avanti manuale
  ENDIF
ELSE
  IF NOT Inp02                    ; Se l’ingresso Inp02
                                  ; è disattivo
    IF NOT AsseX:st_still         ; Se l’asse non è fermo
      STOP AsseX                  ; Ferma l’asse
    ENDIF
  ENDIF
ENDIF
 
IF Inp02 AND NOT Inp01            ; Se l’ingresso Inp02
                                  ; è attivo e l’ingresso
                                  ; Inp01 è disattivo
  IF AsseX:st_still               ; Se l’asse è fermo
    AsseX:setvel=AsseX:maxvel/10  ; Imposto la velocità di
                                  ; movimento manuale
    MANBW AsseX                   ; Indietro manuale
  ENDIF
ELSE                              ; Altrimenti
  IF NOT Inp01                    ; Se l’ingresso Inp01 è
                                  ; disattivo
    IF NOT AsseX:st_still         ; Se l’asse non è fermo
      STOP AsseX                  ; Ferma l’asse
    ENDIF
  ENDIF                           ; FINE
 
WAIT 1
JUMP MAIN
END

Il device non ha al suo interno datagroup o array dati dove è possibile contenere vari tipi di camme, percui, se si devono gestire camme diverse in base al tipo di lavorazione, ci si deve appoggiare ai tool della CPU e scaricare i dati sul device ogni volta che ve ne è la necessità.

Con questo esempio viene gestita la programmazione della camma con i dati inseriti nel secondo programma di un datagroup. Il device è configurato come descritto nello startup.

;--------------------------------------------------
; File di configurazione
;--------------------------------------------------
 
;--------------------------------------------------
; Variabili Globali
;--------------------------------------------------
GLOBAL
gfProgram   F     ;Abilitazione programmazione camma
 
;--------------------------------------------------
; Variabili System
;--------------------------------------------------
SYSTEM
sbPuntProg  B     ;Numero del programma da porre in esecuzione
 
;--------------------------------------------------
; Variabili Datagroup
;--------------------------------------------------
DATAGROUP
dgCamma
 
DATAPROGRAM   10   ;10 programmi disponibili
ddlCode       L    ;codice del programma
 
STEP          128  ;128 passi di programma disponibili
ddbCodeG      B    ;Codice G
ddlCodeQs     L    ;Codice Qs
ddlCodeQs     L    ;Codice Qm
ddlCodeM      L    ;Codice M
ddlCodeQma    L    ;Codice Qm ausiliario
ddlCodeQsa    L    ;Codice Qs ausiliario
 
;--------------------------------------------------
; Task di programmazione camma
;--------------------------------------------------
MAIN:
  .
  .
  sbPuntProg = 2 ;Imposto il puntatore di programma
  .
  .
 
;--------------------------------------------------
; Programmazione del device CAMMING4
;--------------------------------------------------
IF gfProgram
   AsseX:codeG1     = ddbCodeG   [sbPuntProg , 1] ;Settore 1
   AsseX:codeQm1    = ddlCodeQm  [sbPuntProg , 1] ;Settore 1
   AsseX:codeQs1    = ddlCodeQs  [sbPuntProg , 1] ;Settore 1
   AsseX:codeQma1   = ddlCodeQma [sbPuntProg , 1] ;Settore 1
   AsseX:codeQsa1   = ddlCodeQsa [sbPuntProg , 1] ;Settore 1
   AsseX:codeM1     = ddlCodeM   [sbPuntProg , 1] ;Settore 1
   AsseX:codeG2     = ddbCodeG   [sbPuntProg , 2] ;Settore 2
   AsseX:codeQm2    = ddlCodeQm  [sbPuntProg , 2] ;Settore 2
   AsseX:codeQs2    = ddlCodeQs  [sbPuntProg , 2] ;Settore 2
   AsseX:codeQma2   = ddlCodeQma [sbPuntProg , 2] ;Settore 2
   AsseX:codeQsa2   = ddlCodeQsa [sbPuntProg , 2] ;Settore 2
   AsseX:codeM2     = ddlCodeM   [sbPuntProg , 2] ;Settore 2
   .
   .
   AsseX:codeG128   = ddbCodeG   [sbPuntProg , 128] ;Settore 128
   AsseX:codeQm128  = ddlCodeQm  [sbPuntProg , 128] ;Settore 128
   AsseX:codeQs128  = ddlCodeQs  [sbPuntProg , 128] ;Settore 128
   AsseX:codeQma128 = ddlCodeQma [sbPuntProg , 128] ;Settore 128
   AsseX:codeQsa128 = ddlCodeQsa [sbPuntProg , 128] ;Settore 128
   AsseX:codeM128   = ddlCodeM   [sbPuntProg , 128] ;Settore 128
 
   gfProgram = 0
ENDIF

Il device CAMMING4 gestisce dei settori di camma programmati in incrementale, all’interno dei quali vengono riportati lo spazio da percorrere dal master e lo spazio che deve percorrere lo slave. Una camma è composta da più settori i quali possono essere di accelerazione, di decelerazione, di cambio velocità o dedicati ad operazioni particolari come, ad esempio, il rifasamento conteggi o loop camma.
Ogni settore della camma deve contenere delle informazioni relative a:

• codeG tipo di settore
• codeQm quota master (ATTENZIONE: inserire valori solo positivi)
• codeQs quota slave
• codeQma quota master ausiliaria (ATTENZIONE: inserire valori solo positivi)
• codeQsa quota slave ausiliaria
• codeM codice di utilizzo generico, il quale viene visualizzato attraverso la variabile codeMex. In genere contiene lo stato degli utensili, gli stati particolari della camma, ecc.

Il settore di accelerazione viene utilizzato con asse slave fermo (velocità slave uguale a zero, indipendentemente dalla velocità del master); alla fine del settore la velocità dello slave è uguale a quella del master.
I casi tipici di accelerazione sono riportati nelle figure A, B, C e D.
Nell'esempio di figura A, alla fine del settore la velocità dello slave sarà uguale a quella del master; la legge che lega lo spazio master e quello slave è:
Spazio slave = 1/2 Spazio master
Più piccolo è lo spazio master che si considera e maggiore sarà il gradiente di accelerazione dello slave, il quale lo possiamo ricavare dalla formula:
Tempo acc. slave = Spazio master nel settore di acc. / Velocità massima master

	Nel caso in cui ci si trovi di fronte a questo tipo di accelerazione si consiglia l'utilizzo del codice codeG = 132.

Figura A

Esempio di programmazione

• codeG 132
• codeQm Spazio Master
• codeQs Spazio Slave
• codeQma Non utilizzato
• codeQsa Non utilizzato
• codeM codice generico

	Nel caso si volessero utilizzare le rampe epicicloidali, si consiglia l'utilizzo del codice codeG = 232.

Nel caso in cui si vogliano utilizzare le rampe epicicloidali per accelerare rispettando lo stesso funzionamento descritto per il settore 132, è sufficiente programmare il settore come descritto sopra e programmando il codeG = 232.

Nell'esempio di figura B, alla fine del settore la velocità dello slave è in proporzione alla velocità del master (la proporzione verrà chiamata K), la legge che lega lo spazio master e lo spazio slave è:
Spazio slave = K/2 Spazio master
Più piccolo è lo spazio master che si considera e maggiore sarà il gradiente di accelerazione dello slave, il quale lo possiamo ricavare dalla formula:
Tempo di acc. slave = Spazio master nel settore di acc. / Velocità massima master

	Nel caso in cui ci si trovi di fronte a questo tipo di accelerazione è obbligatorio l'utilizzo del codice codeG = 131.

Figura B

Esempio di programmazione

• codeG 131
• codeQm Spazio Master
• codeQs Spazio Slave
• codeQma Non utilizzato
• codeQsa Non utilizzato
• codeM codice generico

<^^Nel caso si volessero utilizzare le rampe epicicloidali, si consiglia l'utilizzo del codice codeG = 231.^

Nel caso in cui si vogliano utilizzare le rampe epicicloidali per accelerare rispettando lo stesso funzionamento descritto per il settore 131, è sufficiente programmare il settore come descritto sopra e programmando il codeG = 231.
Nell'esempio di figura C, si vogliono delle accelerazioni spinte, e non è possibile impostare delle quote Master/Slave di valore finito. Il settore 150 è in pratica la somma di due settori: 131 e 133. Tale settore è utilizzato quando si conoscono gli spazi successivi al settore di accelerazione e si vuole uno spazio slave accelerativo molto piccolo, anche inferiore all'unità di misura. Il settore 150 si avvale dei seguenti parametri:

• codeG : codice settore (150)
• codeQma : indica lo spazio master entro il quale lo slave si deve portare a una certa velocità, che chiameremo di sincronizzazione.
• codeQm e codeQs : la cui divisione indica il rapporto tra lo spazio slave e master (rapporto di sincronizzazione) . Questi spazi saranno effettuati dopo la sezione accelerativa.
• codeQsa : indica lo spazio in impulsi encoder che deve percorrere lo slave nella fase di accelerazione per raggiungere la velocità di sincronizzazione.
  Più piccolo è lo spazio master che si considera e maggiore sarà il gradiente di accelerazione dello slave, il quale lo possiamo ricavare dalla formula:
  Tempo di acc. Slave = Spazio master nel settore di acc. / Velocità massima master

	Nel caso in cui ci si trovi di fronte a questo tipo di accelerazione è obbligatorio l'utilizzo del codice codeG = 150.

Figura C

Esempio di programmazione

• codeG 150
• codeQm Spazio Master
• codeQs Spazio Slave
• codeQma Spazio Master in accelerazione
• codeQsa Spazio Slave in accelerazione (bit * 4)
• codeM codice generico

Nell'esempio di figura D, si vogliono delle accelerazioni spinte, e non è possibile impostare delle quote Master/Slave di valore finito. Il settore 152 è in pratica come il settore 131. Tale settore è utilizzato quando si conosce il rapporto di sincronizzazione e si vuole uno spazio slave accelerativo molto piccolo, anche inferiore all'unità di misura.
Il settore 152 si avvale dei seguenti parametri:

• codeG : codice settore (152)
• codeQma : indica lo spazio master entro il quale lo slave si deve portare a una certa velocità, che chiameremo di sincronizzazione.
• codeQm e codeQs : la cui divisione indica il rapporto tra lo spazio slave e master (rapporto di sincronizzazione).
• codeQsa : indica lo spazio in impulsi encoder che deve percorrere lo slave nella fase di accelerazione per raggiungere la velocità di sincronizzazione.
  Più piccolo è lo spazio master che si considera e maggiore sarà il gradiente di accelerazione dello slave, il quale lo possiamo ricavare dalla formula:
  Tempo di acc. Slave = Spazio master nel settore di acc. / Velocità massima master

	Nel caso in cui ci si trovi di fronte a questo tipo di accelerazione è obbligatorio l'utilizzo del codice codeG = 152.

Figura D

Esempio di programmazione

• codeG 152
• codeQm Coefficente Master
• codeQs Coefficente Slave
• codeQma Spazio Master in accelerazione
• codeQsa Spazio Slave in accelerazione (bit * 4)
• codeM codice generico

	Nel caso si volessero utilizzare le rampe epicicloidali, si consiglia l'utilizzo del codice codeG = 252.

Nel caso in cui si vogliano utilizzare le rampe epicicloidali per accelerare rispettando lo stesso funzionamento descritto per il settore 152, è sufficiente programmare il settore come descritto sopra e programmando il codeG = 252.

Nel caso in cui sia necessario fermare l'asse slave (indipendentemente dalla sua velocità), rimanendo agganciati con la camma (velocità zero indipendentemente dalla velocità del master), può essere utilizzato il settore di decelerazione.
Nell'esempio di figura E, alla fine del settore, la velocità dello slave sarà uguale a zero; la legge che lega lo spazio master e quello slave (la proporzione tra la velocità master e quella slave verrà chiamata K) è:
Spazio slave = K/2 Spazio master
Più piccolo è lo spazio master che si considera e maggiore sarà il gradiente di decelerazione dello slave, che è possibile ricavare da:
Tempo di dec. Slave = Spazio master nel settore di dec. / Velocità massima master

	Nel caso in cui ci si trovi di fronte ad una decelerazione è obbligatorio l'utilizzo del codice codeG = 135.

Figura E

Esempio di programmazione

• codeG 135
• codeQm Spazio Master
• codeQs Spazio Slave
• codeQma Non utilizzato
• codeQsa Non utilizzato
• codeM codice generico

	Nel caso si volessero utilizzare le rampe epicicloidali, si consiglia l'utilizzo del codice codeG = 235.

Nel caso in cui si vogliano utilizzare le rampe epicicloidali per accelerare rispettando lo stesso funzionamento descritto per il settore 135, è sufficiente programmare il settore come descritto sopra e programmando il codeG = 235.

Nell'esempio di figura F, si vogliono delle decelerazioni spinte, e non è possibile impostare delle quote Master/Slave di valore finito. Il settore 151 è in pratica la somma di due settori: 133 e 135. Tale settore è utilizzato quando si conoscono gli spazi precedenti al settore di decelerazione e si vuole uno spazio slave decelerativo molto piccolo, anche inferiore all'unità di misura.
Il settore 151 si avvale dei seguenti parametri:

• codeG : codice settore (151)
• codeQma : indica lo spazio master entro il quale lo slave si deve portare da una certa velocità, che chiameremo di sincronizzazione a velocità zero.
• codeQm e codeQs : la cui divisione indica il rapporto tra lo spazio slave e master (rapporto di sincronizzazione) . Questi spazi sono effettuati prima della sezione decelerativa.
• codeQsa : indica lo spazio in impulsi encoder che deve percorrere lo slave nella fase di decelerazione.

Più piccolo è lo spazio master che si considera e maggiore sarà il gradiente di decelerazione dello slave, il quale lo possiamo ricavare dalla formula:
Tempo di dec. Slave = Spazio master nel settore di dec. / Velocità massima master

	Nel caso in cui ci si trovi di fronte a questo tipo di decelerazione è obbligatorio l'utilizzo del codice codeG = 151.

Figura F

Esempio di programmazione

• codeG 151
• codeQm Spazio Master
• codeQs Spazio Slave
• codeQma Spazio Master in decelerazione
• codeQsa Spazio Slave in decelerazione (bit * 4)
• codeM codice generico

	Per poter effettuare queste operazioni esistono due tipi di codici (codeG = 133 e codeG = 134) i quali si differenziano solamente per la scelta della velocità che si vuole dare allo slave alla fine del settore di cambio velocità.

Il settore di cambio velocità può essere utilizzato:

• Ogni volta che l'asse slave deve raggiungere una velocità (diversa da zero), partendo da un diverso valore di velocità (anch'esso diverso da zero).
• Ogni volta che l'asse slave deve mantenere una velocità costante.

Nell'esempio la velocità dello slave è uguale a quella del master (all'inizio del settore di cambio velocità). Nel caso in cui la velocità sia diversa è necessario considerare, nelle formule a seguire, la costante del rapporto delle velocità master e slave all'inizio del settore.
Il codeG = 133 prevede che la velocità dello slave alla fine del settore possa essere diversa da quella iniziale e la velocità finale dello slave (di fine settore), dipenderà esclusivamente dal rapporto degli spazi master/slave (vedi figura G).
Ci si trova infatti di fronte a tre casi:

1. Rapporto master/slave < 1 Velocità dello slave a fine settore > della velocità del master
2. Rapporto master/slave = 1 Velocità dello slave a fine settore = della velocità del master
3. Rapporto master/slave > 1 Velocità dello slave a fine settore < della velocità del master

La velocità alla fine del settore sarà data dalla formula:
Vel. Slave = Vel. Master + { [ 2 (Spazio Slave - Spazio Master) / Spazio Master ] x 100 } %

Figura G

Esempio di programmazione

• codeG 133
• codeQm Spazio Master
• codeQs Spazio Slave
• codeQma Non utilizzato
• codeQsa Non utilizzato
• codeM codice generico

	Nel caso si volessero utilizzare le rampe epicicloidali, si consiglia l'utilizzo del codice codeG = 233.

Nel caso in cui si vogliano utilizzare le rampe epicicloidali per accelerare rispettando lo stesso funzionamento descritto per il settore 133, è sufficiente programmare il settore come descritto sopra e programmando il codeG = 233.
Il codeG = 134 prevede che la velocità dello slave alla fine del settore sia uguale a quella iniziale e la velocità a metà settore dello slave dipenderà esclusivamente dal rapporto degli spazi master/ slave (vedi figura H). Ci si trova infatti di fronte a tre casi:

1. Rapporto master/slave < 1 Velocità dello slave al centro del settore > della velocità del master
2. Rapporto master/slave = 1 Velocità dello slave al centro del settore = della velocità del master
3. Rapporto master/slave > 1 Velocità dello slave al centro del settore < della velocità del master

La velocità al centro del settore sarà data dalla formula:
Vel. slave = Vel. master + { [ 2 (Spazio slave - Spazio master) / Spazio master ] x 100 } % x (Vel. master)

Figura H

Esempio di programmazione

• codeG 134
• codeQm Spazio Master
• codeQs Spazio Slave
• codeQma Non utilizzato
• codeQsa Non utilizzato
• codeM codice generico

	Nel caso si volessero utilizzare le rampe epicicloidali, si consiglia l'utilizzo del codice codeG = 234.

Nel caso in cui si vogliano utilizzare le rampe epicicloidali per accelerare rispettando lo stesso funzionamento descritto per il settore 134, è sufficiente programmare il settore come descritto sopra e programmando il codeG = 234.
Se viene programmato un settore 133, 134, 233 o 234 con spazio master e slave a 0, viene considerato come un settore non operativo (codeG = 130).
Nell'esempio di figura I, si vuole cambiare velocità allo slave, e non è possibile impostare un rapporto Master/Slave di valore finito. Il settore 153 è in pratica come il settore 133. Tale settore è utilizzato quando si conosce il rapporto di sincronizzazione e si vuole uno spazio slave accelerativo molto piccolo, a volte anche inferiore all'unitá di misura.
Il settore 153 si avvale dei seguenti parametri:

• codeG : codice settore (153)
• codeQma : indica lo spazio master entro il quale lo slave si deve portare a una certa velocità, che chiameremo di sincronizzazione.
• codeQm e codeQs : la cui divisione indica il rapporto tra lo spazio slave e master (rapporto di sincronizzazione).
• codeQsa : il device indica lo spazio in impulsi encoder che ha percorso lo slave per raggiungere la velocità di sincronizzazione dopo la fase di accelerazione.

	Nel caso in cui ci si trovi di fronte a questo tipo di cambio velocità, è consigliato l'utilizzo del codice codeG = 153.

Figura I

Esempio di programmazione

• codeG 153
• codeQm Coefficente Master
• codeQs Coefficente Slave
• codeQma Spazio Master in accelerazione
• codeQsa Spazio Slave in accelerazione (bit * 4)
• codeM codice generico

	Nel caso si volessero utilizzare le rampe epicicloidali, si consiglia l'utilizzo del codice codeG = 253.

Nel caso in cui si vogliano utilizzare le rampe epicicloidali per accelerare rispettando lo stesso funzionamento descritto per il settore 153, è sufficiente programmare il settore come descritto sopra e programmando il codeG = 253.

Nell'esempio di figura L, si vuole portare lo slave ad una velocità senza dovere eseguire una rampa di raccordo. Il settore 154 a differenza di tutti gli altri, impone la velocità iniziale uguale alla velocità finale mantenendo la velocità costante tra i due punti. Questo settore può essere utilizzato come settore di partenza della camma (partenza senza accelerazione), come settore intermedio oppure come ultimo settore (fermata senza rampa).
Il settore 154 si avvale dei seguenti parametri:

• codeG : codice settore (154)
• codeQma : Tipo di addolcimento settore
• codeQm e codeQs : la cui divisione indica il rapporto tra lo spazio slave e master (rapporto di sincronizzazione). Questi spazi vengono eseguiti durante il settore.
• codeQsa : Se impostato a 0 indica che il settore successivo è un settore di movimento, se viene impostato a 1 indica che il settore successivo non prevede il movimento (decelerazione con rampa zero).

	Nel caso in cui ci si trovi di fronte a questo tipo di movimento è obbligatorio l'utilizzo del codice codeG = 154.

Figura L

Esempio di programmazione

• codeG 154
• codeQm Spazio Master
• codeQs Spazio Slave
• codeQma Tipo di addolcimento settore
• codeQsa
  0 = settore sucessivo di movimento
  1 = asse fermo nel settore successivo
  2 = Albero elettirco
• codeM codice generico

Dal grafico di figura L si possono notare i gradini di velocità nel cambio tra un settore ed il successivo. Per eliminare questi gradini si è inserita la funzione di addolcimento cambio settore la quale prevede di inserire una rampa di addolcimento tra i due settori in modo da rendere meno “ruvido” il passaggio tra un settore ed il successivo.
La programmazione dell’addolcimento può essere fatta semplicemente inserendo nel codeQma se si vuole l’addolcimento sfruttando la metà, un terzo, un quarto oppure un quinto del settore più piccolo. Naturalmente l’addolcimento viene eseguito solamente tra due settori 154 adiacenti, senza aver frapposto nessun codeG diverso (cambio conteggio, jump, etc.).

Figura M

Il codeQma ha il seguente significato:
0 = Nessun addolcimento
1 = Addolcimento di 1/2 del settore più piccolo
2 = Addolcimento di 1/3 del settore più piccolo
3 = Addolcimento di 1/4 del settore più piccolo
4 = Addolcimento di 1/5 del settore più piccolo

Nel caso in cui si vogliano utilizzare le rampe epicicloidaliper le variazioni di velocità, rispettando lo stesso funzionamento descritto per il settore 154, è sfficente programmare il settore come descritto sopra e utilizzare il codeG=254.

Per programmare un settore come albero elettrico si devono programmare i parametri come descritto in seguito:
codeG1 = 154
codeQma1 = 0
codeQsa1 = 2
codeQm1 = numeratore del rapporto di velocità
codeQs1 = denominatore del rapporto di velocità
Una volta dato il comando di Startcam al device, gli unici valori modificabili del settore sono codeQs e codeQsa, se altri valori vengono modificati con la camma in esecuzione si incorre nell’errore 5 e il device va in emergenza.
Il rapporto tra codeQm e codeQs indica, rispettivamente, il rapporto Master/Slave dell’albero elettrico, ed in particolare questo rapporto può essere modificato dinamicamente (con camma in esecuzione) agendo solo sul parametro codeQs. Questi parametri seguono sempre la legge del minimo spazio in tempo di campionamento (cioè, lo spazio fatto dal master in un tempo di campionamento del device, a velocità massima, deve essere minore di quello impostato su codeQm), per cui, onde evitare errori sulla camma, è preferibile impostare dei valori sufficientemente alti; ad es. per un rapporto 1:1 i valori potrebbero essere codeQm=1000 e codeQs = 1000.
La nuova velocità dello Slave dovuta al nuovo rapporto viene raggiunto immediatamente dall’asse senza alcuna rampa, per cui se si desidera avere una variazione graduale della velocità si dovrà cambiare gradualmente il rapporto fino a raggiungere quello desiderato.
Se si imposta il valore 0 o 1 su codeQsa si passa al settore successivo (nel caso non si sia programmato nessun settore successivo per fermare il device è sufficiente dare uno Stop-cam). Le variabili positm e posit (conteggio Master e conteggio Slave) vengono automaticamente riportate rispettivamente al valore d codeQm e codeQs nel momento esatto in cui il valore delle variabili stesse supera il valore impostato in CodeQm (per postm) e CodeQs (per posit).

	In una tipica configurazione utilizzante Q1-CPU-DA02 con 2 assi interpolati circolarmente più un asse tangente, il tempo di campionamento minimo impostabile è di 4 millisecondi (3 mS per i 3 devices CAMMING4 e 1mS per il master simulato).

Il device CAMMING4 ha la possibilità di gestire l'asse Slave con andamenti trigonometrici del tipo seno, coseno o tangente in modo che combinando più assi slave si possono muovere gli assi realizzando interpolazioni circolari, elicoidali, con assi tangenti e tutte le movimentazioni di questo tipo con il vantaggio che il limite del numero di assi da movimentare è costituito solamente dal tempo di campionamento che si dichiara nella configurazione dell'applicativo e che è direttamente proporzionale al numero di assi utilizzato.
Come è noto dalla trigonometria, le coordinate cartesiane di un qualsiasi punto appartenente ad una circonferenza sono rappresentabili dalle funzioni Y = R * sen(a) e X = R * cos(a).“

Figura N

Per realizzare l'interpolazione circolare tra gli assi X e Y è necessario legare il moto dei due assi a quello di un unico Master (anche simulato). Se la traiettoria percorsa nello spazio dal punto A al punto B è un arco di circonferenza, possiamo dichiarare che in tale spazio Master gli assi Slave X e Y dovranno muoversi in funzione del raggio R e dell'angolo a. La velocità di percorrenza del master simulato determina la velocità di interpolazione tra gli assi, cioè la velocità di un ipotetico punto lungo la traiettoria sul piano XY.
Il rapporto di velocità tra il Master e lo Slave è al massimo 1. Quindi, nel caso di utilizzo di due assi Slave legati allo stesso Master, bisogna che la velocità massima con cui si muove il Master (simulato o no) sia uguale alla più piccola tra le due velocità massime dei due Slave. Se a questo sistema si aggiunge un terzo asse Camming 4 utilizzante lo stesso Master simulato, questo asse sarà sempre direzionato sulla tangente della circonferenza.
Di seguito vengono riportati degli esempi applicativi tenendo conto che:
codeG = 170 =⇒ Seno orario
codeG = 171 =⇒ Seno antiorario
codeG = 172 =⇒ Coseno orario
codeG = 173 =⇒ Coseno antiorario
codeG = 174 =⇒ Tangente oraria
codeG = 175 =⇒ Tangente antioraria
codeG = 180 =⇒ Rifasamento asse tangente

Nel caso in cui sia necessario muovere l'asse slave in funzione del seno e si vuol seguire la traiettoria rispetto al senso orario della circonferenza, si deve utilizzare il codeG = 170. Se viene programmato il valore del raggio della circonferenza da realizzare (codeQm) positivo, viene eseguito l'arco di circonferenza più corto, mentre se è negativo, viene percorso l’arco più lungo.
Esempio di programmazione

• codeG 170
• codeQm Raggio della circonferenza espressa in unità di misura
• codeQs Spostamento dell'asse Slave X (device in programmazione)
• codeQma Visualizzazione dello spazio Master eseguito nel settore in unità di misura
• codeQsa Spostamento dell'asse Slave Y (device associato)
• codeM codice generico

Nel caso in cui sia necessario muovere l'asse slave in funzione del seno e si vuol seguire la traiettoria rispetto al senso antiorario della circonferenza, si deve utilizzare il codeG = 171. Se viene programmato il valore del raggio della circonferenza da realizzare (codeQm) positivo, viene eseguito l'arco di circonferenza più corto, mentre se è negativo, viene percorso l'arco più lungo.
Esempio di programmazione

• codeG 171
• codeQm Raggio della circonferenza espressa in unità di misura
• codeQs Spostamento dell'asse Slave X (device in programmazione)
• codeQma Visualizzazione dello spazio Master eseguito nel settore in unità di misura
• codeQsa Spostamento dell'asse Slave Y (device associato)
• codeM codice generico

Nel caso in cui sia necessario muovere l'asse slave in funzione del coseno e si vuol seguire la traiettoria rispetto al senso orario della circonferenza, si deve utilizzare il codeG = 172. Se viene programmato il valore del raggio della circonferenza da realizzare (codeQm) positivo, viene eseguito l'arco di circonferenza più corto, mentre se è negativo, viene percorso l'arco più lungo.
Esempio di programmazione

• codeG 172
• codeQm Raggio della circonferenza espressa in unità di misura
• codeQs Spostamento dell'asse Slave X (device associato)
• codeQma Visualizzazione dello spazio Master eseguito nel settore in unità di misura
• codeQsa Spostamento dell'asse Slave Y (device in programmazione)
• codeM codice generico

Nel caso in cui sia necessario muovere l'asse slave in funzione del coseno e si vuol seguire la traiettoria rispetto al senso antiorario della circonferenza, si deve utilizzare il codeG = 173. Se viene programmato il valore del raggio della circonferenza da realizzare (codeQm) positivo, viene eseguito l'arco di circonferenza più corto, mentre se è negativo, viene percorso l'arco più lungo.
Esempio di programmazione

• codeG 173
• codeQm Raggio della circonferenza espressa in unità di misura
• codeQs Spostamento dell'asse Slave X (device associato)
• codeQma Visualizzazione dello spazio Master eseguito nel settore in unità di misura
• codeQsa Spostamento dell'asse Slave Y (device in programmazione)
• codeM codice generico

Nel caso in cui sia necessario muovere l'asse slave in funzione della tangente e si vuol seguire la traiettoria rispetto al senso orario della circonferenza, si deve utilizzare il codeG = 174. Se viene programmato il valore del raggio della circonferenza da realizzare (codeQm) positivo, viene eseguito l'arco di circonferenza più corto, mentre se è negativo, viene percorso l'arco più lungo.
Esempio di programmazione

• codeG 174
• codeQm Raggio della circonferenza espressa in unità di misura
• codeQs Spostamento dell'asse Slave
• codeQma Visualizzazione dello spazio Master eseguito nel settore in unità di misura
• codeQsa Spostamento dell'altro asse Slave
• codeM codice generico

Nel caso in cui sia necessario muovere l'asse slave in funzione della tangente e si vuol seguire la traiettoria rispetto al senso antiorario della circonferenza, si deve utilizzare il codeG = 175. Se viene programmato il valore del raggio della circonferenza da realizzare (codeQm) positivo, viene eseguito l'arco di circonferenza più corto, mentre se è negativo, viene percorso l'arco più lungo.
Esempio di programmazione

• codeG 175
• codeQm Raggio della circonferenza espressa in unità di misura
• codeQs Spostamento dell'asse Slave
• codeQma Visualizzazione dello spazio Master eseguito nel settore in unità di misura
• codeQsa Spostamento dell'altro asse Slave
• codeM codice generico

Nel caso in cui sia necessario rifasare l'asse Slave per recuperare l'eventuale errore di posizione angolare dell'asse tangente, che si è sfasata per le aprossimazioni nei calcoli angolari, si deve utilizzare il codeG = 180. Nel codeQs si deve inserire la differenza di posizione dell'asse da recuperare espresso in unità di misura.
Esempio di programmazione

• codeG 180
• codeQm Non utilizzato
• codeQs Valore del recupero dell'asse Slave espresso in unità di misura
• codeQma Non utilizzato
• codeQsa Non utilizzato
• codeM Non utilizzato

Si vuol collegare il punto iniziale A con il punto finale B con un arco di circonferenza avente raggio R.
Sappiamo che per 2 punti passano 2 circonferenze aventi raggio R, percui si deve fare la scelta di quali dei 4 archi di circonferenza vogliamo percorrere. La scelta viene fatta seguendo quanto riportato nella figura 0. Con i termini AsseX ed AsseY si intendono i devices che gestiscono rispettivamente gli assi X ed Y del sistema.

Figura O

L’arco di circonferenza tra il punto A e il punto B può essere eseguito attraverso una delle quattro traiettorie I, II, III, IV. Con R = 26, ?X = 15 e ?Y = 33 la programmazione per ottenere ognuna di queste quattro traiettorie è:

Con riferimento all’esempio precedente si illustra il legame esistente tra i parametri codeG (174, 175), codeQm dei settori che gestiscono l’asse tangente e gli archi di circonferenza congiungenti il punto iniziale A al punto finale B. Con il termine Asset si intende il device che gestisce l’asse tangente. L’esempio di figura P riporta il caso delle traiettorie piú lunghe; per scegliere quelle piú brevi basta porre codeQm = R mentre il significato dei codeG rimane lo stesso. La freccia in grassetto rappresenta l’asse.
Poiché si assume che l’asse tangente sia correttamente posizionato all’inizio di ogni settore, non si fa la distinzione tra asse a destra/sinistra del verso di avanzamento ma ci si limita a riservare due settori per il movimento orario e antiorario.

Figura P

Molte volte esiste la necessità di far partire lo slave su un punto del master noto, ma non esiste la possibilità di collegarsi ad un sensore di prossimità. L’unico vincolo è che il settore contenente il codeG 160 deve essere il primo settore di movimento della camma e non può essere messo in ciclo. Al comando di STARTCAM, lo stato st_camex va a 1 ed Il movimento dell’asse Slave inizia solo al superamento della quota Master (espressa in unità di misura) impostata nel settore 160 e da li seguirà l’andamento descritto nei settori successivi.
Se lo STARTCAM é dato con il conteggio master superiore alla quota impostata, viene settato il warning 9; in queste condizioni il conteggio Master deve divenire minore della quota impostata per poter trovarsi nella giusta situazione di partenza del sistema. Non è possibile entrare in un settore con codeG = 160 provenendo da un jump o da un loop camma (errore 7).

Esempio di programmazione

• codeG 160
• codeQm Quota di STARTCAMMA espressa in unità di misura
• codeQs Non utilizzato
• codeQma Non utilizzato
• codeQsa Non utilizzato
• codeM Non utilizzato

Il settore di cambio fine camma (codeG = 136), viene utilizzato ogni volta che si deve concludere la camma (sganciare la camma) fermando l’asse slave in reazione di spazio sull’ultimo punto della camma. Naturalmente l’asse slave deve essere fermo al momento dello sgancio della camma, percui si presume che il settore precedente contenga il codice di decelerazione (codeG = 135).
Dopo aver eseguito questo settore la camma è sganciata e, per riagganciarla, bisogna inviare il comando di STARTCAM.

Esempio di programmazione

• codeG 136
• codeQm Non utilizzato
• codeQs Non utilizzato
• codeQma Non utilizzato
• codeQsa Non utilizzato
• codeM Non utilizzato

Il settore di absolute jump (codeG = 137), viene utilizzato per fare un salto ad un settore (definito nel codeQm) per poter modificare al volo l’andamento della camma in base a delle condizioni stabilite dal programmatore.
La situazione più comune per l’utilizzo di questa funzione è quella di una parte della camma che deve essere ripetuta parecchie volte.
Bisogna fare attenzione al fatto che i conteggi non vengono aggiornati e quindi a lungo andare possono andare in overflow. Si consiglia quindi di utilizzare i settori di aggiornamento conteggio nel settore che precede quello contenente il codeG = 137.

Esempio di programmazione

• codeG 137
• codeQm Numero del settore a cui saltare
• codeQs Non utilizzato
• codeQma Non utilizzato
• codeQsa Non utilizzato
• codeM Non utilizzato

Il settore di jump condizionato (codeG = 190), viene utilizzato per fare un salto ad un settore (definito nel codeQm) per un certo numero di volte (definito nel codeQs) dopo di che si passa al settore successivo. Il conteggio del numero di salti eseguiti è disponibile nel codeQma.
Bisogna fare attenzione al fatto che i conteggi non vengono aggiornati e quindi a lungo andare possono andare in overflow. Si consiglia quindi di utilizzare i settori di aggiornamento conteggio nel settore che precede quello contenente il codeG = 190.

Esempio di programmazione

• codeG 190
• codeQm Numero del settore a cui saltare
• codeQs Numero di volte
• codeQma Visualizzazione numero salti effettuati
• codeQsa Non utilizzato
• codeM Non utilizzato

Il settore di loop camma (codeG = 138), viene utilizzato per ripetere la camma in esecuzione dal settore numero uno, azzerando per sottrazione sia i conteggi master che slave.
Si consiglia l’utilizzo di questo codice nelle camme ripetute all’infinito che non hanno problemi di sottrazione dei conteggi.

Esempio di programmazione

• codeG 138
• codeQm Non utilizzato
• codeQs Non utilizzato
• codeQma Non utilizzato
• codeQsa Non utilizzato
• codeM Non utilizzato

Il settore non operativo (codeG = 130), viene utilizzato per riservare dei settori a delle funzioni da eseguire solamente in condizioni particolari definite dal programmatore.
Per esempio si può considerare una camma per il taglio al volo, nella quale è necessario riservare dei settori da utilizzare nel caso in cui, meccanicamente, non si riesca a fare il taglio nello spazio master riservato a tale operazione.

Esempio di programmazione

• codeG 130
• codeQm Non utilizzato
• codeQs Non utilizzato
• codeQma Non utilizzato
• codeQsa Non utilizzato
• codeM Non utilizzato

Tutti i settori che non necessitano spazio master per essere processati sono definiti “a campionamento zero”; nello specifico sono tutti i settori di NOP, JUMP, LOOP ed END.
Un settore a campionamento zero è considerato anche il codeG = 133 se programmato come:
codeG = 133
codeQm = 0
codeQs = 0
Per come è strutturato il device, non è possibile mettere in sequenza più di 9 settori a campionamento zero.

Il settore di aggiornamento conteggio si utilizza per fare un cambio del conteggio, portandolo a valori che possano indicare la reale posizione fisica dell’asse. Il caso più tipico è l’asse circolare (da 0° a 360°): ogni volta che si raggiungono i 360° si deve sottrarre un angolo giro. Per fare un aggiornamento conteggio esistono molteplici codici di sottrazione o di impostazione conteggio, sia in bit encoder che in unità di misura. Per come è strutturato il device, non è possibile mettere in sequenza più di 4 settori di aggiornamento conteggio. Si riporta a seguito una tabella contenente la descrizione delle operazioni eseguite durante l’aggiornamento conteggio in base al codice utilizzato.

Legenda:
n.u.:Non Utilizzato
c.u.:Codice Utente

Come esempio consideriamo un semplice spandifilo:

• Partenza con rampa di accelerazione.
• Raggiungimento di una velocità proporzionale a quella del master.
• Mantenimento della velocità raggiunta per tutto il percorso.
• Fermata con rampa di decelerazione.
• Stop l’asse per un certo spazio del master.
• Ritorno al punto di partenza con le stesse modalità del tratto di andata.

Settore 1 Acceleazione, con partenza da velocità zero e spostamento slave positivo (codeG = 131). È importante calcolare il rapporto dello spazio master/slave di questo tratto in modo che la velocità di uscita sia quella che poi verrà mantenuta dall’asse slave nel tratto a velocità costante.

Settore 2 Intermedio con velocità costante e spostamento slave positivo (codeG = 133).

Settore 3 Decelerazione con velocità finale zero, con una possibile compensazione della velocità di frenata nella prima metà del tratto e spostamento slave positivo (codeG = 135). Potrebbe avere gli stessi valori impostati nel settore 1.

Settore 4 Fermata lavorazione con spostamento slave uguale a zero (codeG = 133). Si programma lo spazio master mentre quello slave viene impostato a 0.

Settore 5 Accelerazione, con partenza da velocità zero e spostamento slave negativo (codeG = 131). È importante calcolare il rapporto dello spazio master/slave di questo tratto in modo che la velocità di uscita sia quella che poi verrà mantenuta dall’asse slave nel tratto a velocità costante. Teoricamente si possono impostare gli stessi valori inseriti nel settore 1 cambiando di segno la quota slave.

Settore 6 Intermedio con velocità costante e spostamento slave negativo (codeG = 133).

Settore 7 Decelerazione con velocità finale zero, con una possibile compensazione della velocità di frenata nella prima metà del tratto e spostamento slave negativo (codeG = 135). Potrebbe avere gli stessi valori impostati nel settore 5.

Settore 8 Fermata lavorazione con spostamento slave uguale a zero (codeG = 133). Si programma lo spazio master mentre quello slave viene impostato a 0.

Dopo avere eseguito il settore 8, ci dovranno essere delle funzioni che eseguono il rifasamento dei conteggi Master e Slave sottraendo lo spazio percorso fino a fine settore; successivamente si dovrà avere la riesecuzione automatica della stessa camma dal settore 1 (JUMP o loop camma).

Come esempio consideriamo un semplice taglio al volo:

• Partenza asse slave con rampa di accelerazione.
• Raggiungimento della velocità master.
• Mantenimento della velocità raggiunta per tutto il taglio.
• Concluso il taglio l’asse slave deve accelerare per portarsi ad una extravelocità, mantenendola per un certo spazio.
• Stop asse slave con rampa di decelerazione.
• Ritorno dell’asse slave al punto di partenza (home), senza tempo di inversione ed eseguendo le rampe di accelerazione e decelerazione.

Settore 1 Accelerazione, con partenza da velocità zero e spostamento slave positivo (codeG = 132). Alla fine di questo settore lo slave avrà la stessa velocità del master.

Settore 2 Intermedio con velocità costante e spostamento slave positivo (codeG = 133). In questo settore lo spazio percorso dal master sarà uguale a quello percorso dallo slave.

Settore 3 Accelerazione e spostamento slave positivo (codeG = 133). Il codice impostato non è di accelerazione ma, per far accelerare lo slave rispetto al master, viene impostato uno spazio slave maggiore di quello master.

Settore 4 Intermedio con velocità costante e spostamento slave positivo (codeG = 133). In questo settore lo spazio percorso dallo slave sarà proporzione a quello percorso dal master.

Settore 5 Decelerazione e spostamento slave positivo (codeG = 133). In questo settore si porta lo slave alla stessa velocità del master.

Settore 6 Decelerazione con velocità finale zero, con una possibile compensazione della velocità di frenata nella prima metà del tratto e spostamento slave positivo (codeG = 135).

Settore 7 Accelerazione, con partenza da velocità zero e spostamento slave negativo (codeG = 131). In questo settore la velocità di uscita dello slave può essere diversa da quella del master.

Settore 8 Intermedio con velocità costante e spostamento slave negativo (codeG = 133).

Settore 9 Decelerazione con velocità finale zero, con una possibile compensazione della velocità di frenata nella prima metà del tratto e spostamento slave negativo (codeG = 135).

Dopo avere eseguito il settore 9, ci dovrà essere una funzione che esegua il rifasamento del conteggio del Master, sottraendo lo spazio percorso fino a fine settore e, successivamente, la riesecuzione automatica della stessa camma (JUMP o loop camma).

La presenza di un errore nel sistema camming viene segnalato dallo stato st_error.
Essendo causato da un evento grave e non essendo garantita in questa situazione la gestione dell’asse slave, si è deciso in modo arbitrario di bloccare l’asse senza rampe come fosse avvenuta un’emergenza.
Quando st_error è uguale a 1, troviamo presente sulla variabile errcode il tipo di errore intervenuto (vedi tabella) e nella variabile errvalue una indicazione sulla causa dell’errore

Se il device va in errore, per poter riprendere la lavorazione bisogna cancellare lo stato st_error attraverso il comando RSERR e fare la consueta routine di ripristino da emergenza (RESUME asse).

NOTA: L’errore 4 è dovuto al fatto che il settore viene eseguito in un tempo inferiore al tempo di campionamento del device, percui non può essere processato. Se ci si trova in questa situazione bisogna aumentare la quota del master nel settore oppure calare la velocità del master.

La presenza di un warning nel sistema camming viene segnalato dallo stato st_warning.
Essendo causato da un evento non grave ed essendo garantita in questa situazione la gestione dell’asse slave, l’asse slave continua il suo lavoro.
Quando st_warning è uguale a 1, troviamo presente sulla variabile wrncode il tipo di warning intervenuto (vedi tabella) e nella variabile wrnvalue il numero del settore della camma che ha provocato il warning.

La priorità più alta è contrassegnata da 0, la più bassa con 8.
Per cancellare lo stato st_warning bisogna inviare il comando RSWRN.
NOTA: In caso di warning 8, la funzione sará ritardata per un tempo sufficiente da consentire alla CPU di terminare dei calcoli interni. Nel caso di start camma da ingresso di interruzione, la posizione di avvio camma può non essere quella del momento dell’interrupt, ma quella dopo la fine dei calcoli. Il tempo di esecuzione dei calcoli (espressi in tempo di campionamento del device), è riportata nella tabella seguente:

	L'encoder master del device CAMMING4 non è in alcun modo legato all'encoder del device EANPOS.

Il device CAMMING4 può gestire due tipi di master:

• Entrambi possono essere provenienti da un encoder meccanicamente collegato al sistema

master ed elettricamente collegato al sistema QMOVE oppure encoder simulati. Viene inoltre accettata la soluzione mista (uno collegato elettricamente ed uno simulato.)
Lo scambio tra i due encoder viene fatto attraverso il parametro mtype senza nessun vincolo, in modo che, anche nell'esecuzione di una camma, sia possibile fare lo scambio tra i dispositivi. Nel sistema utilizzante il device CAMMING4 può essere dichiarato un encoder simulato utilizzando un device di movimento (ad esempio un EANPOS) dichiarato con il contatore sullo slot 1 (normalmente riservato alla CPU del sistema) e tutte le altre periferiche disabilitate:

;--------------------------------
; Dichiarazione device interni
;--------------------------------
 
INTDEVICE
<nome_device>  EANPOS  TCamp  ICont    IntL  IAZero  IOutA
Master         EANPOS    2    1.CNT01  X     X.X     X.X

dove:

Il device così configurato viene considerato come un master simulato e viene parametrizzato e utilizzato come fosse un device normale tenendo presente che il loop di regolazione deve essere aperto (st_loopon = 0) e di conseguenza non serve parametrizzare il P.I.D. ma è sufficiente impostare il feedforward al 100% (feedfw = 1000).

Si ipotizza di utilizzare il device EANPOS configurato come nell’esempio precedente e di voler dare il set di velocità (setvel) espresso in Hz. Si ipotizza inoltre che il master simulato debba continuare il suo movimento all’infinito.
Il flag sf01 esegue lo start e lo stop del device simulato.

;----------------------------------------------------
; Gestione del master simulato
;----------------------------------------------------
 
Master:measure = 1000
Master:pulse = 4000
Master:decpt = 0
Master:unitvel = 1
Master:maxvel = 1000
Master:taccdec = 100
Master:maxpos = 999999
Master:minpos = -999999
INIT Master
WAIT Master:st_init
LOOPOFF Master
WAIT NOT Master:st_loopon
RESUME Master
WAIT NOT Master:st_emrg
 
MAIN:
IF sf01
  IF Master: st_still
    Master:posit = 0
    Master:setvel = 500
    Master:setpos = 999999
    START Master
  ENDIF
  IF Master:posit GE 500000
    Master:posit = 0
  ENDIF
ELSE
  IF NOT Master:st_still
    STOP Master
  ENDIF
ENDIF
 
WAIT 1
JUMP MAIN
END

Per avere un corretto funzionamento durante la fase di sincronismo, si richiede che gli impulsi nel tempo (frequenza) generati dal trasduttore Master siano maggiori o uguali a quelli dell’asse Slave. In ogni caso si richiede di rispettare la condizione

Frequenza slave = 1,5 × Frequenza master

Nel caso di un non rispetto di questa condizione si hanno dei problemi nella taratura dell’asse Slave in sincronismo a causa di una rugosità nel movimento.

Il device ha la possibilità di gestire un ingresso normale ed un ingresso in interrupt per eseguire comandi o eseguire azioni. L’indirizzo degli ingressi è configurabile nel file di configurazione (InG ed InGInt). Per far eseguire una funzione specifica all’ingresso, è sufficiente assegnare alla variabile funInp (se si tratta di ingresso normale) oppure funInt (se si tratta di ingresso in interrupt) il codice riportato nella tabella seguente.

Tutte le funzioni degli ingressi possono essere gestiti sia su ingressi normali che su ingressi in interrupt.
Per avere un corretto funzionamento degli ingressi, bisogna che essi siano attivati rispettando le condizioni richieste nella descrizione del comando o dell’azione descritta.

Il device ha la possibilità di gestire un uscita per segnalare alcuni stati. L’indirizzo dell’uscita è configurabile nel file di configurazione (Out). Per far eseguire una funzione specifica all’uscita, è sufficiente assegnare alla variabile funOut il codice riportato nella tabella seguente.

Il nome del parametro, stato o comando viene riportato alla sinistra della tabella.

=R\\=

Indica se il relativo parametro o stato è ritentivo (al momento dell’inizializzazione del device mantiene lo stato precedentemente definito), oppure lo stato che assume al momento dell’inizializzazione del device.
R = Ritentivo
0 = Al momento dell’inizializzazione del device il valore viene forzato a zero.
1 = Al momento dell’inizializzazione del device il valore viene forzato a uno.

=D\\=

Indica la dimensione del parametro.
F = Flag
B = Byte
W = Word
L = Long

Vengono descritte tutte le condizioni necessarie affinché il parametro sia considerato corretto o perché il comando venga accettato.
In alcuni casi vengono specificati dei valori limite per l’accettazione del parametro: se vengono introdotti dei valori esterni ai limiti impostati, il dato viene comunque accettato; pertanto devono essere previsti opportuni controlli interni tali da garantire il corretto funzionamento. Per l’esecuzione di un comando, tutte le relative condizioni devono necessariamente essere soddisfatte; in caso contrario il comando non viene eseguito.

A

Indica la modalità di accesso.
R = Read (lettura).
W = Write (scrittura).

1. Non è possibile mettere in sequenza più di 7 settori a campionamento zero.
2. Non è possibile mettere in sequenza più di 3 settori di aggiornamento conteggio.
3. Con i parametri:
   pulse = 999999
   measure = 934
   maxvel = 999999
   unitvel = 0
   decpt = 3
   Si stabiliscono le condizioni per creare degli overflow nei calcoli dei settori 150, 151, 152 e 153.
4. Durante l’esecuzione della camma (st_camex = 1), non è possibile cambiare il settore in esecuzione e quello eseguito successivamente.
5. Il device è stato creato per funzionare con il master che si incrementa. E’ possibile eseguire la camma con il master che decrementa sottostando alle seguenti condizioni:
   La camma si ferma rimane in reazione di spazio sul settore precedente se incontra i settori 130, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 160. Può eseguire il settore precedente solamente se è già stato eseguito almeno una volta (potrebbe non essere stato eseguito a causa di un jump).