T168_111\device\Motor 文件：4个文件

DCMotorDrv.c  。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

/******************************************************************************
 *                                                                            *
 *                         M O D U L E   D E F I N E                          *
 *                                                                            *
 ******************************************************************************/

#define DCMOTORDRV_C

/******************************************************************************
 *                                                                            *
 *        C O M P I L E R   D E F I N E D   I N C L U D E   F I L E S         *
 *                                                                            *
 ******************************************************************************/

/* None */

/******************************************************************************
 *                                                                            *
 *            U S E R   D E F I N E D   I N C L U D E   F I L E S             *
 *                                                                            *
 ******************************************************************************/

#include "Common.h"
#include "XCore.h"
#include "XRibbon.h"
#include "Motor.h"
#include "XVarBank.h"

/******************************************************************************
 *                                                                            *
 *                         L O C A L   D E F I N E S                          *
 *                                                                            *
 ******************************************************************************/

#if defined(TTP245P_PCB)
#define DC_MOTOR_FORWARD            AT91F_PIO_ClearOutput(AT91C_BASE_PIOB, AT91C_PIO_PB1)
#define DC_MOTOR_BACKWARD            AT91F_PIO_SetOutput(AT91C_BASE_PIOB, AT91C_PIO_PB1)

#elif defined(T045_PCB) ||defined(T40_PCB)
                                    //DC motor phase
#define DC_MOTOR_FORWARD            gpio_setportval(GPIO_PORTA, BIT0, 0);//AT91F_PIO_ClearOutput(AT91C_BASE_PIOB, AT91C_PIO_PB22)
#define DC_MOTOR_BACKWARD            gpio_setportval(GPIO_PORTA, BIT0, BIT0);//AT91F_PIO_SetOutput(AT91C_BASE_PIOB, AT91C_PIO_PB22)
#endif

#define DCM_PWM_FREQ                    714

/******************************************************************************
 *
 * Function:
 *    
 *
 * Description: 
 *        
 *
 * Input:
 *      None
 *
 * Output:
 *      None.
 *
 ******************************************************************************/
VOID InitialDCMotor(VOID)
{    
    
    PWM_TIME_DATA_T sPt;    
    
    PWM_SetTimerIO(PWM_TIMER0,TRUE);                    
        
    /* Install Callback function */ 
    PWM_InstallCallBack(PWM_TIMER0, NULL, NULL);

    /* Enable Interrupt Sources of PWM Timer 0    */
    PWM_DisableInt(PWM_TIMER0,0);

    /* PWM Timer property */ 
    sPt.u8Mode = PWM_TOGGLE_MODE;
    sPt.fFrequency = DCM_PWM_FREQ;
    sPt.u8HighPulseRatio = 30;        /* High Pulse peroid : Total Pulse peroid = 1 : 100 */ 
    sPt.bInverter = FALSE;                

    /* Set PWM Timer 0 Configuration */
    PWM_SetTimerClk(PWM_TIMER0,&sPt);                            

        
    PWM_Enable(PWM_TIMER0,FALSE);

}

VOID DCMotorRewindCtrl(BOOL Enable, _eMotorDir Direction, UINT Percent)
{
    PWM_TIME_DATA_T sPt;

    if ( Direction == MOTOR_FORWARD ){
        DC_MOTOR_FORWARD;
    }
    else{
        DC_MOTOR_BACKWARD;    
    }
    //PWM_DisableInt(PWM_TIMER0,0);
    /* PWM Timer property */ 

    if ( Enable && Percent )
    {        
        
#if 0    
        PWM_SetTimerIO(PWM_TIMER0,TRUE);
        outp32(CNR0, 33612);            
        outp32(CMR0, 336*Percent);    
        PWM_Enable(PWM_TIMER0,TRUE);
        
#else
        PWM_SetTimerIO(PWM_TIMER0,TRUE);
        /* Enable Interrupt Sources of PWM Timer 0    */

        //PWM_InstallCallBack(PWM_TIMER0, NULL,NULL);
        
        PWM_DisableInt(PWM_TIMER0,0);

        /* PWM Timer property */ 
        sPt.u8Mode = PWM_TOGGLE_MODE;
        sPt.fFrequency = DCM_PWM_FREQ;
        sPt.u8HighPulseRatio = Percent;        /* High Pulse peroid : Total Pulse peroid = 1 : 100 */ 
        sPt.bInverter = FALSE;                

        /* Set PWM Timer 0 Configuration */
        PWM_SetTimerClk(PWM_TIMER0,&sPt);        
        PWM_Enable(PWM_TIMER0,TRUE);
#endif
        

        
    }
    else
    {
        PWM_SetTimerIO(PWM_TIMER0,FALSE);
        outp32(CNR0, 33612);            
        outp32(CMR0, 0);    
    }

#if defined(RIBBON_MODEL)
    ClearRibbonEncode();
#endif

}

Motor.h  。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

#ifndef MOTOR_H

/******************************************************************************
 *                                                                            *
 *                         M O D U L E   D E F I N E                          *
 *                                                                            *
 ******************************************************************************/

#define MOTOR_H
    
/******************************************************************************
 *                                                                            *
 *        C O M P I L E R   D E F I N E D   I N C L U D E   F I L E S         *
 *                                                                            *
 ******************************************************************************/

/* None */

/******************************************************************************
 *                                                                            *
 *            U S E R   D E F I N E D   I N C L U D E   F I L E S             *
 *                                                                            *
 ******************************************************************************/

#ifdef __cplusplus
extern "C" {            /* Assume C declarations for C++ */
#endif    /* __cplusplus */
    
/******************************************************************************
 *                                                                            *
 *                        G L O B A L   D E F I N E S                         *
 *                                                                            *
 ******************************************************************************/

#if defined(TTP2410M_MACH)    // Fixed 300 DPI
#define SPEED(s)                    (INT)(s - 2)

#elif defined(TTP286M_MACH)    // Fixed 300 DPI
#define SPEED(s)                    (INT)(s - 1)

#elif defined(TPH_DPI_200)
#define SPEED(s)                    (INT)(s * 2 - 3)

#elif defined(TPH_DPI_300)
#define SPEED(s)                    (INT)(s * 2 - 2)
//#define SPEED(s)                    (INT)(s - 1)

#endif

#if defined(TTP2410M) || defined(TTP246MP) || defined(TTP286M)
#define MOTOR_STEP_RATE                (FLOAT)1.5
#define MOTOR_STEP_SCALE            3

#elif defined(TTP644M)
#define MOTOR_STEP_RATE                (FLOAT)0.5
#define MOTOR_STEP_SCALE            1

//#elif defined(XP_H500E_MACH) || defined(DELUXE_3044_MACH)
//#define MOTOR_STEP_RATE                (FLOAT)1
//#define MOTOR_STEP_SCALE            3

#else

#if ORIGIN_STEP_MOTOR_DRIVE
#define MOTOR_STEP_RATE                (FLOAT)1
#define MOTOR_STEP_SCALE            1
#endif

#if NEW_STEP_MOTOR_DRIVE
#if FULL_STEP_FULL_CURRENT
#define MOTOR_STEP_RATE                1//(FLOAT)2//(FLOAT)1 // ch_20220120 : changed to 2 from 1.
#define MOTOR_STEP_SCALE            1//2//1 // ch_20220121 : changed to 2 from 1.
#elif HALF_STEP_FULL_CURRENT
#define MOTOR_STEP_RATE                (FLOAT)2//(FLOAT)1 // ch_20220120 : changed to 2 from 1.
#define MOTOR_STEP_SCALE            2//1 // ch_20220121 : changed to 2 from 1.
#elif HALF_STEP_PART_CURRENT
#define MOTOR_STEP_RATE                (FLOAT)2//(FLOAT)1 // ch_20220120 : changed to 2 from 1.
#define MOTOR_STEP_SCALE            2//1 // ch_20220121 : changed to 2 from 1.
#endif
#endif

#endif

/******************************************************************************
 *                                                                            *
 *                 S T R U C T U R E   D E F I N I T I O N S                  *
 *                                                                            *
 ******************************************************************************/

enum
{
    DCM_PRE_STOP,
    DCM_STOP,
    DCM_PRE_FORWARD,
    DCM_FORWARD,
    DCM_POST_FORWARD,
    DCM_PRE_BACKWARD,
    DCM_BACKWARD,
    DCM_POST_BACKWARD,
};

typedef enum
{
    CURRENT_OFF,
    CURRENT_20,
    CURRENT_60,
    CURRENT_100,
}_eMotorCurrent;

typedef enum
{
    STATUS_MOTOR_FORWARD,
    STATUS_MOTOR_BACKWARD,
    STATUS_MOTOR_WILL_STOP,
    STATUS_MOTOR_STOP,
    STATUS_MOTOR_IDLE,
}_eMotorStatus;

typedef enum
{
    MOTOR_FORWARD,            // motor forward
    MOTOR_BACKWARD,            // motor backward
    MOTOR_NULL,
}_eMotorDir;

/******************************************************************************
 *                                                                            *
 *    G L O B A L   V A R I A B L E S   -   N O   I N I T I A L I Z E R S     *
 *                                                                            *
 ******************************************************************************/

/* None */

/******************************************************************************
 *                                                                            *
 *       G L O B A L   V A R I A B L E S   -   I N I T I A L I Z E R S        *
 *                                                                            *
 ******************************************************************************/

/* None */

/******************************************************************************
 *                                                                            *
 *                   F U N C T I O N   P R O T O T Y P E S                    *
 *                                                                            *
 ******************************************************************************/

//--- DCMotorDrv ---//
VOID InitialDCMotor(VOID);
VOID DCMotorRewindCtrl(BOOL, _eMotorDir, UINT);
VOID DCMotorSupplyCtrl(BOOL, _eMotorDir, UINT);
VOID Trigger74123(VOID);

//--- StepMotorDrv ---//
VOID InitialMotorCurrent(VOID);
WORD CalculateMotorTemp(WORD);
VOID SetStepMotorCurrent(_eMotorCurrent);
VOID MotorPhaseChange(_eMotorDir);
VOID Trigger74123(VOID);

//--- MotorLib ---//
VOID InitialMotor(_eMotorDir *);
VOID CalculateAccelStepTable(INT);
WORD GetSpeedTime(VOID);
INT NowSpeed(VOID);
INT ToMotorSpeed(FLOAT);
VOID ResponseMotorTemp(VOID);
WORD GetMotorTemp(VOID);
FLOAT ToSpeedValue(INT);
CHAR *ToSpeedString(INT);
_eMotorStatus GetMotorStatus(VOID);
_eMotorStatus GetPreMotorStatus(VOID);
_eMotorDir GetPreMotorDir(VOID);
INT GetMotorStepCounter(VOID);
BOOL IsMotorEnable(VOID);
INT CorrectShrinkage(INT, BOOL);
INT CorrectSlack(_eMotorDir, INT);
VOID EnableMotor(_eMotorDir, INT, INT, BOOL, BOOL);
VOID ModifyMotorStep(INT);
VOID ClrContinuousJob(VOID);
VOID SetDeceleration(INT, INT, BOOL, BOOL);
VOID SetJobRemainStep(INT, BOOL);
VOID StopMotor(VOID);
WORD CheckMotorCurrentDown(WORD Time);
VOID MotorCurrentDown(VOID);
VOID RibbonControl(BOOL, INT, BOOL);
BOOL MotorProcess(VOID);

#ifdef __cplusplus
}                       /* End of extern "C" { */
#endif    /* __cplusplus */

#endif    

MotorLib.c  。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

/******************************************************************************
 *                                                                            *
 *                         M O D U L E   D E F I N E                          *
 *                                                                            *
 ******************************************************************************/

#define MOTORLIB_C

/******************************************************************************
 *                                                                            *
 *        C O M P I L E R   D E F I N E D   I N C L U D E   F I L E S         *
 *                                                                            *
 ******************************************************************************/

#include <math.h>

/******************************************************************************
 *                                                                            *
 *            U S E R   D E F I N E D   I N C L U D E   F I L E S             *
 *                                                                            *
 ******************************************************************************/

#include "Common.h"
#include "XCore.h"
#include "XTimer.h"
#include "XADC.h"
#include "XComm.h"
#include "XProFile.h"
#include "XPrtEng.h"
#include "Motor.h"
#include "XVarBank.h"

/******************************************************************************
 *                                                                            *
 *                         L O C A L   D E F I N E S                          *
 *                                                                            *
 ******************************************************************************/

#if defined(TDP225_PCB)
#define STOP_DELAY                    36
#define FORWARD_DELAY                12
#define BACKWARD_DELAY                12
#define BACKWARD_RIBBON_ENBLE           1

//#elif  defined(XPH500B) || defined(XP470B) || defined(XPH400B) || defined(XP450B) ||defined(DELUXE_2045)
//#define STOP_DELAY                    48
//#define FORWARD_DELAY                36
//#define BACKWARD_DELAY                12
//#define BACKWARD_RIBBON_ENBLE           0

#elif  defined(XPH500E) ||defined(DELUXE_3044)
#define STOP_DELAY                    48
#define FORWARD_DELAY                36
#define BACKWARD_DELAY                12
#define BACKWARD_RIBBON_ENBLE           0

#elif  defined(XPH500B)
#define STOP_DELAY                    48
#define FORWARD_DELAY                36
#define BACKWARD_DELAY                12
#define BACKWARD_RIBBON_ENBLE       1
#else
#define STOP_DELAY                    48
#define FORWARD_DELAY                36
#define BACKWARD_DELAY                12
#define BACKWARD_RIBBON_ENBLE       1

#endif

#if  defined(TTP245P) || defined(TDP245P) 
#define BACKWARD_SPEED_MAX            SPEED(4)

#elif  defined(TTP345) || defined(TDP345)
#define BACKWARD_SPEED_MAX            SPEED(3)

#elif defined(HIPPO_TPU_333)
#define BACKWARD_SPEED_MAX            SPEED(4)

#elif  defined(XPH500B) ||defined(XPH500E) || defined(XPH400B)  \
           ||defined(DELUXE_2045) ||defined(DELUXE_3044)
           
#define BACKWARD_SPEED_MAX            SPEED(2)

#elif defined(XP470B) ||defined(DELUXE_2044) ||defined(XP450B) \
||defined(XPDT425B)|| defined(XPDT108BLABEL)||defined(XPDT427B)\
||defined(XP460B)||defined(XP490B)
#define BACKWARD_SPEED_MAX            SPEED(3)

#else
#define BACKWARD_SPEED_MAX            SPEED(2)

#endif

#if defined(TPH_DPI_200)

#if defined(XPDT108BLABEL)
#define    HUNDRED_SPEED_MIN            100        // 1.5" * 100
#else
#define    HUNDRED_SPEED_MIN            150        // 1.5" * 100
#endif

#define    HUNDRED_SPEED_MAX            800        //   8" * 100

#elif defined(TPH_DPI_300)
#define    HUNDRED_SPEED_MIN            100        //   1" * 100
#define    HUNDRED_SPEED_MAX            600        //   6" * 100

#endif

#define    SPEED_MIN                    ((FLOAT)HUNDRED_SPEED_MIN / 100)
#define    SPEED_MAX                    ((FLOAT)HUNDRED_SPEED_MAX / 100)

#if defined(TTP2410M_MACH)    // Fixed 300 DPI
#define MOTOR_CUR_DOWN_TIME            (PERIPHERAL_CLOCK / MOTION_DIV / 1000)    // if one step > 1 ms 
#define    DEF_ACCEL_NUM                160        // 4"(15), 6"(38), 8"(70), 10"(111), 12"(160)

#elif defined(TTP286M_MACH)    // Fixed 300 DPI
#define MOTOR_CUR_DOWN_TIME            (PERIPHERAL_CLOCK / MOTION_DIV / 1000)    // if one step > 1 ms 
#define    DEF_ACCEL_NUM                70        // 2"(3), 3"(9), 4"(17), 5"(27), 6"(39), 7"(54), 8"(70)

#else
//#elif  defined(XP_H500B_MACH)  || defined(XP_470B_MACH) || defined(XP_H500E_MACH) ||defined(DELUXE_3044_MACH) || defined(DELUXE_2044)  // Fixed 300 DPI
#define MOTOR_CUR_DOWN_TIME            (PERIPHERAL_CLOCK / MOTION_DIV / 500)    // if one step > 1 ms 
#define    DEF_ACCEL_NUM                70        // 2"(3), 3"(9), 4"(17), 5"(27), 6"(39), 7"(54), 8"(70)

//#else
//#define MOTOR_CUR_DOWN_TIME            (PERIPHERAL_CLOCK / MOTION_DIV / 500)    // if one step > 2 ms 6250
//#define    DEF_ACCEL_NUM                (((HUNDRED_SPEED_MAX - HUNDRED_SPEED_MIN) / 25) + 1)    // 25% 27

#endif

#define    MAX_ACCEL_NUM                384

#define SPEED_NUM                    (sizeof(SpeedTable) / sizeof(FLOAT))  //14

/******************************************************************************
 *                                                                            *
 *                        L O C A L   T Y P E D E F S                         *
 *                                                                            *
 ******************************************************************************/

/* None */

/******************************************************************************
 *                                                                            *
 *             L O C A L   F U N C T I O N   P R O T O T Y P E S              *
 *                                                                            *
 ******************************************************************************/

/* None */

/******************************************************************************
 *                                                                            *
 *    L O C A L   I N I T I A L I Z E D   D A T A   D E F I N I T I O N S     *
 *                                                                            *
 ******************************************************************************/

#if defined(TPH_DPI_200)

CONST STATIC FLOAT SpeedTable[] = { 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7, 7.5, 8.0};
CONST STATIC CHAR *SpeedString[] = { "1.5","2","2.5","3","3.5","4","4.5","5","5.5","6","6.6","7","7.5","8" };

#elif defined(TPH_DPI_300)
CONST STATIC FLOAT SpeedTable[] = { 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6 };
CONST STATIC CHAR *SpeedString[] = { "1","1.5","2","2.5","3","3.5","4","4.5","5","5.5","6" };

#endif

#if defined(TPH_DPI_200)
//CONST STATIC UINT DCForwardCurrent[][3] =
//{
    {PRE,ING,POST},
//    { 20, 85/*70*/, 20 },    // 1.5" // ch_20220722 : changed to 85 from 70 to solve the ribbon winkle.
//    { 20, 85/*70*/, 20 },    // 2"
//    { 20, 85/*70*/, 20 },    // 2.5"
//    { 20, 85/*70*/, 20 },    // 3"
//    { 20, 85/*70*/, 20 },    // 3.5"
//    { 20, 85/*70*/, 20 },    // 4"
//    { 20, 85/*70*/, 20 },    // 4.5"
//    { 20, 85/*70*/, 20 },    // 5"
//    { 20, 85/*70*/, 20 },    // 5.5"
//    { 20, 85/*70*/, 20 },    // 6"

//};

//CONST STATIC UINT DCForwardCurrent[][3] =
//{
    {PRE,ING,POST},
//    { 20, 100, 20 },    // 1.5" // ch_20220722 : changed to 100 from 70 to solve the ribbon winkle.
//    { 20, 100, 20 },    // 2"
//    { 20, 100, 20 },    // 2.5"
//    { 20, 100, 20 },    // 3"
//    { 20, 100, 20 },    // 3.5"
//    { 20, 100, 20 },    // 4"
//    { 20, 100, 20 },    // 4.5"
//    { 20, 100, 20 },    // 5"
//    { 20, 100, 20 },    // 5.5"
//    { 20, 100, 20 },    // 6"

//};

CONST STATIC UINT DCForwardCurrent[][3] =
{
//    {PRE,ING,POST},
    { 20, 65, 20 },    // 1.5" // ch_20220722 : changed to 65 from 100 to solve the ribbon winkle.
    { 20, 65, 20 },    // 2"
    { 20, 65, 20 },    // 2.5"
    { 20, 65, 20 },    // 3"
    { 20, 65, 20 },    // 3.5"
    { 20, 65, 20 },    // 4"
    { 20, 65, 20 },    // 4.5"
    { 20, 65, 20 },    // 5"
    { 20, 65, 20 },    // 5.5"
    { 20, 65, 20 },    // 6"

};

CONST STATIC UINT DCBackwardCurrent[][3] =
{
    { 15, 10, 20 },    // 1.5"
    { 20, 10, 20 },    // 2"
    { 20, 10, 20 },    // 2.5"
    { 20, 10, 20 },    // 3"
    { 20, 10, 20 },    // 3.5"
    { 20, 10, 20 },    // 4"
    { 20, 10, 20 },    // 4.5"
    { 20, 10, 20 },    // 5"
    { 20, 10, 20 },    // 5.5"
    { 20, 10, 20 },    // 6"
};

#elif defined(TPH_DPI_300)
CONST STATIC UINT DCForwardCurrent[][3] =
{
//    {PRE,ING,POST},
    { 20, 70, 20 },    // 1"
    { 20, 70, 20 },    // 1.5"
    { 20, 70, 20 },    // 2"
    { 20, 70, 20 },    // 2.5"
    { 20, 70, 20 },    // 3"
    { 20, 70, 20 },    // 3.5"
    { 20, 70, 20 },    // 4"
};

CONST STATIC UINT DCBackwardCurrent[][3] =
{
    { 15, 10, 20 },    // 1"
    { 15, 10, 20 },    // 1.5"
    { 20, 10, 20 },    // 2"
    { 20, 10, 20 },    // 2.5"
    { 20, 10, 20 },    // 3"
    { 20, 10, 20 },    // 3.5"
    { 20, 10, 20 },    // 4"
};

#endif

/******************************************************************************
 *                                                                            *
 *    L O C A L   U N I T I A L I Z E D   D A T A   D E F I N I T I O N S     *
 *                                                                            *
 ******************************************************************************/

STATIC WORD AccelStepTable[MAX_ACCEL_NUM];
STATIC WORD SpeedToStepTable[SPEED_NUM];

STATIC WORD MotorTemp;                    // motor temperature record

STATIC _eMotorStatus MotorStatus;        // step motor status
STATIC _eMotorStatus PreMotorStatus;    // previous step motor status
STATIC _eMotorDir *pPreMotorDir;        // int Previous motor direction
STATIC BOOL RibbonInside;                // ribbon inside flag
STATIC BOOL DCMotorEnable;                // dc motor enable flag
STATIC BOOL MotorEnable;                // step motor enable flag
STATIC INT MotorCounter;                // step motor move counter
STATIC INT StepDelay;                    // step motor delay counter
STATIC INT MotorSpeed;                    // motor Speed
STATIC INT StepNum;                        // motor isr time
STATIC INT BackSpeed;
STATIC INT ForwardSlack;
STATIC INT BackwardSlack;
    
#if defined(TTP2410M_MACH) || defined(TTP286M_MACH)
STATIC BOOL ContinuousJob;
STATIC INT JobRemainStep;
STATIC INT CurrRemainStep;
STATIC INT CurrOffsetStep;
#endif

/******************************************************************************
 *
 * Function:
 *    
 *
 * Description: 
 *        
 *
 * Input:
 *      None
 *
 * Output:
 *      None.
 *
 ******************************************************************************/
VOID InitialMotor(_eMotorDir *pMotorDir)
{
    INT AccelNumber;
    FLOAT data;

    MotorTemp = 0;

    MotorStatus    = STATUS_MOTOR_IDLE;
    PreMotorStatus = STATUS_MOTOR_IDLE;
    pPreMotorDir   = pMotorDir;
    RibbonInside   = FALSE;
    DCMotorEnable  = FALSE;
    MotorEnable    = FALSE;
    MotorCounter   = 0;

    StepDelay  = 0;
    MotorSpeed = 0;
    StepNum    = 0;

#if defined(TTP2410M_MACH) || defined(TTP286M_MACH)
    ContinuousJob  = TRUE;
    JobRemainStep  = 0;
    CurrRemainStep = 0;
    CurrOffsetStep = 0;
#endif

    InitialMotorCurrent();

    AccelNumber = DEF_ACCEL_NUM;
    if (GetProfileInt("NUMBER OF ACCELERATION", &data))
        AccelNumber = (INT)data;
    if (AccelNumber > MAX_ACCEL_NUM)
        AccelNumber = MAX_ACCEL_NUM;

    CalculateAccelStepTable(AccelNumber);

    // Initial DC motor
    InitialDCMotor();
    RibbonControl(FALSE, DCM_STOP, RibbonInside);

    BackSpeed = BACKWARD_SPEED_MAX;
    if (GetProfileInt("BACKSPEED", &data))
        BackSpeed =  (INT)ToMotorSpeed(data);

    ForwardSlack = FORWARD_SLACK;
    if (GetProfileInt("FORWARDSLACK", &data))
        ForwardSlack =  (INT)data;

    BackwardSlack = BACKWARD_SLACK;
    if (GetProfileInt("BACKWARDSLACK", &data))
        BackwardSlack =  (INT)data;
}
//
//#define NEW_SPEED_LIST
VOID CalculateAccelStepTable(INT AccelNumber)
{
    FLOAT Accel, Inch;
    INT i, j = 0;
#if defined(NEW_SPEED_LIST)
       FLOAT  NowStepSpeed = SPEED_MIN;
       Accel=(SPEED_MAX - SPEED_MIN)*(SPEED_MAX + SPEED_MIN) /2* TPH_DPI/(AccelNumber - 1 );
#else
    Accel = (SPEED_MAX - SPEED_MIN) / (AccelNumber - 1);
#endif
    Inch = SPEED_MIN;
    for (i = 0; i < AccelNumber; i++)
    {
        //debug_printf("\r\n Inch(%d):%f", i, Inch);
        if (SpeedTable[j] <= Inch)
        {
            if (j < SPEED_NUM)
                SpeedToStepTable[j++] = i;
        }
#if defined(NEW_SPEED_LIST)
                AccelStepTable[i] = (WORD)((FLOAT)CLOCK_TIME / (TPH_DPI * NowStepSpeed));
                NowStepSpeed=sqrt(NowStepSpeed*NowStepSpeed+Accel/TPH_DPI*2);
                Inch = NowStepSpeed;
#else
        AccelStepTable[i] = (WORD)((FLOAT)CLOCK_TIME / (TPH_DPI * Inch));
        Inch += Accel;
#endif
                //debug_printf(",%d",AccelStepTable[i]);
    }
    while (j < SPEED_NUM)
        SpeedToStepTable[j++] = AccelNumber - 1;
    //for (i = 0; i < SPEED_NUM; i++)
    //    debug_printf("\r\n Table[%d]:%d", i, SpeedToStepTable[i]);
}

WORD GetSpeedTime(VOID)
{
    return (AccelStepTable[StepNum] / MOTOR_STEP_SCALE);
}

INT NowSpeed(VOID)
{
    INT i;

    for (i = 0; i < SPEED_NUM; i++)
    {
        if (SpeedToStepTable[i] >= StepNum)
            return i;
    }
    return (SPEED_NUM - 1);
}

FLOAT ToSpeedValue(INT Speed)
{
    return SpeedTable[Speed];
}

INT ToMotorSpeed(FLOAT Speed)
{
    INT i;

    for (i = 0; i < SPEED_NUM; i++)
    {
        if (Speed <= SpeedTable[i])
            return i;
    }
    return (SPEED_NUM - 1);
}

CHAR *ToSpeedString(INT Speed)
{
    return (CHAR *)SpeedString[Speed];
}

VOID ResponseMotorTemp(VOID)
{
    if (MotorTemp)
    {
        SendPrintf("%03d\r\n", MotorTemp);
        MotorTemp = 0;
    }
}

WORD GetMotorTemp(VOID)
{
    WORD Value = 0;

#if defined(TTP245C_MACH)
    StartADConvert(MOTOR_TEMP_AD);
    Value = CalculateMotorTemp(ReadAD(MOTOR_TEMP_AD));
    MotorTemp = Value;
#endif
    return Value;
}

#if defined(__HITACHI__)
#pragma inline(GetMotorStatus)
#endif

_eMotorStatus GetMotorStatus(VOID)
{
    if (MotorCounter == 1)
        return STATUS_MOTOR_WILL_STOP;
    return MotorStatus;
}

_eMotorStatus GetPreMotorStatus(VOID)
{
    return PreMotorStatus;
}

_eMotorDir GetPreMotorDir(VOID)
{
    return *pPreMotorDir;
}

INT GetMotorStepCounter(VOID)
{
    return MotorCounter;
}

BOOL IsMotorEnable(VOID)
{
    return MotorEnable;
}

INT CorrectShrinkage(INT Cnt, BOOL Ribbon)
{
    if (Ribbon)
        Cnt = Cnt * TT_ADD_PERCENT / 1000;
    else
        Cnt = Cnt * DT_ADD_PERCENT / 1000;

    return Cnt;
}

INT CorrectSlack(_eMotorDir Mode, INT Cnt)
{
    if (Mode == MOTOR_FORWARD && *pPreMotorDir == MOTOR_BACKWARD)
        Cnt += ForwardSlack;
    if (Mode == MOTOR_BACKWARD && *pPreMotorDir == MOTOR_FORWARD)
        Cnt += BackwardSlack;

    return Cnt;
}
//
/*  通过函数的参数Direction去选择电机是正转还是反转，并把MotorStatus置为正转或反转 ,并且给电机计数器赋值    */
VOID EnableMotor(_eMotorDir Direction, INT Step, INT Speed, BOOL DCMotor, BOOL Inside)
{
    Step = CorrectSlack(Direction, Step);
//sysprintf("EN_M...");                           //pc下发打印开始和中间进来执行1次///
    if (Step <= 0)
        return;

//debug_printf("\rS%d,%d", Direction, Step);
//sysprintf("EN_M : %d,%d", Direction, Step);

    switch (Direction)
    {
        case MOTOR_FORWARD:
        {
            MotorEnable   = TRUE;
            MotorCounter  = (INT)((FLOAT)Step * MOTOR_STEP_RATE);
//sysprintf("\nFWS%d\n", MotorCounter); // ch_20220217            
            MotorStatus   = STATUS_MOTOR_FORWARD;
            *pPreMotorDir = MOTOR_FORWARD;
            MotorSpeed    = Speed;
            DCMotorEnable = DCMotor;
            RibbonInside  = Inside;
            break;
        }
        case MOTOR_BACKWARD:
        {
            MotorEnable   = TRUE;
            MotorCounter  = (INT)((FLOAT)Step * MOTOR_STEP_RATE);
//sysprintf("\nBWS%d\n", MotorCounter); // ch_20220217            
            MotorStatus   = STATUS_MOTOR_BACKWARD;
            *pPreMotorDir = MOTOR_BACKWARD;
            MotorSpeed    = Speed;
            DCMotorEnable = DCMotor;
            RibbonInside  = Inside;
            if (MotorSpeed > BackSpeed)
                MotorSpeed = BackSpeed;
            else
                MotorSpeed = Speed;
            break;
        }
    }
}
//
VOID ModifyMotorStep(INT Step)
{
//debug_printf("\rMdf%d", Step);
    if (MotorStatus != STATUS_MOTOR_STOP && MotorStatus != STATUS_MOTOR_IDLE)
    {
        MotorCounter = (INT)(Step * MOTOR_STEP_RATE);
        if (MotorCounter < 1)
            MotorCounter = 1;
    }
#if defined(TTP2410M_MACH) || defined(TTP286M_MACH)
    CurrRemainStep = MotorCounter;
#endif
}

// ch_20220218 
INT GetMotorCounter(VOID)
{
    return MotorCounter;
}

#if defined(TTP2410M_MACH) || defined(TTP286M_MACH)

VOID ClrContinuousJob(VOID)
{
    ContinuousJob = FALSE;
}

VOID SetJobRemainStep(INT Step, BOOL Ribbon)
{
    if (Step > 10000) Step = 10000;        // avoid over the "int" type
    Step = CorrectShrinkage(Step, Ribbon);
    JobRemainStep = Step * MOTOR_STEP_RATE;
}

VOID SetDeceleration(INT Remain, INT Offset, BOOL Ribbon, BOOL Continuously)
{
    Remain = CorrectShrinkage(Remain, Ribbon);
    Offset = CorrectShrinkage(Offset, Ribbon);
    ContinuousJob = Continuously;
    CurrRemainStep = Remain * MOTOR_STEP_RATE;
    CurrOffsetStep = Offset * MOTOR_STEP_RATE;
}

STATIC BOOL CheckDeceleration(INT StepNumber)
{
    INT RemainStep;

    if (CurrRemainStep)
        CurrRemainStep -= 1;

    RemainStep = CurrRemainStep;
    if (ContinuousJob)
    {
        RemainStep += JobRemainStep;
        RemainStep += GetRestJobStep(CurrOffsetStep);
    }
    else
        RemainStep += CurrOffsetStep;

    if (StepNumber > RemainStep)
        return TRUE;

    return FALSE;
}

#endif
//
/* 电机状态MotorStatus = STATUS_MOTOR_IDLE;   */
VOID StopMotor(VOID)
{
    MotorSpeed = 0;
    MotorCounter = 0;
    StepDelay = 0;
    MotorEnable = FALSE;
    MotorStatus = STATUS_MOTOR_IDLE;
    PreMotorStatus = STATUS_MOTOR_IDLE;
    SetStepMotorCurrent(CURRENT_OFF);
    RibbonControl(FALSE, DCM_STOP, RibbonInside);
}

WORD CheckMotorCurrentDown(WORD Time)
{
    if (Time > MOTOR_CUR_DOWN_TIME + 100)
        return MOTOR_CUR_DOWN_TIME;
    else
        return 0;
}

VOID MotorCurrentDown(VOID)
{
    if (MotorEnable != TRUE)
        return;

    SetStepMotorCurrent(CURRENT_60);
}

VOID RibbonControl(BOOL Enable, INT request, BOOL inside)
{
#if defined(RIBBON_MODEL) && defined(TTP286M_MACH)
    _eMotorDir SupplyDirection = (inside ? MOTOR_BACKWARD : MOTOR_FORWARD);

    switch (request) {
    case DCM_PRE_STOP:
        DCMotorRewindCtrl(Enable, MOTOR_FORWARD,   15);
        DCMotorSupplyCtrl(Enable, SupplyDirection, 15);
        break;
    case DCM_STOP:
        DCMotorRewindCtrl(FALSE, MOTOR_FORWARD,   0);
        DCMotorSupplyCtrl(FALSE, SupplyDirection, 0);
        break;
    case DCM_PRE_FORWARD:
        DCMotorRewindCtrl(Enable, MOTOR_FORWARD,   DCForwardCurrent[MotorSpeed][0][0]);
        DCMotorSupplyCtrl(Enable, SupplyDirection, DCForwardCurrent[MotorSpeed][1][0]);
        break;
    case DCM_FORWARD:
        DCMotorRewindCtrl(Enable, MOTOR_FORWARD,   DCForwardCurrent[MotorSpeed][0][1]);
        DCMotorSupplyCtrl(Enable, SupplyDirection, DCForwardCurrent[MotorSpeed][1][1]);
        break;
    case DCM_POST_FORWARD:
        DCMotorRewindCtrl(Enable, MOTOR_FORWARD,   DCForwardCurrent[MotorSpeed][0][2]);
        DCMotorSupplyCtrl(Enable, SupplyDirection, DCForwardCurrent[MotorSpeed][1][2]);
        break;
    case DCM_PRE_BACKWARD:
        DCMotorRewindCtrl(Enable, MOTOR_BACKWARD,  DCBackwardCurrent[MotorSpeed][0][0]);
        DCMotorSupplyCtrl(Enable, SupplyDirection, DCBackwardCurrent[MotorSpeed][1][0]);
        break;
    case DCM_BACKWARD:
        DCMotorRewindCtrl(Enable, MOTOR_BACKWARD,  DCBackwardCurrent[MotorSpeed][0][1]);
        DCMotorSupplyCtrl(Enable, SupplyDirection, DCBackwardCurrent[MotorSpeed][1][1]);
        break;
    case DCM_POST_BACKWARD:
        DCMotorRewindCtrl(Enable, MOTOR_FORWARD,   DCBackwardCurrent[MotorSpeed][0][2]);
        DCMotorSupplyCtrl(Enable, SupplyDirection, DCBackwardCurrent[MotorSpeed][1][2]);
        break;
    }

#elif defined(RIBBON_MODEL) && defined(TTP2410M_MACH)

#elif defined(RIBBON_MODEL)
    switch (request) {
    case DCM_PRE_STOP:
        DCMotorRewindCtrl(Enable, MOTOR_FORWARD, 15);
        break;
    case DCM_STOP:
        DCMotorRewindCtrl(FALSE, MOTOR_FORWARD, 0);
        break;
    case DCM_PRE_FORWARD:
        DCMotorRewindCtrl(Enable, MOTOR_FORWARD,  DCForwardCurrent[MotorSpeed][0]);
        break;
    case DCM_FORWARD:
        DCMotorRewindCtrl(Enable, MOTOR_FORWARD,  DCForwardCurrent[MotorSpeed][1]);
        break;
    case DCM_POST_FORWARD:
        DCMotorRewindCtrl(Enable, MOTOR_FORWARD,  DCForwardCurrent[MotorSpeed][2]);
        break;
    case DCM_PRE_BACKWARD:
        DCMotorRewindCtrl(Enable, MOTOR_BACKWARD, DCBackwardCurrent[MotorSpeed][0]);
        break;
    case DCM_BACKWARD:
        DCMotorRewindCtrl(Enable, MOTOR_BACKWARD, DCBackwardCurrent[MotorSpeed][1]);
        break;
    case DCM_POST_BACKWARD:
        DCMotorRewindCtrl(Enable, MOTOR_FORWARD,  DCBackwardCurrent[MotorSpeed][2]);
        break;
    }

#endif
}
///
/*  这是一个电机控制的函数，主要作用是根据不同的电机状态（停止、前进、后退）来控制电机运动。代码中包含了一些参数设置，如电机速度、步骤延迟等。
   同时，还会触发一些外部设备，如RibbonControl和Trigger74123等。

根据MotorStatus的取值，函数会执行不同的操作：

1 当MotorStatus为STATUS_MOTOR_IDLE时，表示电机处于空闲状态，会调用RibbonControl函数停止带动器的运动。
2 当MotorStatus为STATUS_MOTOR_STOP时，表示电机停止运动，会根据上一次的PreMotorStatus执行一些操作，并逐渐减小StepDelay直到为0，
    最后停止带动器的运动，设置电机电流为CURRENT_OFF，将MotorStatus设置为STATUS_MOTOR_IDLE，并将MotorEnable设置为FALSE。

3 当MotorStatus为STATUS_MOTOR_FORWARD时，表示电机正向运动，会根据上一次的PreMotorStatus执行一些操作，并逐渐减小StepDelay直到为0，
    最后根据当前的MotorSpeed和StepNum的值进行相应的处理，修改MotorCounter的值，如果MotorCounter为0，则将MotorStatus设置为STATUS_MOTOR_STOP，并执行一些操作。

4 当MotorStatus为STATUS_MOTOR_BACKWARD时，表示电机反向运动，会根据上一次的PreMotorStatus执行一些操作，并逐渐减小StepDelay直到为0，
    最后根据当前的MotorSpeed和StepNum的值进行相应的处理，修改MotorCounter的值，如果MotorCounter为0，则将MotorDelay设置为STOP_DELAY，并将MotorStatus设置为STATUS_MOTOR_STOP，并执行一些操作。
最后，函数返回一个BOOL类型的值，表示是否有运动发生 

*/
///
BOOL MotorProcess(VOID)     //<--MotionJobProcess(_MotionJob *MJob)
{
    BOOL movement = FALSE;

    // motor disable
    if (MotorEnable != TRUE)
        return FALSE;

    if (MotorSpeed > SPEED_NUM - 1)    //确保在合理范围内
        MotorSpeed = SPEED_NUM - 1;

    if (PreMotorStatus != MotorStatus)   //检测当前状态和上一次的电机状态是否相同，
        StepNum = 0;

    switch (MotorStatus)
    {
        case STATUS_MOTOR_IDLE:
        {
            RibbonControl(FALSE, DCM_STOP, RibbonInside);
            break;
        }
           case STATUS_MOTOR_STOP:                              // 2
        {
            if (PreMotorStatus != STATUS_MOTOR_STOP)
            {
                StepDelay = STOP_DELAY;          //步骤延迟    STOP_DELAY = 48
                if (PreMotorStatus == STATUS_MOTOR_FORWARD)
                    RibbonControl(DCMotorEnable, DCM_POST_FORWARD, RibbonInside);
                if (PreMotorStatus == STATUS_MOTOR_BACKWARD)
                    RibbonControl(DCMotorEnable, DCM_POST_BACKWARD, RibbonInside);
            }
            PreMotorStatus = STATUS_MOTOR_STOP;

            if (StepDelay == STOP_DELAY / 2)
                RibbonControl(DCMotorEnable, DCM_PRE_STOP, RibbonInside);

            if (StepDelay == 0)
            {
                RibbonControl(FALSE, DCM_STOP, RibbonInside);
                SetStepMotorCurrent(CURRENT_OFF);
                PreMotorStatus = MotorStatus = STATUS_MOTOR_IDLE;
                MotorEnable = FALSE;
            }
            else
                StepDelay -= 1;

            break;
           }
           case STATUS_MOTOR_FORWARD:
           {
            if (PreMotorStatus != STATUS_MOTOR_FORWARD)
            {

                StepDelay += FORWARD_DELAY;     //   FORWARD_DELAY
                RibbonControl(DCMotorEnable, DCM_PRE_FORWARD, RibbonInside);
                Trigger74123();
        sysprintf("Motor_2\n");
                MotorPhaseChange(MOTOR_NULL);
            }
            PreMotorStatus = STATUS_MOTOR_FORWARD;
            SetStepMotorCurrent(CURRENT_100);

            if (StepDelay == 1)
                RibbonControl(DCMotorEnable, DCM_FORWARD, RibbonInside);

            if (StepDelay == 0)
            {
#if defined(TTP2410M_MACH) || defined(TTP286M_MACH)
                if (CheckDeceleration(StepNum) && StepNum >= SpeedToStepTable[DOWN_TO_SPEED])
                {
                    if (--StepNum <= SpeedToStepTable[DOWN_TO_SPEED])
                        StepNum = SpeedToStepTable[DOWN_TO_SPEED];
                }
                else
#endif
                {
                    if (++StepNum >= SpeedToStepTable[MotorSpeed])
                        StepNum = SpeedToStepTable[MotorSpeed];
                }

                if (MotorCounter)
                    MotorCounter -= 1;

                if (MotorCounter == 0)
                    MotorStatus = STATUS_MOTOR_STOP;
sysprintf("Motor_3\n");                                      //PC打印时中间循环执行到结束
                MotorPhaseChange(MOTOR_FORWARD);
                movement = TRUE;
            }
            else
                StepDelay -= 1;

            break;
           }
           case STATUS_MOTOR_BACKWARD:
           {
            if (PreMotorStatus != STATUS_MOTOR_BACKWARD)
            {
                StepDelay = BACKWARD_DELAY;      //   BACKWARD_DELAY = 12
                if(BACKWARD_RIBBON_ENBLE != 0 )
                {
                    RibbonControl(DCMotorEnable, DCM_PRE_BACKWARD, RibbonInside);
                }
                Trigger74123();
//    sysprintf("Motor_4\n");                      //PC打印时开始进来执行1次
                MotorPhaseChange(MOTOR_NULL);
            }
            PreMotorStatus = STATUS_MOTOR_BACKWARD;
            SetStepMotorCurrent(CURRENT_100);      //设置电机电流

            //if (StepDelay == 1&&(BACKWARD_RIBBON_ENBLE != 0))
            if (StepDelay == 1)
                RibbonControl(DCMotorEnable, DCM_BACKWARD, RibbonInside);

            if (StepDelay == 0)
            {
                if (++StepNum >= SpeedToStepTable[MotorSpeed])
                    StepNum = SpeedToStepTable[MotorSpeed];

                if (MotorCounter)
                    MotorCounter -= 1;

                if (MotorCounter == 0)
                {
                    StepDelay = STOP_DELAY;
                    MotorStatus = STATUS_MOTOR_STOP;
                }
sysprintf("Motor_5\n");                               //PC打印时开始循环执行一段时间   
                MotorPhaseChange(MOTOR_BACKWARD);
                movement = TRUE;
            }
            else
                StepDelay -= 1;

            break;
           }
    }
    return movement;
}

StepMotorDrv.c  。。。。。。。。。。。。。。。。。。。。。。。。。。。

/******************************************************************************
 *                                                                            *
 *                         M O D U L E   D E F I N E                          *
 *                                                                            *
 ******************************************************************************/

#define STEPMOTORDRV_C

/******************************************************************************
 *                                                                            *
 *        C O M P I L E R   D E F I N E D   I N C L U D E   F I L E S         *
 *                                                                            *
 ******************************************************************************/

/* None */

/******************************************************************************
 *                                                                            *
 *            U S E R   D E F I N E D   I N C L U D E   F I L E S             *
 *                                                                            *
 ******************************************************************************/

#include "Common.h"
#include "XCore.h"
#include "XTimer.h"
#include "Motor.h"

unsigned char phaseChngCnt[8] = {0}; // ch_20220127

/******************************************************************************
 *                                                                            *
 *                         L O C A L   D E F I N E S                          *
 *                                                                            *
 ******************************************************************************/

#if defined(TTP245P_PCB) 
#define MOTOR_CURRENT0_HIGH            AT91F_PIO_SetOutput(AT91C_BASE_PIOB, AT91C_PIO_PB2)
#define MOTOR_CURRENT0_LOW            AT91F_PIO_ClearOutput(AT91C_BASE_PIOB, AT91C_PIO_PB2)
#define MOTOR_CURRENT1_HIGH            AT91F_PIO_SetOutput(AT91C_BASE_PIOB, AT91C_PIO_PB3)
#define MOTOR_CURRENT1_LOW            AT91F_PIO_ClearOutput(AT91C_BASE_PIOB, AT91C_PIO_PB3)
#define MOTOR_PHASE1_PIN            ( AT91F_PIO_IsInputSet(AT91C_BASE_PIOC, AT91C_PIO_PC4) == AT91C_PIO_PC4 )
#define MOTOR_PHASE1_HIGH            AT91F_PIO_SetOutput(AT91C_BASE_PIOC, AT91C_PIO_PC4)
#define MOTOR_PHASE1_LOW            AT91F_PIO_ClearOutput(AT91C_BASE_PIOC, AT91C_PIO_PC4)
#define MOTOR_PHASE2_HIGH            AT91F_PIO_SetOutput(AT91C_BASE_PIOC, AT91C_PIO_PC10)
#define MOTOR_PHASE2_LOW            AT91F_PIO_ClearOutput(AT91C_BASE_PIOC, AT91C_PIO_PC10)

#elif defined(T045_PCB) ||defined(T40_PCB)

#define MOTOR_POWER_HIGH              gpio_setportval(GPIO_PORTA, BIT3, BIT3)
#define MOTOR_POWER_LOW                  gpio_setportval(GPIO_PORTA, BIT3, 0)
#define MOTOR_CURRENT0_HIGH            //gpio_setportval(GPIO_PORTC, BIT1, BIT1)
#define MOTOR_CURRENT0_LOW            //gpio_setportval(GPIO_PORTC, BIT1, 0)
#define MOTOR_CURRENT1_HIGH            //gpio_setportval(GPIO_PORTC, BIT2, BIT2)
#define MOTOR_CURRENT1_LOW            //gpio_setportval(GPIO_PORTC, BIT2, 0)
#define MOTOR_PHASE1_PIN            (inpw(REG_GPIOA_DOUT)&BIT2)
#define MOTOR_PHASE1_HIGH            gpio_setportval(GPIO_PORTA, BIT2, BIT2)
#define MOTOR_PHASE1_LOW            gpio_setportval(GPIO_PORTA, BIT2, 0)
#define MOTOR_PHASE2_HIGH            gpio_setportval(GPIO_PORTA, BIT4, BIT4)
#define MOTOR_PHASE2_LOW            gpio_setportval(GPIO_PORTA, BIT4, 0)

#endif

/******************************************************************************
 *                                                                            *
 *                        L O C A L   T Y P E D E F S                         *
 *                                                                            *
 ******************************************************************************/

/* None */

/******************************************************************************
 *                                                                            *
 *             L O C A L   F U N C T I O N   P R O T O T Y P E S              *
 *                                                                            *
 ******************************************************************************/

/* None */

/******************************************************************************
 *                                                                            *
 *    L O C A L   I N I T I A L I Z E D   D A T A   D E F I N I T I O N S     *
 *                                                                            *
 ******************************************************************************/

#if defined(TTP245P_PCB) ||defined(T045_PCB) ||defined(T40_PCB)

//--- Motor temperture ---//
STATIC CONST INT MotorTempTable[] = 
{
    913,908,903,898,893,887,881,875,869,863,857,850,843,837,829,822,    // 21  ~  36 
    815,807,800,792,784,776,767,759,750,742,733,724,715,706,696,687,    // 37  ~  52 
    677,668,658,649,639,629,619,609,599,590,580,570,560,550,540,530,    // 53  ~  68 
    520,510,501,491,481,472,462,453,444,434,425,416,407,398,389,381,    // 69  ~  84 
    372,364,356,348,340,332,324,316,309,302,294,287,280,274,267,260,    // 85  ~ 100 
};

#endif

STATIC UINT MotorPhase = 0;                // step motor phase

/******************************************************************************
 *                                                                            *
 *    L O C A L   U N I T I A L I Z E D   D A T A   D E F I N I T I O N S     *
 *                                                                            *
 ******************************************************************************/

/******************************************************************************
 *
 * Function:
 *    
 *
 * Description: 
 *        
 *
 * Input:
 *      None
 *
 * Output:
 *      None.
 *
 ******************************************************************************/

VOID InitialMotorCurrent(VOID)
{

    SetStepMotorCurrent(CURRENT_OFF);
}

#if defined(TTP245P_PCB) ||defined(T045_PCB) ||defined(T40_PCB)
WORD CalculateMotorTemp(WORD Value)
{
    INT i;

    for ( i = 0 ; i < sizeof(MotorTempTable) / sizeof(WORD) ; i++ )
    {
        if ( Value > MotorTempTable[i] )
            break;
    }
    return ( i + 21 );
}

#endif

VOID SetStepMotorCurrent(_eMotorCurrent Current)
{
    switch ( Current )
    {
        case CURRENT_OFF:
            MOTOR_POWER_LOW;
            MOTOR_CURRENT0_HIGH;
            MOTOR_CURRENT1_HIGH;
            break;

        case CURRENT_20:
            MOTOR_POWER_HIGH;
            MOTOR_CURRENT0_LOW;
            MOTOR_CURRENT1_HIGH;
            break;

        case CURRENT_60:
            MOTOR_POWER_HIGH;
            MOTOR_CURRENT0_HIGH;
            MOTOR_CURRENT1_LOW;
            break;

        case CURRENT_100:
            MOTOR_POWER_HIGH;
            MOTOR_CURRENT0_LOW;
            MOTOR_CURRENT1_LOW;
            break;
    }
}

#if ORIGIN_STEP_MOTOR_DRIVE
VOID MotorPhaseChange(_eMotorDir Direction)
{
#if defined(TTP245P)  || defined(TDP245P)  
    if ( Direction == MOTOR_FORWARD )
        MotorPhase += 1;
    else if ( Direction == MOTOR_BACKWARD )
        MotorPhase -= 1;
#else
    if ( Direction == MOTOR_FORWARD )
        MotorPhase -= 1;
    else if ( Direction == MOTOR_BACKWARD )
        MotorPhase += 1;
#endif

    switch ( MotorPhase % 4 )
    {
        case 0:        // 11
            MOTOR_PHASE1_HIGH;
            MOTOR_PHASE2_HIGH;
            break;

        case 1:        // 01
            MOTOR_PHASE1_HIGH;
            MOTOR_PHASE2_LOW;
            break;

        case 2:        // 00
            MOTOR_PHASE1_LOW;
            MOTOR_PHASE2_LOW;
            break;

        case 3:        // 10
            MOTOR_PHASE1_LOW;
            MOTOR_PHASE2_HIGH;
            break;
    }
}
#endif

#if FULL_STEP_FULL_CURRENT
VOID MotorPhaseChange(_eMotorDir Direction)
{
    UINT32 u32Temp1 = 0; // ch_20220130
    
#if defined(TTP245P)  || defined(TDP245P)  
    if ( Direction == MOTOR_FORWARD )
        MotorPhase += 1;
    else if ( Direction == MOTOR_BACKWARD )
        MotorPhase -= 1;
#else
    if ( Direction == MOTOR_FORWARD )
        MotorPhase -= 1;
    else if ( Direction == MOTOR_BACKWARD )
        MotorPhase += 1;
#endif

    switch ( MotorPhase % 4 )
    {
        case 0:        // 11
            u32Temp1 = inpw(REG_GPIOC_DOUT);
//            MOTOR_PHASE1_HIGH;
            // GPC8
            if (!(u32Temp1&BIT8))
                u32Temp1 |= BIT8;
//            MOTOR_PHASE2_HIGH;
            // GPC11
            if (!(u32Temp1&BIT11))
                u32Temp1 |= BIT11;
            outpw(REG_GPIOC_DOUT, u32Temp1);
            break;

        case 1:        // 01
            u32Temp1 = inpw(REG_GPIOC_DOUT);
//            MOTOR_PHASE1_HIGH;
            if (!(u32Temp1&BIT8))
                u32Temp1 |= BIT8;            
//            MOTOR_PHASE2_LOW;
            u32Temp1 &= ~BIT11;
            outpw(REG_GPIOC_DOUT, u32Temp1);
            break;

        case 2:        // 00
            u32Temp1 = inpw(REG_GPIOC_DOUT);
//            MOTOR_PHASE1_LOW;
//            MOTOR_PHASE2_LOW;
            u32Temp1 &= ~(BIT8|BIT11);
            outpw(REG_GPIOC_DOUT, u32Temp1);
            break;

        case 3:        // 10
            u32Temp1 = inpw(REG_GPIOC_DOUT);
//            MOTOR_PHASE1_LOW;
            u32Temp1 &= ~BIT8;
//            MOTOR_PHASE2_HIGH;
            if (!(u32Temp1&BIT11))
                u32Temp1 |= BIT11;
            outpw(REG_GPIOC_DOUT, u32Temp1);
            break;
    }
}

#elif HALF_STEP_FULL_CURRENT
VOID MotorPhaseChange(_eMotorDir Direction)
{
    UINT32 u32Temp1 = 0; // ch_20220130
    
#if defined(TTP245P)  || defined(TDP245P)  
    if ( Direction == MOTOR_FORWARD )
        MotorPhase += 1;
    else if ( Direction == MOTOR_BACKWARD )
        MotorPhase -= 1;
#else
    if ( Direction == MOTOR_FORWARD )
//        MotorPhase -= 1; // ch_20220120
        MotorPhase += 1; // ch_20220120
    else if ( Direction == MOTOR_BACKWARD )
//        MotorPhase += 1; // ch_20220120
        MotorPhase -= 1; // ch_20220120
#endif

    switch ( MotorPhase % 8)
    {
        case 0:        // 1101        
            // ch_20220130
            u32Temp1 = inpw(REG_GPIOC_DOUT);
            u32Temp1 &= ~(BIT9);
//            u32Temp1 |= (BIT8|BIT11|BIT6);        
            if (!(u32Temp1 & BIT8))
                u32Temp1 |= BIT8;        
            if (!(u32Temp1 & BIT11))
                u32Temp1 |= BIT11;
            if (!(u32Temp1 & BIT6))
                u32Temp1 |= BIT6;                        
            outpw(REG_GPIOC_DOUT, u32Temp1);
        
            phaseChngCnt[0]++; // ch_20220127
            break;

        case 1:        // 1100
            // ch_20220130
            u32Temp1 = inpw(REG_GPIOC_DOUT);
            u32Temp1 &= ~(BIT9|BIT6);
//            u32Temp1 |= (BIT8|BIT11);
            if (!(u32Temp1 & BIT8))
                u32Temp1 |= BIT8;        
            if (!(u32Temp1 & BIT11))
                u32Temp1 |= BIT11;            
            outpw(REG_GPIOC_DOUT, u32Temp1);

            phaseChngCnt[1]++; // ch_20220127
            break;

        case 2:        // 0110
            // ch_20220130
            u32Temp1 = inpw(REG_GPIOC_DOUT);
            u32Temp1 &= ~(BIT8|BIT6);
//            u32Temp1 |= (BIT11|BIT9);
            if (!(u32Temp1 & BIT11))
                u32Temp1 |= BIT11;
            if (!(u32Temp1 & BIT9))
                u32Temp1 |= BIT9;                
            outpw(REG_GPIOC_DOUT, u32Temp1);            

            phaseChngCnt[2]++; // ch_20220127
            break;

        case 3:        // 0100
            // ch_20220130
            u32Temp1 = inpw(REG_GPIOC_DOUT);
            u32Temp1 &= ~(BIT8|BIT9|BIT6);
//            u32Temp1 |= (BIT11);
            if (!(u32Temp1 & BIT11))
                u32Temp1 |= BIT11;        
            outpw(REG_GPIOC_DOUT, u32Temp1);            

            phaseChngCnt[3]++; // ch_20220127
            break;

        case 4:        // 0001
            // ch_20220130
            u32Temp1 = inpw(REG_GPIOC_DOUT);
            u32Temp1 &= ~(BIT8|BIT11|BIT9);
//            u32Temp1 |= (BIT6);
            if (!(u32Temp1 & BIT6))
                u32Temp1 |= BIT6;                
            outpw(REG_GPIOC_DOUT, u32Temp1);

            phaseChngCnt[4]++; // ch_20220127
            break;

        case 5:        // 0000
            // ch_20220130
            u32Temp1 = inpw(REG_GPIOC_DOUT);
            u32Temp1 &= ~(BIT8|BIT11|BIT9|BIT6);
            outpw(REG_GPIOC_DOUT, u32Temp1);

            phaseChngCnt[5]++; // ch_20220127
            break;

        case 6:        // 1010
            // ch_20220130
            u32Temp1 = inpw(REG_GPIOC_DOUT);
            u32Temp1 &= ~(BIT11|BIT6);
//            u32Temp1 |= (BIT8|BIT9);
            if (!(u32Temp1 & BIT8))
                u32Temp1 |= BIT8;        
            if (!(u32Temp1 & BIT9))
                u32Temp1 |= BIT9;                
            outpw(REG_GPIOC_DOUT, u32Temp1);

            phaseChngCnt[6]++; // ch_20220127
            break;

        case 7:        // 1000
            // ch_20220130
            u32Temp1 = inpw(REG_GPIOC_DOUT);
            u32Temp1 &= ~(BIT11|BIT9|BIT6);
//            u32Temp1 |= (BIT8);
            if (!(u32Temp1 & BIT8))
                u32Temp1 |= BIT8;                
            outpw(REG_GPIOC_DOUT, u32Temp1);

            phaseChngCnt[7]++; // ch_20220127
            break;            
    }
}

// ch_20220130
#elif HALF_STEP_PART_CURRENT
VOID MotorPhaseChange(_eMotorDir Direction)
{
    UINT32 u32Temp1 = 0; // ch_20220130
    
#if defined(TTP245P)  || defined(TDP245P)  
    if ( Direction == MOTOR_FORWARD )
        MotorPhase += 1;
    else if ( Direction == MOTOR_BACKWARD )
        MotorPhase -= 1;
#else
    if ( Direction == MOTOR_FORWARD )
//        MotorPhase -= 1; // ch_20220120
        MotorPhase += 1; // ch_20220120
    else if ( Direction == MOTOR_BACKWARD )
//        MotorPhase += 1; // ch_20220120
        MotorPhase -= 1; // ch_20220120
#endif

    switch ( MotorPhase % 8)
    {
        case 0:
            // PTC8-PTC11-PTC9-PTC3-PTC6-PTC0
            // 1 1 0 0 1 1
            u32Temp1 = inpw(REG_GPIOC_DOUT);
            u32Temp1 &= ~(BIT9|BIT3);
        
            // ch_20220204
//            u32Temp1 |= (BIT8|BIT11|BIT6|BIT0); 
            if (!(u32Temp1 & BIT8))
                u32Temp1 |= BIT8;
            if (!(u32Temp1 & BIT11))
                u32Temp1 |= BIT11;
            if (!(u32Temp1 & BIT6))
                u32Temp1 |= BIT6;
            if (!(u32Temp1 & BIT0))
                u32Temp1 |= BIT0;
            
            outpw(REG_GPIOC_DOUT, u32Temp1);
        
            phaseChngCnt[0]++; // ch_20220127
            break;

        case 1:
            // PTC8-PTC11-PTC9-PTC3-PTC6-PTC0
            // 1 1 1 0 1 0
            u32Temp1 = inpw(REG_GPIOC_DOUT);
            u32Temp1 &= ~(BIT3|BIT0);

            // ch_20220204
//            u32Temp1 |= (BIT8|BIT11|BIT9|BIT6); 
            if (!(u32Temp1 & BIT8))
                u32Temp1 |= BIT8;
            if (!(u32Temp1 & BIT11))
                u32Temp1 |= BIT11;
            if (!(u32Temp1 & BIT9))
                u32Temp1 |= BIT9;
            if (!(u32Temp1 & BIT6))
                u32Temp1 |= BIT6;
            
            outpw(REG_GPIOC_DOUT, u32Temp1);

            phaseChngCnt[1]++; // ch_20220127
            break;

        case 2:
            // PTC8-PTC11-PTC9-PTC3-PTC6-PTC0
            // 0 1 1 1 0 0
            u32Temp1 = inpw(REG_GPIOC_DOUT);
            u32Temp1 &= ~(BIT8|BIT6|BIT0);

            // ch_20220204
//            u32Temp1 |= (BIT11|BIT9|BIT3);
            if (!(u32Temp1 & BIT11))
                u32Temp1 |= BIT11;
            if (!(u32Temp1 & BIT9))
                u32Temp1 |= BIT9;
            if (!(u32Temp1 & BIT3))
                u32Temp1 |= BIT3;
            
            outpw(REG_GPIOC_DOUT, u32Temp1);            

            phaseChngCnt[2]++; // ch_20220127
            break;

        case 3:
            // PTC8-PTC11-PTC9-PTC3-PTC6-PTC0
            // 0 1 1 0 1 0
            u32Temp1 = inpw(REG_GPIOC_DOUT);
            u32Temp1 &= ~(BIT8|BIT3|BIT0);

            // ch_20220204        
//            u32Temp1 |= (BIT11|BIT9|BIT6);            
            if (!(u32Temp1 & BIT11))
                u32Temp1 |= BIT11;
            if (!(u32Temp1 & BIT9))
                u32Temp1 |= BIT9;
            if (!(u32Temp1 & BIT6))
                u32Temp1 |= BIT6;
            
            outpw(REG_GPIOC_DOUT, u32Temp1);        

            phaseChngCnt[3]++; // ch_20220127
            break;

        case 4:
            // PTC8-PTC11-PTC9-PTC3-PTC6-PTC0
            // 0 0 0 0 1 1
            u32Temp1 = inpw(REG_GPIOC_DOUT);
            u32Temp1 &= ~(BIT8|BIT11|BIT9|BIT3);

            // ch_20220204        
//            u32Temp1 |= (BIT6|BIT0);                    
            if (!(u32Temp1 & BIT6))
                u32Temp1 |= BIT6;
            if (!(u32Temp1 & BIT0))
                u32Temp1 |= BIT0;    
            
            outpw(REG_GPIOC_DOUT, u32Temp1);

            phaseChngCnt[4]++; // ch_20220127
            break;

        case 5:
            // PTC8-PTC11-PTC9-PTC3-PTC6-PTC0
            // 0 0 1 0 1 0
            u32Temp1 = inpw(REG_GPIOC_DOUT);
            u32Temp1 &= ~(BIT8|BIT11|BIT3|BIT0);

            // ch_20220204        
//            u32Temp1 |= (BIT9|BIT6);                    
            if (!(u32Temp1 & BIT9))
                u32Temp1 |= BIT9;
            if (!(u32Temp1 & BIT6))
                u32Temp1 |= BIT6;
            
            outpw(REG_GPIOC_DOUT, u32Temp1);

            phaseChngCnt[5]++; // ch_20220127
            break;

        case 6:
            // PTC8-PTC11-PTC9-PTC3-PTC6-PTC0
            // 1 0 1 1 0 0
            u32Temp1 = inpw(REG_GPIOC_DOUT);
            u32Temp1 &= ~(BIT11|BIT6|BIT0);

            // ch_20220204        
//            u32Temp1 |= (BIT8|BIT9|BIT3);    
            if (!(u32Temp1 & BIT8))
                u32Temp1 |= BIT8;            
            if (!(u32Temp1 & BIT9))
                u32Temp1 |= BIT9;
            if (!(u32Temp1 & BIT3))
                u32Temp1 |= BIT3;
            
            outpw(REG_GPIOC_DOUT, u32Temp1);

            phaseChngCnt[6]++; // ch_20220127
            break;

        case 7:
            // PTC8-PTC11-PTC9-PTC3-PTC6-PTC0
            // 1 0 1 0 1 0
            u32Temp1 = inpw(REG_GPIOC_DOUT);
            u32Temp1 &= ~(BIT11|BIT3|BIT0);

            // ch_20220204
//            u32Temp1 |= (BIT8|BIT9|BIT6);                    
            if (!(u32Temp1 & BIT8))
                u32Temp1 |= BIT8;            
            if (!(u32Temp1 & BIT9))
                u32Temp1 |= BIT9;
            if (!(u32Temp1 & BIT6))
                u32Temp1 |= BIT6;
            
            outpw(REG_GPIOC_DOUT, u32Temp1);

            phaseChngCnt[7]++; // ch_20220127
            break;            
    }
}
#endif

#if defined(TTP245P_PCB) ||defined(T045_PCB) ||defined(T40_PCB)
VOID Trigger74123(VOID)
{
#if 0
    BOOL data = MOTOR_PHASE1_PIN;
    MOTOR_PHASE1_HIGH;
    DelayTime(10);
    MOTOR_PHASE1_LOW;
    if ( data )
        MOTOR_PHASE1_HIGH;
#endif
}

#endif