Un algoritmo di gestione del posizionamento di un motore è un elemento chiave nei moderni sistemi meccatronici.Questo blocco funzione gestisce il posizionamento di un asse (lineare o rotativo) e consente di controllare con precisione il movimento di un attuatore, tipicamente un motore, per spostare un carico da una posizione iniziale a una destinazione finale. Il blocco funzione è protetto per utilizzarlo occorre richiedere il codice di protezione, vedi protezione funzioni e blocchi funzione. E’ comunque possibile utilizzarlo liberamente in modo test per 15 Min.
Un controllo PID (Proporzionale-Integrale) confronta la posizione attuale con quella desiderata e calcola l’errore. In base a questo errore, l’algoritmo determina la correzione da inviare al motore per correggere la traiettoria. Durante il movimento, l’algoritmo aggiorna continuamente la velocità in base al feedback, garantendo che la posizione finale venga raggiunta nel tempo prestabilito.
Descrizione
Enable (BOOL) Comando abilitazione, se il driver lo permette il motore viene mantenuto in loop di posizione.
SpyOn (BOOL) Se attivo permette di spiare il funzionamento della FB (Vedi articolo).
JogFwd (BOOL) Comanda la rotazione in jog avanti del motore alla velocità definita in JSpeed.
JogBkw (BOOL) Comanda la rotazione in jog indietro del motore alla velocità definita in JSpeed.
Start (BOOL) Comanda il posizionamento del motore alla quota definita in PQuote alla velocità definita in PSpeed.
Hold (BOOL) Comanda l’arresto in hold della rotazione del motore.
DType (eMLDRIVERTYPE) Tipo di driver comando motore (Definizione).
ScTime (TIME) Definizione tempo scansione calcoli. Se valore 0 viene eseguito ad ogni esecuzione.
CDelay (TIME) Tempo ritardo comandi direzione driver. Il comando di movimentazione è attivato dopo il tempo definito dalla attivazione dei comandi di direzione.
MSpeed (UDINT) Numero di impulsi generati dal trasduttore del motore alla massima velocità (Impulsi/S).
JSRatio (REAL) Percentuale velocità motore in jog (%).
PSRatio (REAL) Percentuale velocità motore in posizionamento (%).
PQuote (LINT) Quota posizionamento motore (Impulsi).
RQuote (LINT) Quota reale motore (Impulsi).
ATime (TIME) Tempo accelerazione/decelerazione motore.
KProp (REAL) Coefficente proporzionale regolazione.
ITime (TIME) Coefficente integrativo. 0 annulla regolazione integrativa.
ELimit (UDINT) Limite errore servo (Impulsi).
PosnOn (BOOL) Attivo durante il posizionamento motore.
PosnEnd (BOOL) Fine posizionamento motore.
Forward (BOOL) Comando direzione rotazione oraria.
Backward (BOOL) Comando direzione rotazione antioraria.
Run (BOOL) Comando rotazione motore.
SRatio (REAL) Percentuale velocità rotazione motore (%).
EServo (DINT) Valore errore servo (Impulsi).
PTime (TIME) Durata posizionamento motore.
Trigger di spy
Se SpyOn attivo è possibile utilizzare la console di spionaggio per verificare il funzionamento della FB. Sono previsti vari livelli di triggers.
Livelli di trigger
| Trigger | Descrizione |
|---|---|
| 16#10000000 | Lg: Log programma |
| 16#40000000 | Er: Errori di esecuzione |
Dati trigger
Abilitando lo spionaggio al termine del posizionamento motore verrà ritornato un messaggio di log del tipo:
MotorPositioning:Lg|Positioning time:11.995, SEMax:10, Start:0, TQuote:9000 [0], PQuote:10000 [0]
- Positioning time: Ritorna il tempo di posizionamento in secondi.
- SEMax: Indica il massimo valore di errore servo durante il posizionamento.
- Start: Indica la quota di partenza del posizionamento.
- TQuote: Indica la quota di soglia a cui è iniziata la rampa di decelerazione verso la quota di posizionamento. Tra parentesi l’errore quota confronto.
- PQuote: Indica la quota di posizionamento. Tra parentesi l’errore quota confronto.
Esempi
Come utilizzare gli esempi
ST_MotorPositioning: Viene gestito il comando di un motore stepping, occorre definire gli I/O logici utilizzati per il comando del driver. Viene utilizzata una uscita PWM collegata ad un counter sul modulo CPU per gestire l’ingresso di clock del driver. Impostanddo da debug il valore di PQuote ed attivando Start si comanderà il posizionamento del motore sulla quota impostata.
LogicLab (Ptp206, ST_MotorPositioning)
PROGRAM ST_MotorPositioning
VAR
Pulses : ARRAY[0..1] OF UDINT; (* Counter pulses (Pulses) *)
CInp : SysGetCounter; (* Counter acquisition *)
PWMOut : SysSetPWMOut; (* PWM output *)
PLoop : MotorPositioning; (* Motor positioning *)
END_VAR
// *****************************************************************************
// PROGRAM "ST_MotorPositioning"
// *****************************************************************************
// Position a stepper motor connected to CPU module PWM output.
// The motor has 200 step/revolution.
// -----------------------------------------------------------------------------
// -------------------------------------------------------------------------
// INITIALIZATION
// -------------------------------------------------------------------------
// Execute program initialization.
IF (SysFirstLoop) THEN
// Set Motor positioning parameters.
PLoop.SpyOn:=TRUE; //Spy On
PLoop.DType:=eMLDRIVERTYPE#DIRBYCOMMAND; //Driver type
PLoop.ScTime:=T#0d; //Scansion time
PLoop.CDelay:=T#100ms; //Commands delay
PLoop.MSpeed:=1000; //Maximum speed (Pulses/S)
PLoop.JSRatio:=25.0; //Jog speed ratio (%)
PLoop.PSRatio:=100.0; //Position speed ratio (%)
PLoop.ATime:=T#2s; //Acceleration time
PLoop.KProp:=0.1; //Proportional coefficent (Nr)
PLoop.ITime:=T#1s; //Integrative time
PLoop.ELimit:=100; //Error limit (Pulses)
// Set PWM output parameters.
PWMOut.Address:=255; //Module address
PWMOut.Channel:=0; //Module channel
PWMOut.Duty:=50.0; //Duty cycle
// Set counter input parameters.
CInp.Address:=255; //Module address
CInp.Channel:=0; //Module channel
CInp.Mode:=16#00000000; //Acquisition mode
END_IF;
// -------------------------------------------------------------------------
// MOTOR POSITIONING
// -------------------------------------------------------------------------
// Counter management, counts the PWM output pulses sent to motor driver.
CInp(); //Counter acquisition
Pulses[1]:=CInp.Value-Pulses[0]; //Counter pulses (Pulses)
Pulses[0]:=CInp.Value; //Counter pulses (Pulses)
IF (PLoop.Forward) THEN PLoop.RQuote:=PLoop.RQuote+TO_LINT(Pulses[1]); END_IF;
IF (PLoop.Backward) THEN PLoop.RQuote:=PLoop.RQuote-TO_LINT(Pulses[1]); END_IF;
// Motor positioning FB execution.
PLoop(); //Motor positioning
// PWM output frequency.
PWMOut.Frequency:=(TO_REAL(PLoop.MSpeed)/100.0)*PLoop.SRatio; //Frequency output (Hz)
IF NOT(PLoop.Forward OR PLoop.Backward) THEN PWMOut.Frequency:=0.0; END_IF;
// PWM output duty adjusting according to the frequency.
// CPU module (Load 1KOhm): FMin=300, FMax=2000, DMin=50, DMax 76
// PCB124 board(Load 1KOhm): FMin=300, FMax=5000, DMin=45, DMax 2
PWMOut.Duty:=ValueScale(PWMOut.Frequency, 300.0, 2000.0, 50.0, 76.0);
// PWMOut.Duty:=ValueScale(PWMOut.Frequency, 300.0, 5000.0, 45.0, 2.0)
PWMOut(); //PWM output
// Motor positioning commands.
// The logical inputs must be defined according your system.
PLoop.Enable:=Di00M00; //FB enable
PLoop.JogFwd:=Di01M00; //Jog forward
PLoop.JogBkw:=Di02M00; //Jog backward
PLoop.Start:=Di03M00; //Start positioning
PLoop.Hold:=Di04M00; //Hold
// Motor driver commands, manage direction.
// The logical outputs must be defined according your system.
Do00M00:=PLoop.Forward; //Forward command
Do01M00:=PLoop.Backward; //Backward command
// [End of file]