MotorPositioning, gestione posizionamento motore

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

Immagine FB MotorPositioning

Parametro	Tipo	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]

Descrizione​

Trigger di spy​

Esempi​

Descrizione

Trigger di spy

Esempi