Vai al contenuto

MotorPositioning, gestione posizionamento motore

Vai all indice del manuale di programmazione

Questo blocco funzione gestisce il posizionamento di un motore, è 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.

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.

Immagine FB MotorPositioning

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
TriggerDescrizione
16#10000000Lg: Log programma
16#40000000Er: 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
  • PQuote: Indica la quota di posizionamento.

    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#STEPPER; //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:=1; //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#00000001; //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:=(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]
    Was this article helpful?