SDK_Encoder_Setup.mc

Go to the documentation of this file.

 
#pragma once
 
#include <SysDef.mh>
#include "SDK_Encoder_Setup.mh"
 
long sdkSetupIncEncoder(long axis, long encPort, long encRes, long latchType, long latchParam, long latchSlope)
{
    VIRTCOUNTIN_PARAM(axis, VIRTCNTIN_MODE) = VIRTCNTIN_MODE_ABSOLUTE;                                              // Defines how the source value is handled
    VIRTCOUNTIN_PARAM(axis, VIRTCNTIN_PISRC_COUNTER) = HWCOUNTINC_PROCESS_SRCINDEX(encPort,PO_HWCNTINC_VALUE);      // Setup virtual counter module
 
    HWENC_PARAM(encPort, HWENCODER_MODE) = HWENCODER_MODE_INCREMENTAL;                                              // Setup encoder type
    HWAMP_PARAM(encPort, HWAMP_ENCRES) = encRes;                                                                    // Resolution of the encoder
    HWAMP_PARAM(axis, HWAMP_PISRC_ACTPOS) = HWCOUNTINC_PROCESS_SRCINDEX(encPort,PO_HWCNTINC_VALUE);                 // Source input for actual position
 
    // Virtuallatch module mapping
    VIRTLATCH_PARAM(axis,VIRTLATCH_MODE)=
    VIRTLATCH_MODE_HARDWARE;
    VIRTLATCH_PARAM(axis,VIRTLATCH_PISRC_COUNTER) =
    VIRTCOUNTIN_PROCESS_SRCINDEX(axis,PO_VIRTCNTIN_VALUE);
    VIRTLATCH_PARAM(axis,VIRTLATCH_PISRC_LATCHCNT)=
    HWCOUNTINC_PROCESS_SRCINDEX(encPort,PO_HWCNTINC_VALUE);
    VIRTLATCH_PARAM(axis,VIRTLATCH_PISRC_LATCH)=
    HWLATCH_PROCESS_SRCINDEX(encPort,PO_HWLATCH_VALUE);
    VIRTLATCH_PARAM(axis,VIRTLATCH_PISRC_LATCHSTAT)=
    HWLATCH_PROCESS_SRCINDEX(encPort,PO_HWLATCH_FLAG);
    VIRTLATCH_PARAM(axis,VIRTLATCH_PISRC_LATCHFIFO_AMOUNT)=
    HWLATCH_PROCESS_SRCINDEX(encPort,PO_HWLATCH_AMOUNT_IN_FIFO);
    VIRTLATCH_PARAM(axis,VIRTLATCH_PISRC_LATCHFIFO_READ)=
    HWLATCH_PROCESS_SRCINDEX(encPort,PO_HWLATCH_FIFOREAD);
 
    if (latchType == 0) // Default latchtype, encoder Z signal
    {
        HWLATCH_PARAM(encPort, HWLATCH_PISRC_TRIGGER) = HWLATCH_PISRC_TRIGGER_ENCZ;
    }
    else if (latchType == 1)    // Digital input for latch signal
    {
        HWLATCH_PARAM(encPort, HWLATCH_PISRC_TRIGGER) =   HWLATCH_PISRC_TRIGGER_DINP + latchParam-1;
        HWLATCH_PARAM(encPort, HWLATCH_SLOPE) = latchSlope;
    }
    else    // Error
    {
        print("Not supported latchType");
        return(-1);
    }
    return(1);
}
 
long sdkSetupSinCosEncoder(long axis, long encPort, long encRes, long latchType, long latchParam, long latchSlope)
{
    VIRTCOUNTIN_PARAM(axis, VIRTCNTIN_MODE) = VIRTCNTIN_MODE_ABSOLUTE;                                              // Defines how the source value is handled
    VIRTCOUNTIN_PARAM(axis, VIRTCNTIN_PISRC_COUNTER) = HWCOUNTINC_PROCESS_SRCINDEX(encPort,PO_HWCNTINC_VALUE);      // Setup virtual counter module
 
    HWENC_PARAM(encPort, HWENCODER_MODE) = HWENCODER_MODE_SINCOS;                                                   // Setup encoder type
    HWAMP_PARAM(encPort, HWAMP_ENCRES) = encRes;                                                                    // Resolution of the encoder
    HWAMP_PARAM(axis, HWAMP_PISRC_ACTPOS) = HWCOUNTINC_PROCESS_SRCINDEX(encPort,PO_HWCNTINC_VALUE);                 // Source input for actual position
 
    // Virtuallatch module mapping
    VIRTLATCH_PARAM(axis,VIRTLATCH_MODE)=
    VIRTLATCH_MODE_HARDWARE;
    VIRTLATCH_PARAM(axis,VIRTLATCH_PISRC_COUNTER)=
    VIRTCOUNTIN_PROCESS_SRCINDEX(encPort,PO_VIRTCNTIN_VALUE);
    VIRTLATCH_PARAM(axis,VIRTLATCH_PISRC_LATCHCNT)=
    HWCOUNTINC_PROCESS_SRCINDEX(encPort,PO_HWCNTINC_VALUE);
    VIRTLATCH_PARAM(axis,VIRTLATCH_PISRC_LATCH)=
    HWLATCH_PROCESS_SRCINDEX(encPort,PO_HWLATCH_VALUE);
    VIRTLATCH_PARAM(axis,VIRTLATCH_PISRC_LATCHSTAT)=
    HWLATCH_PROCESS_SRCINDEX(encPort,PO_HWLATCH_FLAG);
    VIRTLATCH_PARAM(axis,VIRTLATCH_PISRC_LATCHFIFO_AMOUNT)=
    HWLATCH_PROCESS_SRCINDEX(encPort,PO_HWLATCH_AMOUNT_IN_FIFO);
    VIRTLATCH_PARAM(axis,VIRTLATCH_PISRC_LATCHFIFO_READ)=
    HWLATCH_PROCESS_SRCINDEX(encPort,PO_HWLATCH_FIFOREAD);
 
    if (latchType == 0) // Default latchtype, encoder Z signal
    {
        HWLATCH_PARAM(encPort, HWLATCH_PISRC_TRIGGER) = HWLATCH_PISRC_TRIGGER_ENCZ;
    }
    else if (latchType == 1)    // Digital input for latch signal
    {
        HWLATCH_PARAM(encPort, HWLATCH_PISRC_TRIGGER) = HWLATCH_PISRC_TRIGGER_DINP + latchParam -1;
        HWLATCH_PARAM(encPort, HWLATCH_SLOPE) = latchSlope;
    }
    else    // Error
    {
        print("Not supported latchType");
        return(-1);
    }
    return(1);
}
 
 
 
long sdkSetupAbsSSIEncoder(long axis, long encPort, long encRes, long clockFreq, long fastUpdate, long datlen, long isBinary, long latchBitMask)
{
    VIRTCOUNTIN_PARAM(axis, VIRTCNTIN_MODE) =  VIRTCNTIN_MODE_ABSOLUTE_DIRECT_ENDLESS;                          // Defines how the source value is handled
    VIRTCOUNTIN_PARAM(axis, VIRTCNTIN_PISRC_COUNTER) = HWCOUNTABS_PROCESS_SRCINDEX(encPort,PO_HWCNTABS_VALUE);  // Setup virtual counter module
    VIRTCOUNTIN_PARAM(axis, VIRTCNTIN_OVFL_VALUE) = encRes;                                                     // Value where counter should produce an overflow
 
    HWENC_PARAM(encPort, HWENCODER_DATLEN) = datlen;
    HWENC_PARAM(encPort, HWENCODER_CLOCKFREQ) = clockFreq;
 
    HWAMP_PARAM(axis, HWAMP_PISRC_ACTPOS) = HWCOUNTABS_PROCESS_SRCINDEX(encPort,PO_HWCNTABS_VALUE);             // Source input for actual position
 
    HWENC_PARAM(encPort, HWENCODER_MODE) = HWENCODER_MODE_SSI_ACTIVE;                                           // Setup SSI Encoder active clock
 
    if(fastUpdate)                                                                                              // Setup fast update for commutation
    {
        HWENC_PARAM(encPort, HWENCODER_FAST_UPDATE) = 1;
        //HWENC_PARAM(encPort, HWENCODER_FAST_UPDATE) = HWENCODER_FAST_UPDATE_ENABLE;
    }
    else
    {
        HWENC_PARAM(encPort, HWENCODER_FAST_UPDATE) = 0;
        //HWENC_PARAM(encPort, HWENCODER_FAST_UPDATE) = HWENCODER_FAST_UPDATE_DISABLE;
    }
    if(isBinary)                                                                                                // Setup data coding typ
    {
        HWCOUNTABS_PARAM(encPort, HWCNTABS_CODING) = HWCNTABS_CODING_NONE;
    }
    else
    {
        HWCOUNTABS_PARAM(encPort, HWCNTABS_CODING) = HWCNTABS_CODING_GREY;
        //HWCOUNTABS_PARAM(encPort, HWCNTABS_CODING) = HWCNTABS_CODING_GRAY;
    }
 
    // Virtuallatch module mapping
    VIRTLATCH_PARAM(axis,VIRTLATCH_MODE)=VIRTLATCH_MODE_SOFTWARE;
    // Set the source for the lathc module
    VIRTLATCH_PARAM(axis,VIRTLATCH_PISRC_COUNTER)=
    HWCOUNTABS_PROCESS_SRCINDEX(encPort,PO_HWCNTABS_VALUE);
    VIRTLATCH_PARAM(axis, VIRTLATCH_PISRC_LATCHVALID) =
    // Set the source for input trigger, could be an other source like user param
    VIRTDIGIN_PROCESS_SRCINDEX(axis,PO_VIRTDIGIN_VALLONG);
    // Bitmask for the latchvalid source
    VIRTLATCH_PARAM(axis, VIRTLATCH_LATCHVALID_BITMASK) = latchBitMask;
 
    return(1);
}
long sdkSetupHallEncoderMACS5(long axis, long hallPort,long hallAligment)
{
    long hall_ModNo;
 
    // Determine Hall Number, note that the Hall-Module number has a fix assignment to the axis number
    if     (axis == 0){ hall_ModNo = 0; }
    else if (axis == 2){ hall_ModNo = 1; }
    else if (axis == 3){ hall_ModNo = 2; }
    else if (axis == 5){ hall_ModNo = 3; }
    else { // (AxisNo == 1 || AxisNo == 4)
      print("Axis No ", axis, " cannot be used as BLDC axis");
      return(-1);
    }
 
    HWAMP_PARAM((axis), HWAMP_HALL_ALIGNMENT) =  hallAligment;      // set hall alignment
 
    // Parameterization Hall Sensors
    HWENC_PARAM((hallPort), HWENCODER_MODE) = HWENCODER_MODE_HALL;  // Set encder mode
    HWHALL_PARAM((hallPort), HWHALL_MODE) = HWHALL_MODE_ENABLE;     // enable hall decoder
    HWHALL_PARAM((hall_ModNo), HWHALL_PISRC_ENCOUT) = (hallPort);   // use input number
 
    return(1);
}
 
 
long sdkSetupHallEncoder(long axis, long hallAligment, long hallDirection)
{
    VIRTCOUNTIN_PARAM(axis, VIRTCNTIN_MODE) = VIRTCNTIN_MODE_ABSOLUTE;                                              // Defines how the source value is handled
    VIRTCOUNTIN_PARAM(axis, VIRTCNTIN_PISRC_COUNTER) = HWHALL_PROCESS_SRCINDEX(axis,PO_HWHALL_POS);
 
    HWAMP_PARAM(axis, HWAMP_HALL_ALIGNMENT) =  hallAligment;    // set hall alignment
    HWHALL_PARAM(axis, HWHALL_MODE) = HWHALL_MODE_ENABLE;       // enable hall encoder
 
    if(hallDirection==-1)
        VIRTCOUNTIN_PARAM(axis, VIRTCNTIN_UUFACT_INCNO) = -1;
 
    return(1);
}