T168_111\system\PrtEng：第5~7

最新推荐文章于 2024-08-16 23:08:28 发布

qq_33772147

最新推荐文章于 2024-08-16 23:08:28 发布

阅读量396

点赞数 5

文章标签： java 前端服务器

本文链接：https://blog.csdn.net/qq_33772147/article/details/137682212

版权

PrtEng.c 。。。。。。。。。。。。。。。。。。。。。。。。。。。。

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

#define PRTENG_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 <string.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 "XProFile.h"
#include "XADC.h"
#include "XLED.h"
#include "XKey.h"
#include "XCentronic.h"
#include "XTimer.h"
#include "XTask.h"
#include "XVarBank.h"
#include "XDisplay.h"
#include "XFunction.h"
#include "PrtEng.h"

extern _AnalogMedia* GetMediaData(VOID); // ch_20220718

extern UCHAR GetCalStatPowerOn(VOID); // ch_20220411
extern _CalResult* GetCalResult(VOID);

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

#if defined(AT91SAM9260)
#if defined(TTP245P_PCB)
#define ENABLE_MOTION_ISR           (AT91C_BASE_TC5->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG)
#define DISABLE_MOTION_ISR           (AT91C_BASE_TC5->TC_CCR = AT91C_TC_CLKDIS)
#define   CLEAR_MOTION_STATUS

#define ENABLE_MOTOR_CTRL_ISR AT91F_TC_InterruptEnable(AT91C_BASE_TC5, AT91C_TC_CPAS)
#define DISABLE_MOTOR_CTRL_ISR AT91F_TC_InterruptDisable(AT91C_BASE_TC5, AT91C_TC_CPAS)
#define CLEAR_MOTOR_CTRL_STATUS

#define   MOTION_TIME                   AT91C_BASE_TC5->TC_RC
#define   MOTOR_CTRL_TIME               AT91C_BASE_TC5->TC_RA
#elif defined(T045_PCB) ||defined(T40_PCB)
#define ENABLE_MOTION_ISR           (AT91C_BASE_TC2->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG)
#define DISABLE_MOTION_ISR           (AT91C_BASE_TC2->TC_CCR = AT91C_TC_CLKDIS)
#define   CLEAR_MOTION_STATUS

#define ENABLE_MOTOR_CTRL_ISR AT91F_TC_InterruptEnable(AT91C_BASE_TC2, AT91C_TC_CPAS)
#define DISABLE_MOTOR_CTRL_ISR AT91F_TC_InterruptDisable(AT91C_BASE_TC2, AT91C_TC_CPAS)
#define CLEAR_MOTOR_CTRL_STATUS

#define MOTION_TIME AT91C_BASE_TC2->TC_RC
#define MOTOR_CTRL_TIME AT91C_BASE_TC2->TC_RA

#endif

#elif defined(SH7040)
#define ENABLE_MOTION_ISR           (MTU.TSTR.BIT.CST4 = 1)
#define DISABLE_MOTION_ISR           (MTU.TSTR.BIT.CST4 = 0)
#define   CLEAR_MOTION_STATUS           (MTU4.TSR.BIT.TGFB = 0)

#define ENABLE_MOTOR_CTRL_ISR       (MTU4.TIER.BIT.TGIEA = 1)
#define DISABLE_MOTOR_CTRL_ISR       (MTU4.TIER.BIT.TGIEA = 0)
#define CLEAR_MOTOR_CTRL_STATUS       (MTU4.TSR.BIT.TGFA = 0)

#define MOTION_TIME MTU4.TGRB
#define MOTOR_CTRL_TIME MTU4.TGRA

#elif defined(N3290)
//#define ENABLE_MOTION_ISR outpw(REG_TCSR1, (inpw(REG_TCSR1) & 0x87FFFFFF)|(0x0C<<27))
//#define DISABLE_MOTION_ISR outpw(REG_TCSR1, (inpw(REG_TCSR1) & 0x87FFFFFF)&(~~(0x0C<<27)))

#define ENABLE_MOTION_ISR outpw(REG_TCSR1, (inpw(REG_TCSR1) & 0x87FFFF00)|0x03 | ((0x1 | 0xC)<<27))
#define DISABLE_MOTION_ISR outpw(REG_TCSR1,0)

#define CLEAR_MOTION_STATUS

#define ENABLE_MOTOR_CTRL_ISR
#define DISABLE_MOTOR_CTRL_ISR
#define CLEAR_MOTOR_CTRL_STATUS

#define MOTION_TIME(time) do{DISABLE_MOTION_ISR;outpw(REG_TICR1,time);ENABLE_MOTION_ISR;}while(0)

#define MOTION_TIME_CLEAR() do{outpw(REG_TDR1,0);}while(0) // ch_20220616

//#define MOTOR_CTRL_TIME(time)
#endif

//#if defined(XPH500E) ||defined(DELUXE_3044)
//#define MOTOR_TIMES 3
//#define PRINT_TIMES 2

//#else
#if defined(T41_PCB)&&defined(MOTOR_MICROSTEP)
#define MOTOR_TIMES 1
#define PRINT_TIMES 2
#else

#if ORIGIN_STEP_MOTOR_DRIVE
#define MOTOR_TIMES 1
#define PRINT_TIMES 1
#endif

#if NEW_STEP_MOTOR_DRIVE
#if FULL_STEP_FULL_CURRENT
#define MOTOR_TIMES                   1
#define PRINT_TIMES                   1
#elif HALF_STEP_FULL_CURRENT
#define MOTOR_TIMES                   1
#define PRINT_TIMES                   2//1 //ch_20220121 : changed to 2 from 1 to match PRINT_TIMES.
#elif HALF_STEP_PART_CURRENT
#define MOTOR_TIMES                   1
#define PRINT_TIMES                   2//1 //ch_20220121 : changed to 2 from 1 to match PRINT_TIMES.
#endif
#endif

#endif
//#endif

#if defined(DLP200) || defined(DLP300)
#define PAPER_ERROR_OFFSET (TPH_DPI * 2)
#else
#define PAPER_ERROR_OFFSET (MM_DOT * 10)
#endif

#define FABRIC_CUT_TIMMING 30 // ms
#define DONTBACK_CUT_TIMMING 0 // ms
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/

STATIC XCALLBACK MotionCallback = _NULL;

STATIC ULONG PeriodTimes = 0;

STATIC INT FabricCutIndex = 0;
STATIC INT FabricCutTime[4] = {-1, -1, -1, -1};
STATIC INT FabricCutCount[4] = {0, 0, 0, 0};
STATIC INT DontBackCutIndex = 0;
STATIC INT DontBackCutTime[4] = {-1, -1, -1, -1};
STATIC INT DontBackCutCount[4] = {0, 0, 0, 0};

/******************************************************************************
* *
* 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 _PrintRecord* pEngRec;
STATIC _PrintCfg* pEngCfg;
STATIC BOOL MotionEnable;

STATIC SHORT PaperCnt = 0; // ch_20220312
STATIC SHORT GapBmCnt = 0; // ch_20220312
STATIC SHORT PrevPaperLen; // ch_20220318
STATIC SHORT PaperLength;
STATIC INT GapBmLength;
STATIC INT PrevGapBmLen = 0; // ch_20220313
STATIC UINT16 GapLenUpCnt = 0; // ch_20220323
STATIC INT PartGapLenSubTotal = 0; // ch_20220314
STATIC INT AllGapLenSubTotal = 0; // ch_20220314
STATIC UCHAR FakePositionOnPaper = 0; // ch_20220313
STATIC UCHAR PreFakePosOnPaper = 0; // ch_20220328
STATIC INT PreSensorPos = POSITION_UNKNOW; // ch_20220314
STATIC UINT16 BlankPaperQty4Compare = 0; // ch_20220318
STATIC UINT16 BlankPaperQty4Print = 0; // ch_20220320
STATIC UCHAR FirstBlankPaper = 0; // ch_20220324
STATIC UCHAR PrintedPaperCnt = 0; // ch_20220323
STATIC UCHAR RetractCnt4BlankPaper = 0; // ch_20220326
STATIC _ePrintJobSeq PrtJobSeq = SEQ_NULL; // ch_20220328

//STATIC SHORT PaperJamCnt; // ch_20220411
STATIC SHORT PaperJamCnt; // ch_20220411
STATIC SHORT GapJamCnt; // ch_20220411
STATIC SHORT LabelEmptyCnt;

STATIC BOOL CreateProcessMenu;
STATIC BOOL ReprintStatus;
STATIC INT ReprintKey;

STATIC BOOL CalibrateMedia;
STATIC BOOL MeasureMedia;

STATIC INT WaitTimeNum;
STATIC WORD WaitJobTime;

STATIC INT CutWaitNum;
STATIC WORD CutWaitTime;

STATIC WORD ContinuousGap;
STATIC BOOL BackBeforePrinting;
STATIC WORD PaperJamLength;
STATIC BOOL ErrorAfterPrinted;
STATIC BOOL RecallSensorSignal;

STATIC INT PrtPrintTotal;
STATIC INT PrtPrintRemain;
STATIC BOOL DontBackCutWorking = FALSE;
STATIC BOOL PreDontBackCutWorking = FALSE;

/
// ch_20220726
STATIC UCHAR PrevWorkType = 0;
UCHAR GetPrevWorkType(VOID) {
return PrevWorkType;
}

/
// ch_20220623
STATIC INT InitialTempLevel = 0, PrevTempLevel = 0;
VOID ClrTempLevel(VOID) {
PrevTempLevel = 0;
InitialTempLevel = 0;
}
/

/
// ch_20220527
STATIC UINT32 FeedStepCnt = 0;
VOID ClrFeedStepCnt(VOID) {
FeedStepCnt = 0;
}
/

STATIC VOID InitialMotionTimer(VOID)
{
UINT dummy;

#if defined(AT91SAM9260)
#if defined(TTP245P_PCB)

   // Disable the Clock Counter
   AT91C_BASE_TC5->TC_CCR = AT91C_TC_CLKDIS;
   // Disable all interrupts
   AT91C_BASE_TC5->TC_IDR = 0xFFFFFFFF;
   // Clear the status register
   dummy = AT91C_BASE_TC5->TC_SR;
   // Select divider and compare trigger
   AT91C_BASE_TC5->TC_CMR =   AT91C_TC_CLKS_TIMER_DIV3_CLOCK |
                               AT91C_TC_WAVESEL_UP_AUTO |
                               AT91C_TC_WAVE;
   // Enable the Clock counter
   AT91C_BASE_TC5->TC_CCR = AT91C_TC_CLKEN;
   // Validate the RC compare interrupt
   AT91C_BASE_TC5->TC_IER = AT91C_TC_CPCS;

AT91F_TC_InterruptEnable(AT91C_BASE_TC5, AT91C_TC_CPCS);

   // Register timer interrupt handler
   AT91F_AIC_ConfigureIt (   AT91C_BASE_AIC,                           // AIC base address
                           AT91C_ID_TC5,                           // Peripheral ID
                           MOTION_PRIORITY,                       // Priority
                           AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE,   // Level sensitive
                           MotionHandler );
   // Enable TC0 interrupt
   AT91F_AIC_EnableIt(AT91C_BASE_AIC, AT91C_ID_TC5);

   // Set compare value
   AT91C_BASE_TC5->TC_RA = (CLOCK_TIME / 500);   // 2 ms
   AT91C_BASE_TC5->TC_RC = GetSpeedTime();
#elif defined(T045_PCB) ||defined(T40_PCB)
   // Disable the Clock Counter
   AT91C_BASE_TC2->TC_CCR = AT91C_TC_CLKDIS;
   // Disable all interrupts
   AT91C_BASE_TC2->TC_IDR = 0xFFFFFFFF;
   // Clear the status register
   dummy = AT91C_BASE_TC2->TC_SR;
   // Select divider and compare trigger
   AT91C_BASE_TC2->TC_CMR =   AT91C_TC_CLKS_TIMER_DIV3_CLOCK |
                               AT91C_TC_WAVESEL_UP_AUTO |
                               AT91C_TC_WAVE;
   // Enable the Clock counter
   AT91C_BASE_TC2->TC_CCR = AT91C_TC_CLKEN;
   // Validate the RC compare interrupt
   AT91C_BASE_TC2->TC_IER = AT91C_TC_CPCS;

AT91F_TC_InterruptEnable(AT91C_BASE_TC2, AT91C_TC_CPCS);

   // Register timer interrupt handler
   AT91F_AIC_ConfigureIt (   AT91C_BASE_AIC,                           // AIC base address
                           AT91C_ID_TC2,                           // Peripheral ID
                           MOTION_PRIORITY,                       // Priority
                           AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE,   // Level sensitive
                           MotionHandler );
   // Enable TC0 interrupt
   AT91F_AIC_EnableIt(AT91C_BASE_AIC, AT91C_ID_TC2);

   // Set compare value
   AT91C_BASE_TC2->TC_RA = (CLOCK_TIME / 500);   // 2 ms 6250
   AT91C_BASE_TC2->TC_RC = GetSpeedTime(); //10262
#endif

#elif defined(SH7040)
   MTU4.TCR.BYTE = 0x41;               // TCNT = 0 , when TGRB compare-match , @/4 = 7159090
    MTU4.TMDR.BYTE = 0xC0;               // TGR A B Operate normally , Normal operation
    MTU4.TIOR.WORD = 0x00;               // Output disabled
    MTU4.TIER.BIT.TGIEA = 0;            // when TCNT == TGRA , interrupt reguest disable
    MTU4.TIER.BIT.TGIEB = 1;            // when TCNT == TGRA , interrupt reguest
    MTU4.TGRA = (CLOCK_TIME / 500);       // 2 ms
    MTU4.TGRB = GetSpeedTime();
    MTU4.TCNT = 0x0000;
   MOTION_IPR = MOTION_PRIORITY;
#elif defined(N3290)

#if 0
   sysSetTimerReferenceClock(TIMER1, sysGetExternalClock()*1000);        //External Crystal
   sysStartTimer(TIMER1, 1000, PERIODIC_MODE);           /* 1000 ticks/per sec ==> 1tick/1ms */
   sysSetTimerEvent(TIMER1, 2, (PVOID)MotionISR);   /* 2 ticks = 2ms call back */

   sysSetLocalInterrupt(ENABLE_IRQ);
   sysEnableInterrupt(IRQ_TMR1);
   DISABLE_MOTION_ISR;
#else
   sysSetTimerReferenceClock(TIMER1,sysGetExternalClock() * 1000);//12Mhz
   outp32(REG_APBCLK, inp32(REG_APBCLK) | TMR1_CKE);
   outp32(REG_APBIPRST, inp32(REG_APBIPRST) | TMR1RST);
   outp32(REG_APBIPRST, inp32(REG_APBIPRST) & ~TMR1RST);
   //outpw(REG_TCSR1, (inpw(REG_TCSR1) & 0x87FFFF00) | PERIODIC_MODE);

   sysInstallISR(IRQ_LEVEL_2, IRQ_TMR1, (PVOID)MotionHandler);//IRQ_LEVEL_1
   sysEnableInterrupt(IRQ_TMR1);
   sysSetInterruptType(IRQ_TMR1, 1);   //eDRVAIC_HIGH_LEVELinverter
   sysSetLocalInterrupt(ENABLE_IRQ);

#endif

#endif
}

STATIC VOID CarriageOpenEvent(VOID)
{
   WORD wTemp = 0; // ch_20220721

#if defined(ANALOG_MEDIA)
   wTemp = GetJobErrorState(); // ch_20220721
   if (wTemp&ERROR_PAPER_EMPTY || wTemp&ERROR_PAPER_JAM) // ch_20220721
       InitialAnalogMedia();
#endif
   ClearPeelMedia();
   CalibrateMedia = TRUE;
   MeasureMedia = TRUE;
}
///
VOID InitialPrintEngine(VOID) //AppMain调用
{
   FLOAT data;

pEngRec = GrabPrintRecord();
pEngCfg = GrabPrintConfig();

InitialSensor(); //初始化传感器

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

#if defined(CARRIAGE_OPEN_MODEL)
InitCarriage();
#endif

   InitialPeel();
   InitialCutter();
   InitialTPHDrv();
   InitialMotor(&pEngCfg->MotorDir);
   InitialJobManager();
   InitialPositionManager();
   InitialCalibration();
   InitialMotionTimer();

CalculateHeatTable();

#if defined(CARRIAGE_OPEN_MODEL)
StartCheckCarriageOpen();
SetCarriageOpenCallback(CarriageOpenEvent);
#endif

CreateProcessMenu = FALSE;
ReprintStatus = FALSE;

CalibrateMedia = TRUE;
MeasureMedia = TRUE;

   WaitTimeNum = DELAY_TIME_NULL;
   WaitJobTime = 0;
   CutWaitNum = DELAY_TIME_NULL;
   CutWaitTime = 0;
   if (GetProfileInt("WAITING TIME OF CUTTING", &data))
       CutWaitTime = (WORD)data;

   ContinuousGap = 0;
   if (GetProfileInt("GAP OF CONTINUOUS", &data))
       ContinuousGap = (SHORT)data;

#if defined(TTP245P_PCB) ||defined(T045_PCB) ||defined(T40_PCB)
BackBeforePrinting = FALSE;

#else
BackBeforePrinting = TRUE;

#endif

if (GetProfileInt("BACK WHEN PRINTING", &data))
BackBeforePrinting = (BOOL)data;

   PaperJamLength = 0;
   if (GetProfileInt("LENGTH OF PAPER JAM", &data))
       PaperJamLength = (WORD)data;
#ifdef DEBUG_PRNT
sysprintf("JamLen%d\n", PaperJamLength); // ch_20220321
#endif

   ErrorAfterPrinted = FALSE;
   if (GetProfileInt("WAIT PRINTEND AFTER ERROR", &data))
       ErrorAfterPrinted = (BOOL)data;

RecallSensorSignal = FALSE;

   if (GetProfileInt("SENSOR SIGNAL OF RECALL", &data))
       RecallSensorSignal = (BOOL)data;
}
///
VOID SetReprintKey(BOOL key)
{
   if (key == TRUE)
       ReprintKey = 1;
   if (key == FALSE)
       ReprintKey = 2;
}

BOOL GetReprintStatus(VOID)
{
return ReprintStatus;
}

VOID SetWaitTime(WORD time)
{
   INT imask = DisableInterrupt(MOTION_IMASK);
   ClrDelayTime(WaitTimeNum);
   WaitTimeNum = DELAY_TIME_NULL;
   WaitJobTime = time;
   EnableInterrupt(imask);
}
///
/*这段代码的作用是设置打印机的总数和剩余数量，并且根据是否定义了LCD_MODEL宏来设置显示器上的剩余数量。
具体实现是通过调用SetDisplayRemain函数来设置显示器上的剩余数量，然后将总数和剩余数量分别赋值给全局变量PrtPrintTotal和PrtPrintRemain。
如果没有定义LCD_MODEL宏，则不会调用SetDisplayRemain函数。*/
VOID SetPrintRemain(INT total, INT remain)
{
#if defined(LCD_MODEL)
   SetDisplayRemain(total, remain);
#endif
   PrtPrintTotal = total;
   PrtPrintRemain = remain;
}

INT GetPrintRemain(VOID)
{
return PrtPrintRemain;
}

VOID ReloadWaitTime(VOID)
{
   INT imask = DisableInterrupt(MOTION_IMASK);
   ClrDelayTime(WaitTimeNum);
   WaitTimeNum = SetDelayTime(WaitJobTime);
   EnableInterrupt(imask);
}

BOOL IsMotion(VOID)
{
   return MotionEnable;
}

VOID EnableMotion(VOID)//<-AddWorkJob(_WorkJob *WorkJob)
{
   if (MotionEnable == TRUE)
       return;

   ENABLE_MOTION_ISR;//MotionHandler
   MotionEnable = TRUE;
   //sysprintf("EnableMotion\n");
}
/
VOID DisableMotion(VOID)
{
   DISABLE_MOTION_ISR;
   MotionEnable = FALSE;
   //sysprintf("DisableMotion\n");
}

XCALLBACK SetMotionCallback(XCALLBACK Callback)
{
   XCALLBACK old = MotionCallback;
   MotionCallback = Callback;
   return old;
}

//STATIC INT CheckSensorPosition(_MotionJob *MJob)
INT CheckSensorPosition(_MotionJob *MJob) //pc下发打印中间循环执行单击按键中间会进来循环执行
{
   _WorkJob *WorkJob = &MJob->WorkJob;
   INT Signal;

   ADCDeinit();
   DelayTime(20);
   ADCInit();
   DelayTime(20);
sysprintf("checkSenPos--\n");

   if ((WorkJob->SensorMode == BLINE_MODE) || (WorkJob->SensorMode == CONTINUE_MODE_R) || \
       (CONTINUE_MODE_T == WorkJob->SensorMode)) // ch_20220126
   {
       //
       // ch_20220530
       if ((CONTINUE_MODE_T == WorkJob->SensorMode) || (CONTINUE_MODE_R == WorkJob->SensorMode)) {
#if defined(ANALOG_MEDIA)
//           SetSensorRdyFlg(TRUE); // ch_20220616 // 20220126
           AnalogMediaSampling(BLINE_SENSOR_AD);
#endif
           Signal = GetBlineSnrSgnOfContPaper();
//           sensorPos = GetSensorPosition(BLINE_SENSOR, Signal); // ch_20220616 // ch_20220126
           return GetSensorPosition(BLINE_SENSOR, Signal);
       }
       else {
       //

#if defined(ANALOG_MEDIA)
//       SetSensorRdyFlg(TRUE); // ch_20220616 // 20220126
       AnalogMediaSampling(BLINE_SENSOR_AD);
#endif
       Signal = GetSensorSignal(BLINE_SENSOR);
//       sensorPos = GetSensorPosition(BLINE_SENSOR, Signal); // ch_20220616 // ch_20220126
       return GetSensorPosition(BLINE_SENSOR, Signal);
//sysprintf("BS%d\t%d\n", Signal, sensorPos); // ch_20211216
//return temp;
       }

   }
   else   // Gap mode and continue mode
   {
#if defined(ANALOG_MEDIA)
//       SetSensorRdyFlg(TRUE); // ch_20220616 // 20220126
       AnalogMediaSampling(GAP_SENSOR_AD);
#endif
       Signal = GetSensorSignal(GAP_SENSOR);

//temp = GetSensorPosition(GAP_SENSOR, Signal);
//sysprintf("GS%d\t%d\t", Signal, temp); // ch_20211216

       return GetSensorPosition(GAP_SENSOR, Signal); // ch_20220401
//       return GetSensorPos4Print(GAP_SENSOR, Signal); // ch_20220401
   }
}
//
STATIC INT RecallSensorPosition(_MotionJob *MJob, INT Position)
{
   STATIC BYTE Store[0x400];
   STATIC INT Index = 0x400;
   STATIC INT Back = 0;

   if (RecallSensorSignal == FALSE)
       return Position;
sysprintf("RecallSen--\n");
   if (GetPreMotorDir() == MOTOR_FORWARD)
   {
       if (Back)   // recall sensor position
       {
           Position = Store[Index & 0x3FF];
           Back -= 1;
       }
       Store[Index++ & 0x3FF] = Position;   // save current position
   }
   else   // motor backward
   {
       Back += 1;
       Index -= 1;
   }
   return Position;
}
///
STATIC INT IgnoreUndersize(_MotionJob *MJob, INT Position) //<--MotionJobProcess(_MotionJob *MJob) //pc下发打印中间循环执行单击按键中间会循环执行
{
   STATIC INT Skip = 0;

   _WorkJob *WorkJob = &MJob->WorkJob;
sysprintf("IgnoreUndersize--\n");
   if (WorkJob->IgnoreSize <= 0)
       return Position;

   if (Position == POSITION_ON_GAP_BLINE)
   {
       if (Skip++ < WorkJob->IgnoreSize)
           Position = POSITION_ON_PAPER;
   }
   else
       Skip = 0;

return Position;
}

STATIC WORD GetLabelEmptyLen(_WorkJob *WorkJob) //<--CheckPaperError（）//pc下发打印时中间循环执行
{
WORD Length = 0;

   if (WorkJob->SensorMode == GAP_MODE)
       Length += (WORD)(WorkJob->fGapSize + WorkJob->fGapOffset); // ch_20220311
//       Length += TPH_GAP_DIS << 1;//(((WORD)(WorkJob->fLabelSize)<<2) + WorkJob->fGapOffset); // ch_20220311
   else if (WorkJob->SensorMode == BLINE_MODE)
       Length += (WORD)(WorkJob->fBlineSize + WorkJob->fBlineOffset);
   Length += PAPER_ERROR_OFFSET;

   if (Length > WorkJob->LimitFeed)
       Length = WorkJob->LimitFeed;
// WorkJob->SensorMode = 2 EmptyLen = 80
sysprintf("%s() : WorkJob->SensorMode = %d\tEmptyLen = %d\n", __FUNCTION__, WorkJob->SensorMode, Length); // ch_20211216

return Length;
}

STATIC WORD GetPaperJamLen(_WorkJob *WorkJob) //<--CheckPaperError(_MotionJob *MJob, INT SensorPos)
{
   WORD Length;
sysprintf("GetPaperJamLen--\n");
   if (PaperJamLength)
       return PaperJamLength;

// 1.5 Paper size
Length = (WORD)WorkJob->fPaperSize + ((WORD)WorkJob->fPaperSize >> 1);

if (Length < WorkJob->LimitFeed && WorkJob->Type == FEED_JOB)
Length = WorkJob->LimitFeed;

//sysprintf("JamLen%d\n", Length); // ch_20211216

return Length;
}

#if defined(RIBBON_MODEL)

STATIC VOID CheckRibbonError(_MotionJob *MJob)
{
   _WorkJob *WorkJob = &MJob->WorkJob;
   STATIC UCHAR ribbonErrCnt = 0; // ch_20220421
   UCHAR RibbonStat = 0; // ch_20220611

if (WorkJob->Ribbon == FALSE)
return;

RibbonStat = CheckRibbonStat();

//sysprintf("R_S_%d\n", RibbonStat);

   if (RibbonStat&(1<<1)) {

       // ch_20220421
       if (++ribbonErrCnt < 3)
           goto RIBBON_CHECK_EMPTY;
       else
           ribbonErrCnt = 0;


       MJob->ErrState |= ERROR_RIBBON_JAM;
   }
   else // ch_20220722
       ribbonErrCnt = 0; // ch_20220722

RIBBON_CHECK_EMPTY:
if (ErrorAfterPrinted && !OverPrintLine())
return;

if (RibbonStat&(1<<0))
MJob->ErrState |= ERROR_RIBBON_EMPTY;
}

#endif

SHORT GetPaperLength(VOID)
{
return PaperLength;
}

SHORT GetGapBmLength(VOID)
{
return GapBmLength;
}

// ch_20220312
INT GetPrevPaperLen(VOID)
{
   return PrevPaperLen;
}
INT GetRealTimeGapBmLen(_WorkJob *WorkJob)
{
   // ch_20220324
   if (GapBmCnt < 0)
       return 0;

   if (WorkJob->Ribbon)
       GapBmLength = GapBmCnt * 1000 / TT_ADD_PERCENT;
   else
       GapBmLength = GapBmCnt * 1000 / DT_ADD_PERCENT;

   return GapBmLength;
}
VOID ResetGapBmCnt(VOID)

{
   GapBmCnt = 0;
}
VOID AdjustRealTimeGapBmLength(_WorkJob *WorkJob)
{
   PrevGapBmLen -= (INT)WorkJob->fGapSize;
}
UCHAR GetFakePosOnPaper(VOID)
{
   return FakePositionOnPaper;
}
VOID ResetFakePosOnPaper(VOID)
{
   FakePositionOnPaper = 0;
}

STATIC VOID CheckLabelLength(_MotionJob *MJob, INT SensorPos, INT PreSensorPos)
{
// STATIC SHORT PaperCnt = 0; // ch_20220312
// STATIC SHORT GapBmCnt = 0; // ch_20220312

_WorkJob *WorkJob = &MJob->WorkJob;

if (WorkJob->Type != PRINT_JOB && WorkJob->Type != FEED_JOB)
return;

if (WorkJob->SensorMode != GAP_MODE && WorkJob->SensorMode != BLINE_MODE)
return;

   // sensor in paper
   if (SensorPos == POSITION_ON_PAPER)
   {
      if (PreSensorPos == POSITION_ON_GAP_BLINE)
      {
           if (WorkJob->Ribbon)
               GapBmLength = GapBmCnt * 1000 / TT_ADD_PERCENT;
           else
               GapBmLength = GapBmCnt * 1000 / DT_ADD_PERCENT;
      }
// ch_20220305
//if (GapBmCnt)
   sysprintf("GC%d\t\n", GapBmCnt);
//       if (GapBmCnt < 0) RetractCnt4BlankPaper++; // ch_20220326
       GapBmCnt = 0;
       if (GetPreMotorDir() == MOTOR_FORWARD)
           PaperCnt++;
       else
           PaperCnt--;
   }

   // sensor in gap bline
   if (SensorPos == POSITION_ON_GAP_BLINE)
   {
       if (PreSensorPos == POSITION_ON_PAPER)
       {
           if (WorkJob->Ribbon)
               PaperLength = PaperCnt * 1000 / TT_ADD_PERCENT;
           else
               PaperLength = PaperCnt * 1000 / DT_ADD_PERCENT;
       }
// ch_20220305
//if (PaperCnt)
//   sysprintf("PC%d\t", PaperCnt);
       PaperCnt = 0;
       if (GetPreMotorDir() == MOTOR_FORWARD)
           GapBmCnt++;
       else
           GapBmCnt--;
   }
}
///pc下发打印中间循环执行
//检查媒体类型是否需要重置
//该函数主要用于检测媒体类型、传感器模式、标签尺寸和亮度是否发生变化，如果有变化则返回TRUE，否则返回FALSE。
//具体实现逻辑如下：
STATIC BOOL CheckMediaTypeReset(_WorkJob *WorkJob) //<--CheckPaperError(_MotionJob *MJob, INT SensorPos)
{
   //definitional part
   BOOL ret = FALSE;
   BYTE Inten;

   STATIC _eSensorMode PreSensorMode = CONTINUE_MODE_T;
   STATIC FLOAT PreLabelSize = 0;
   STATIC BYTE PreInten = 0;
sysprintf("CheckMediaType--\n");

   if (WorkJob->SensorMode == GAP_MODE) //根据WorkJob的SensorMode字段的值，将Inten赋值为GapInten、BlineInten或ContinuousInten。
       Inten = WorkJob->GapInten;
   else if (WorkJob->SensorMode == BLINE_MODE)
       Inten = WorkJob->BlineInten;
   else
       Inten = WorkJob->ContinuousInten;

   if (PreSensorMode != WorkJob->SensorMode)
       ret = TRUE;
   if (PreLabelSize != WorkJob->fLabelSize)
       ret = TRUE;
   if (PreInten != Inten)
       ret = TRUE;

   PreSensorMode = WorkJob->SensorMode;
   PreLabelSize = WorkJob->fLabelSize;
   PreInten = Inten;
   return ret;
}

STATIC VOID ClearPaperErrorCounter(VOID)
{
   GapJamCnt = 0; // ch_20220412
   PaperJamCnt = 0;
   LabelEmptyCnt = 0;
}
/
STATIC BOOL CheckPaperError(_MotionJob *MJob, INT SensorPos) //<--MotionJobProcess(_MotionJob *MJob)
{
   _WorkJob *WorkJob = &MJob->WorkJob;
   BOOL ret = FALSE;
   WORD wTemp1 = 0; // ch_20220411

STATIC UCHAR jamedCnt = 0; // ch_20220429

//#ifdef DEBUG_PRNT
//sysprintf("CheckPaperError()...WT%d\n", WorkJob->Type); // ch_20220321
//#endif

   if (WorkJob->Type != PRINT_JOB && WorkJob->Type != FEED_JOB)
   {
       ClearPaperErrorCounter();
       return ret;
   }

   if (CheckMediaTypeReset(WorkJob))
   {
//#if defined(ANALOG_MEDIA)
//       InitialAnalogMedia(); // ch_20220719
//#endif
       ClearPaperErrorCounter();
   }

//sysprintf("SP%d\n", SensorPos); // ch_20220321

// sensor in paper
if (SensorPos == POSITION_ON_PAPER || SensorPos == POSITION_ON_DETECTING) {
//sysprintf("SP%d\t", SensorPos); // ch_20220321

       LabelEmptyCnt = 0;
//       if (GetPreMotorDir() == MOTOR_FORWARD) // ch_20220321
//       if ((0 == BlankPaperQty4Print) && (!GetCarriageStat())) { // ch_20220321
//       if (0 == BlankPaperQty4Print) { // ch_20220321
           if (GetPreMotorDir() == MOTOR_FORWARD) {
               PaperJamCnt++;
           }
           else {
               PaperJamCnt--;
           }
//       }
//       else {
           GapJamCnt = 0;
//           PaperJamCnt = 0; // ch_20220321
//       }

//
}

   // sensor in gap bline
   if (SensorPos == POSITION_ON_GAP_BLINE)
   {
//sysprintf("SP%d\t", SensorPos); // ch_20220321

       PaperJamCnt = 0;
//       GapJamCnt = 0; // ch_20220411
       if (GetPreMotorDir() == MOTOR_FORWARD)
           LabelEmptyCnt++;
       else
           LabelEmptyCnt--;

//
// ch_20220421 only for debug.
//sp1Cnt = 0; sp3Cnt = 0;
//sp2Cnt++;
//
}

if (ErrorAfterPrinted && !OverPrintLine())
return ret;

   if (WorkJob->SensorMode == GAP_MODE || WorkJob->SensorMode == BLINE_MODE)
   {
       if (PaperJamCnt >= GetPaperJamLen(WorkJob))
       {
#ifdef DEBUG_PRNT
sysprintf("SensorPos = %d\tWorkJob->SensorMode = %d\tPaperJamCnt = %d\n", SensorPos, WorkJob->SensorMode, PaperJamCnt); // ch_20211215
#endif

ResetGapBmCnt(); // ch_20220611

PaperJamCnt = 0;
// GapJamCnt = 0; // ch_20220411

           // ch_20220421
           if (GetCarriageOpenOrClose()) {
               RstCarriageOpenOrCloseFlg();
               goto JAM_BRANCH_FALSE; // ch_20220530 : changed to JAM_BRANCH_FALSE from JAM_BRANCH_RET.
           }

// ch_20220126
//if (CalibratedStat()) // ch_20211216
//{

           // ch_20220429
           jamedCnt++;
           if (jamedCnt < 10)
               goto JAM_BRANCH_FALSE; // ch_20220530 : changed to JAM_BRANCH_FALSE from JAM_BRANCH_RET.
           jamedCnt = 0;

MJob->ErrState |= ERROR_PAPER_JAM;

ret = TRUE;

JAM_BRANCH_FALSE: // ch_20220530g
           ret = FALSE; // ch_20220530g

// ch_20220126
//}
//else
//   ret = FALSE;
       }
   }

   if (LabelEmptyCnt >= GetLabelEmptyLen(WorkJob))
   {
   //debug_printf("P:%d,%d,%d\r\n",PaperEmptyCnt,GetPaperEmptyLen(WorkJob),SensorPos);
#ifdef DEBUG_PRNT
sysprintf("LabelEmptyCnt = %d\tMJob->ErrState = %d\n", LabelEmptyCnt, MJob->ErrState); // ch_20211216
#endif
       LabelEmptyCnt = 0;

// ch_20220126
//if (CalibratedStat()) // ch_20211216
//{

ResetGapBmCnt(); // ch_20220611

if (!GetCalStatPowerOn()) // ch_20220411
goto EMPTY_BRANCH_FALSE; // ch_20220530 : changed to EMPTY_BRANCH_FALSE from EMPTY_BRANCH_RET

       // ch_20220709
       if (GetCarriageOpenOrClose()) {
           RstCarriageOpenOrCloseFlg();
           goto EMPTY_BRANCH_FALSE;
       }

       // ch_20220421
       if (BlankPaperQty4Print)
           goto EMPTY_BRANCH_FALSE;

       MJob->ErrState |= ERROR_PAPER_EMPTY;

//EMPTY_BRANCH_RET: // ch_20220530
ret = TRUE;

EMPTY_BRANCH_FALSE: // ch_20220530
ret = FALSE; // ch_20220530

}

return ret;
}

STATIC INT GetOverHead(VOID)
{
return pEngCfg->OverHead;
}

STATIC VOID ClearOverHead(VOID)
{
   pEngCfg->OverHead = 0;
}
复位调整头部
STATIC VOID ResetAdjustHead(_WorkJob *WorkJob)
{
   pEngCfg->AdjustHead = GetShiftDis(WorkJob);
}
///
/*这段代码用于移动标签（label）的操作。它接受了一个工作任务结构体指针 WorkJob、电机方向 Direction、步长 Step 和连续模式标志 Continuous 作为参数。
   首先，它获取了打印机配置中的一个变量 RibbonInside 的值。

在一些特定的条件下（如定义了 DLP200、DLP300，或者传感器模式为 GAP_MODE 或 BLINE_MODE），Step 的值会经过 CorrectShrinkage() 函数进行修正。

最后，通过调用 EnableMotor() 函数来使能电机，实现标签的移动。函数的参数包括方向、步长、速度、打印带类型和是否内侧位置的标志。

*///
STATIC VOID MoveLabel(_WorkJob *WorkJob, _eMotorDir Direction, INT Step, BOOL Continuous) //<--RetractPresented(_WorkJob *WorkJob)
{
BOOL inside = pEngCfg->RibbonInside;

#if defined(DLP200) || defined(DLP300) /*|| defined(XPH500B) || defined(XPH500E)*/
if (!Continuous || WorkJob->SensorMode == GAP_MODE || WorkJob->SensorMode == BLINE_MODE)
#endif
Step = CorrectShrinkage(Step, WorkJob->Ribbon);

//sysprintf("S=%d\n", Step); // ch_20220217

   EnableMotor(Direction, Step, WorkJob->Speed, WorkJob->Ribbon, inside);
}
/// 走位移量
/*这段代码是用于处理打印机的纸张调整操作。首先，它获取了打印头位置的偏移量（shift），然后计算了需要调整的值（adjust）。
接着根据调整值的正负进行相应的操作：如果调整值大于 0，则向前移动打印头；如果调整值小于 0，
则向后移动打印头，并将状态设置为 TRUE。最后，重置了一些参数，并返回状态值。
*/
STATIC BOOL RetractPresented(_WorkJob *WorkJob) //<--WorkJobProcess(_MotionJob *MJob, BOOL Print)
{
   SHORT shift = GetShiftDis(WorkJob); //
   SHORT adjust = shift - pEngCfg->AdjustHead - pEngCfg->OverHead;
   BOOL status = FALSE;

   if (adjust > 0)
   {
sysprintf("MovL...1\n");
       MoveLabel(WorkJob, MOTOR_FORWARD, adjust, FALSE);
   }
   else if (adjust < 0)
   {
//       adjust -= 8;/*4*/; // ch_20220624 : changed to 8 from 4. // ch_20220527 : up-down-offset.
//sysprintf("MovL...2\n");       //pc下发打印开始进来执行1次
//sysprintf("adjust..=%d\n",adjust);
//_       adjust = adjust+100 ;
       MoveLabel(WorkJob, MOTOR_BACKWARD, 0 - adjust, FALSE);
       status = TRUE;
   }
   pEngCfg->OverHead   = 0;
   pEngCfg->AdjustHead = shift;

#ifdef DEBUG_PRNT
sysprintf("RetractPresented()...\n"); // ch_20220104
#endif

return status;
}
走偏移量
STATIC BOOL LabelPresent(_WorkJob *WorkJob)
{

   if (pEngCfg->OverHead == 0) //
   {
       pEngCfg->OverHead = GetOffsetDis(WorkJob); // ch_20220112   获取偏移量并赋值给 pEngCfg->OverHead

sysprintf("MovL...3\n"); //PC下发打印后边（快打完时）进来执行1次
MoveLabel(WorkJob, MOTOR_FORWARD, pEngCfg->OverHead, FALSE);
#if defined(TTP2410M_MACH) || defined(TTP286M_MACH)
SetDeceleration(pEngCfg->OverHead, 0, WorkJob->Ribbon, FALSE);
#endif

       return TRUE;
   }
   return FALSE;
}

STATIC TASK(ProcessMenu, arg)
{
#if defined(LCD_MODEL) && defined(MENU_TSPL_3)
   JobMenu();
#endif
   if (arg) *(BOOL *)arg = FALSE;
   TaskExit();
}

STATIC VOID KeyProcessMenu(INT Key)
{
if (CreateProcessMenu)
return;

#if defined(MENU_TSPL_3)
   // enters cancels the work the menu
   ReprintKey = 3;
   CreateProcessMenu = TRUE;
   TaskCreate(ProcessMenu, &CreateProcessMenu, TASK_MENU_STACK);
#endif
}

STATIC BOOL PrintKeyProcess(VOID)
{
   STATIC BOOL Entry = FALSE;
   _ePolyLEDStat LEDState = 0; // ch_20220608

INT Event = 0;

   if (CreateProcessMenu)
       return FALSE;
sysprintf("PrintKeyProcess...1\n");
   if (!Entry)
   {
       StopKeyFunc();
       GetKey(FEED_KEY);
       GetKey(MENU_KEY);

#if defined(LCD_MODEL)
       SetDisplayStatus(DIS_PRINTKEY);
#elif defined(MONO_LED)
       StartPeriodFunc(FlashLED2);
#elif defined(POLY_LED)
       ///
       // ch_20220609
sysprintf("P_K_P\n");
       LEDState = GetLEDStat();
//sysprintf("LED_S_%d\n", LEDState);
       if (LED_FLASH_RED_BLUE == LEDState)
           CancelPeriodFunc(FlashBlueRedLED);
       else if (LED_FLASH_RED_BLUE_FAST == LEDState)
           CancelPeriodFunc(FlashBlueRedLEDFast);
       SetLEDStat(LED_FLASH_BLUE);
       ///
       StartPeriodFunc(FlashGreenLED);
#endif
       Entry = TRUE;
   }

if (GetKey(FEED_KEY))
Event = 1;

#if defined(MENU_TSPL_3)
   if (GetKey(MENU_KEY))   // enters cancels the work the menu
   {
       Event = 2;
       CreateProcessMenu = TRUE;
       TaskCreate(ProcessMenu, &CreateProcessMenu, TASK_MENU_STACK);
   }
#endif

   if (Event)
   {
       GetKey(MENU_KEY);
       GetKey(PAUSE_KEY);
       StartKeyFunc(TRUE);

#if defined(LCD_MODEL)
       ClrDisplayStatus(DIS_PRINTKEY);
#elif defined(MONO_LED)
       CancelPeriodFunc(FlashLED2);
       ShowLED(HID_LED_IDLE, HID_LED_ON, HID_LED_IDLE);
#elif defined(POLY_LED)
       CancelPeriodFunc(FlashGreenLED);
       ResetPrevLEDStat(); // ch_20220609
       ShowLED(HID_LED_GREEN);
#endif
       Entry = FALSE;
   }

if (Event == 1) // press FEED key
return TRUE;

   return FALSE;
}
/
STATIC INT ReprintKeyProcess(BOOL Cancel, INT Total, INT Count)
{
   STATIC BOOL Entry = FALSE;
   STATIC KEYFUNC BackupMenu = _NULL;
   _ePolyLEDStat LEDState = 0; // ch_20220608
sysprintf("R_K_P\n--");
   if (CreateProcessMenu && ReprintKey != 3)
       return 0;

   if (!Entry)
   {
       ReprintKey = 0;

       BackupMenu = SetKeyFunc(MENU_KEY, KeyProcessMenu);
       GetKey(DOWN_KEY);
       GetKey(SELECT_KEY);

#if defined(LCD_MODEL)
       SetDisplayReprintKey(Total, Count);
#elif defined(MONO_LED)
       StartPeriodFunc(FlashLED2);
#elif defined(POLY_LED)
       ///
       // ch_20220609

       LEDState = GetLEDStat();
//sysprintf("LED_S_%d\N", LEDState);
       if (LED_FLASH_RED_BLUE == LEDState)
           CancelPeriodFunc(FlashBlueRedLED);
       else if (LED_FLASH_RED_BLUE_FAST == LEDState)
           CancelPeriodFunc(FlashBlueRedLEDFast);
       SetLEDStat(LED_FLASH_BLUE);
       ///
       StartPeriodFunc(FlashGreenLED);
#endif
       Entry = TRUE;
   }

   if (Cancel)               // forced to cancel
       ReprintKey = 2;
   if (GetKey(SELECT_KEY))   // reprint: YES
       ReprintKey = 1;
   if (GetKey(DOWN_KEY))   // reprint: NO
       ReprintKey = 2;

if (ReprintKey == 1 && Total != 0 && Count >= Total)
ReprintKey = 0;

   if (ReprintKey)
   {
       SetKeyFunc(MENU_KEY, BackupMenu);

#if defined(LCD_MODEL)
       ClrDisplayStatus(DIS_REPRINTKEY);
#elif defined(MONO_LED)
       CancelPeriodFunc(FlashLED2);
       ShowLED(HID_LED_IDLE, HID_LED_ON, HID_LED_IDLE);
#elif defined(POLY_LED)
       CancelPeriodFunc(FlashGreenLED);
       ResetPrevLEDStat(); // ch_20220609
       ShowLED(HID_LED_GREEN);
#endif
       Entry = FALSE;
   }

if (ReprintKey == 3)
ReprintKey = 0;

return ReprintKey;
}
///
STATIC VOID FabricCutterProcess(_MotionJob *MJob)
{
INT index;

   if (MJob->State == JOB_PAUSE && MJob->Monitor == MONITOR_IDLE)
       return;
   if (MJob->WorkJob.PrintOutMode != CUTTER_MODE)
       return;

   if (IsFabricCutter())
   {
       FabricCutterDriver();

       for (index = 0; index < 4; index++)
       {
           if (FabricCutCount[index])
           {
               FabricCutCount[index] -= 1;
               if (FabricCutCount[index] == FabricCutTime[index])
{
                   if (!FabricCutterOpenGate())
                       MJob->ErrState |= ERROR_CUTTER;
}
           }
       }
   }
}
/
STATIC VOID FabricCutLabel(_WorkJob *WorkJob)
{
   FabricCutIndex += 1;
   FabricCutTime[FabricCutIndex & 0x3] = (FLOAT)FABRIC_CUT_TIMMING / (FLOAT)(1000 / (ToSpeedValue(WorkJob->Speed) * 300 * MOTOR_TIMES));
   FabricCutCount[FabricCutIndex & 0x3] = GetOffsetDis(WorkJob) * MOTOR_STEP_SCALE;
}

STATIC VOID FabricCutterCancel(VOID)
{
FabricCutTime[FabricCutIndex & 0x3] = -1;
}
/
/*函数签名:该函数名为WorkJobProcess，以_MotionJob指针MJob和BOOL参数Print作为输入。

静态变量:该函数利用几个静态变量，如PeelState、TakeState、CutterState等，来维护函数调用之间的状态信息。

初始化:函数在开始时初始化各种变量，如打印计数器、温度相关变量和作业状态。

状态机:该函数使用基于PrtJobSeq值(假定是一个作业序列)的switch语句实现状态机。不同的状态包括初始化、表单顶部、打印、表单馈送、刀具初始化、切割、剥离初始化、剥离动作、等待新作业、呈现和完成。

电机控制:代码涉及电机控制操作，例如向前移动标签，初始化打印和处理各种电机状态。

作业处理:该函数处理不同类型的作业，包括提要作业、打印作业和电机作业。它还处理诸如新建、锁定、删除和暂停等作业状态。

温度控制:有监测和控制打印头(TPH)温度的章节。它包括温度读数、计算和调整。

打印操作:该代码包含与打印操作相关的部分，包括处理打印键、切割机操作和管理打印过程。

错误处理:代码包括错误检查和设置错误标志，当满足某些条件时，如电机过热或刀具错误。

循环中断:代码使用break语句退出switch语句，并可能在某些条件下跳出函数。
*/
//pc下发打印循环进来执行单击按键也循环进来执行双击定标也循环进来执行
STATIC VOID WorkJobProcess(_MotionJob *MJob, BOOL Print) //<--MotionJobProcess(_MotionJob *MJob)
{
//   STATIC _ePrintJobSeq PrtJobSeq = SEQ_NULL; // ch_20220328
   STATIC _ePeelState *PeelState = _NULL;
   STATIC _eTakeState *TakeState = _NULL;
   STATIC _eCutterState *CutterState;
   STATIC _ePrintOutMode PrePrintOutMode;
   STATIC BOOL PrePrintKey;
   STATIC INT PrePrintKeyCnt;
   STATIC INT PreCutterCnt;
   STATIC INT ReprintKeyCnt = 0;
   STATIC INT PrintKeyCnt = 0;
   STATIC INT CutCnt = 0;
   STATIC INT OverHead;
   STATIC INT TPHTemp;
   STATIC INT TPHTempStep = 0;

   _WorkJob *WorkJob = &MJob->WorkJob; // 该函数对结构体_MotionJob进行操作，并从中提取WorkJob成员
   _eMotorStatus MotorStatus;
   BOOL Continuously;
   INT Value;
//Initialization part
   STATIC _ePrintJobSeq PrevPrtJobSeq = SEQ_NULL; // ch_20220311
//STATIC _eJobState PrevMJobState = JOB_NULL; // ch_20220311
//sysprintf("Enter WorkJobProcess()...\n"); // ch_20211208
   INT sTemp1 = 0, sTemp2 = 0; // ch_20220314
   STATIC INT PrevValidGapBmLen = 0; // ch_20220314
   _CalResult *CalRslt = NULL; // ch_20220323
   STATIC UCHAR ForceShift2Feed = 0; // ch_20220325
   STATIC INT PrevTemp = 0; // ch_20220402
   WORD i = 0; // ch_20220601
   STATIC INT CurrTempLevel = 0; // ch_20220712
   INT FinalTempLevel = 0; // ch_20220712
   STATIC WORD MaxLimitFeed = 0; // ch_20220627

_PrintCfg *pJobCfg = GrabPrintConfig(); // ch_20220816

//该函数对结构体_MotionJob进行操作，并从中提取WorkJob成员   /MJob->State
   if (MJob->State == JOB_NEW)
   {
       MJob->State = JOB_PRINTING; //打印中
       PrtJobSeq = SEQ_INIT;
   }

   if (MJob->State == JOB_LOCK)
   {
       MJob->State = JOB_PAUSE; //暂停
       PrtJobSeq = SEQ_INIT;
   }

   if (MJob->State == JOB_DELETE)
   {
       MJob->State = JOB_CANCEL;
       PrtJobSeq = SEQ_INIT;
   }

#if defined(TTP2410M_MACH) || defined(TTP286M_MACH)
   if (MJob->State == JOB_PAUSE)
       ClrContinuousJob();
#endif
MJob->State
   // ch_20220726
   if (PrevWorkType != WorkJob->Type)
       PrevWorkType = WorkJob->Type;

// ch_20220311
sysprintf("%d\n", MJob->State);
   sysprintf("WJobp--\n");

//sysprintf("%d,%d\t", WorkJob->Type, PrtJobSeq);
//使用状态机(PrtJobSeq)执行与打印、切割、剥离和处理各种作业状态相关的不同序列,状态包括初始化、表单顶部、打印、表单馈送、刀具初始化、切割、剥离初始化、剥离动作、等待新作业、呈现和完成
   switch (PrtJobSeq)
   {
       case SEQ_INIT:
       {
           MotorStatus = GetMotorStatus();
           if (MotorStatus != STATUS_MOTOR_STOP && MotorStatus != STATUS_MOTOR_IDLE) //如果电机在运行状态则退出轮询
               break;

           if (MJob->State == JOB_CANCEL) //工作取消
           {
               MJob->State = JOB_WAIT;
               PrtJobSeq = SEQ_FINISHED;
               break;
           }

           if (MJob->State == JOB_PAUSE) //工作暂停
           {
               MJob->Monitor = MONITOR_IDLE;
               break;
           }

           if (WorkJob->Type == FEED_JOB || WorkJob->Type == PRINT_JOB) //走纸或打印
           {
               sysprintf("pjs--1\n"); //单击按键进来执行，PC下发打印进来执行
               // initial print key counter
               if (WorkJob->PrintKeyCnt != PrePrintKeyCnt || WorkJob->PrintKey != PrePrintKey)
                   PrintKeyCnt = 0;

PrePrintKeyCnt = WorkJob->PrintKeyCnt;
PrePrintKey = WorkJob->PrintKey;

               // initial cutter counter
               if (WorkJob->CutterPieces != PreCutterCnt || WorkJob->PrintOutMode != PrePrintOutMode)
                   CutCnt = 0;

               PreCutterCnt = WorkJob->CutterPieces;
               PrePrintOutMode = WorkJob->PrintOutMode;
           }

#if defined(DIVIDE_INTENSION)
           //定标工作
           if ((CalibrateMedia && WorkJob->Calibrate && WorkJob->Type != MOTOR_JOB) ||
               (MeasureMedia && WorkJob->Measure && WorkJob->Type == PRINT_JOB) ||
               WorkJob->Type == CAL_JOB)
           {
           sysprintf("pjs--2\n"); //双击定标循环进来执行   ，定标不到时一直进来
               if (MotorStatus != STATUS_MOTOR_IDLE)
                   break;

MJob->Monitor = MONITOR_FORM_FEED;

if (CalibrationProcess(WorkJob, CalibrateMedia && WorkJob->Calibrate)) //启动定标
break;

               CalibrateMedia = FALSE;
               MeasureMedia = FALSE;
               ClearPaperErrorCounter();

               ClearOverHead();
               ResetAdjustHead(WorkJob);
               Value = GetNextPaperDis(WorkJob);
//sysprintf("SEQ_I-V = %d\n", Value); // ch_20220218
   //       sysprintf("MovL...4\n");
               MoveLabel(WorkJob, MOTOR_FORWARD, Value, FALSE);
#if defined(TTP2410M_MACH) || defined(TTP286M_MACH)
               SetDeceleration(Value, GetOffsetDis(WorkJob), WorkJob->Ribbon, FALSE);
#endif
               if (WorkJob->Type == CAL_JOB)
                   PrtJobSeq = SEQ_PRESENT;

               break;
           }
#endif
           if (WorkJob->PrintKey && WorkJob->Type == PRINT_JOB)
           {
           sysprintf("pjs--3\n");
               if (PrintKeyCnt == 0)
               {
                   if (!PrintKeyProcess())
                   {
                       MJob->Monitor = MONITOR_PRESS_KEY;
                       break;
                   }
               }

               PrintKeyCnt++;
               if (PrintKeyCnt >= WorkJob->PrintKeyCnt)
                   PrintKeyCnt = 0;
           }

#if defined(TTP245C_MACH)
           Value = GetMotorTemp();
           if (Value > WorkJob->MotorOverHeat)
           {
               MJob->ErrState |= ERROR_MOTOR_OVERHEAT;
               break;
           }
#endif

           // zebra ~~JS backfeed sequence
           OverHead = 0;
           if (WorkJob->SuppressBack && WorkJob->PrintOutMode != OFF_MODE)
           {
           sysprintf("pjs--4\n");
               OverHead = GetOverHead();
               ClearOverHead();
           }

           // partial cutter
           if (!WorkJob->CutterBack && WorkJob->PrintOutMode == CUTTER_MODE)
               ClearOverHead();

           if (WorkJob->Type != FEED_JOB || WorkJob->PrintOutMode != TEAR_MODE)
           {
sysprintf("pjs--5\n");   //PC下发打印时进来执行
               // top of form
               if (RetractPresented(WorkJob)) //用于处理打印机的纸张位置调整操作 //回退一定距离
               {
                   MJob->Monitor = MONITOR_RETRACT; //PC打印进来执行
               }
           }
           PrtJobSeq = SEQ_TOP_OF_FORM;
       }
       case SEQ_TOP_OF_FORM: //表单顶部 //
       {
           MotorStatus = GetMotorStatus();
           if (MotorStatus != STATUS_MOTOR_STOP && MotorStatus != STATUS_MOTOR_IDLE)
               break;

           if (WorkJob->Type == PRINT_JOB || WorkJob->Type == FEED_JOB) PC execute, Click a key ,
           {
               // mend gear slack
//           sysprintf("MovL...5\n"); //PC下发打印中间（回退完）进来执行1次
               MoveLabel(WorkJob, MOTOR_FORWARD, 0, TRUE);
               PrtJobSeq = SEQ_INIT_PRINT;
           }
           else if (WorkJob->Type == MOTOR_JOB)
           {
//sysprintf("W->Qty = %u\n", WorkJob->Quantity); // ch_20220218
       sysprintf("MovL...6\n");
               MoveLabel(WorkJob, WorkJob->MotorDir, WorkJob->Quantity, FALSE);
               MJob->Monitor = MONITOR_FORM_FEED;

#if defined(TTP2410M_MACH) || defined(TTP286M_MACH)
               if (WorkJob->MotorDir == MOTOR_FORWARD)
                   SetDeceleration(WorkJob->Quantity, 0, WorkJob->Ribbon, TRUE);
               SetJobRemainStep(0, WorkJob->Ribbon);
#endif
               MJob->State = JOB_WAIT;
               PrtJobSeq = SEQ_FINISHED;
               break;
           }
       }
       case SEQ_INIT_PRINT: //初始化打印
       {
//       sysprintf("1a3..\n"); //PC下发打印循环执行SEQ_TOP_OF_FORM一段时间后进来循环执行
           MotorStatus = GetMotorStatus();
           if (MotorStatus == STATUS_MOTOR_FORWARD || MotorStatus == STATUS_MOTOR_BACKWARD)
               break;

           if (WorkJob->Type == PRINT_JOB)
           {
           sysprintf("SP..1\n");   //PC execute
               StartADConvert(TPH_TEMP_AD); //开始检测打印头温度
               SetTPHPower(TRUE); //开启打印头电源
                                                   //计算打印行点数
               CalculatePrintPoint(WorkJob->Direction,
                                   WorkJob->Mirror,
                                   WorkJob->ImgBuf.pBuffer,
                                   WorkJob->PrintLength,
                                   WorkJob->ImgBuf.iFirstLine,
                                   WorkJob->ImgBuf.iLastLine,
                                   OverHead);
//WorkJob->Quantity：打印多份时当前的份数，   WorkJob->DspTotal：打印总份数，   WorkJob->DspBase：默认为0
               SetPrintRemain(WorkJob->DspTotal, WorkJob->DspBase + WorkJob->Quantity); //设置打印剩余数

               Value = ReadAD(TPH_TEMP_AD); 打印头温度ADC值
//               if (Value > 739) Value = 739; // ch_20220402
               if (Value > MAX_AD_VAL) Value = MAX_AD_VAL; // ch_20220604
               if (Value < MIN_AD_VAL) Value = MIN_AD_VAL; // ch_20220604

               if (CalculateTPHTemp(Value) > WorkJob->OverHeat)
//               if (CurTemp > WorkJob->OverHeat) // ch_20220605 // ch_20220402
               {
                   MJob->ErrState |= ERROR_TPH_OVERHEAT; //打印头高温
                   break;
               }
               Value = CalculateTPHTempLevel(Value); // If the level is bigger, the printing dark is lower. / Value_打印头温度等级
               //
               // ch_20220623
               CurrTempLevel = Value;
//sysprintf("%d\n", CurrTempLevel); // ch_20220712

               if (0 == InitialTempLevel) {
                   InitialTempLevel = CurrTempLevel;

//sysprintf("%d\t", InitialTempLevel); // ch_20220712
               }

// /

               TPHTemp = Value;
               CalculateHeatTime(WorkJob->Speed, WorkJob->Density, Value); //根据速度、浓度、打印头温度等级来计算加热时间
               MJob->Monitor = MONITOR_PRINTING;
               TPHTempStep=0;
           }

if (WorkJob->Type == FEED_JOB)
MJob->Monitor = MONITOR_FORM_FEED;

           // move motor
           if (WorkJob->SensorMode == GAP_MODE || WorkJob->SensorMode == BLINE_MODE)
           {
           sysprintf("SP..2\n"); //PC execute，Click a key ,
               // need the length greater than the paper error (1.5 Paper size)
               Value = (WORD)WorkJob->fPaperSize + ((WORD)WorkJob->fPaperSize >> 1); /Value_标签大小
//sysprintf("Value = %d\n", Value); // ch_20220218
               if (Value < WorkJob->LimitFeed)   // for feed job
                   Value = WorkJob->LimitFeed;
//sysprintf("Value = %d\n", Value); // ch_20220218
               if (Value < PaperJamLength)
                   Value = PaperJamLength;
//sysprintf("Value = %d\n", Value); // ch_20220218
               Value += PAPER_ERROR_OFFSET;
//sysprintf("Value = %d\n", Value); // ch_20220218
               SetPositionState(TO_POSITION); //设置位置状态
           }
           else                                                       // continue mode
           {
           sysprintf("SP..3\n");
               Value = (WORD)WorkJob->fLabelSize + ContinuousGap;
//sysprintf("Value = %d\n", Value); // ch_20220218
               SetPositionState(DO_NOT_NEED);
           }

           if (OverHead > (WORD)WorkJob->fLabelSize)
           {
           sysprintf("SP..4\n");
               MJob->State = JOB_WAIT;
               PrtJobSeq = SEQ_FINISHED;
               break;
           }

//sysprintf("Value %d - OverHead %d = %d\n", Value, OverHead, Value - OverHead); // ch_20220218
//sysprintf("\nFeed\t%d\t", Value - OverHead); // ch_20220218
//OverHead = 200; // ch_20220218
           MaxLimitFeed = Value - OverHead; // ch_20220627 : Value is greater than WorkJob->LimitFeed sometimes.
   sysprintf("MovL...7\n");     //pc下发打印中间（正向走纸一会）进来执行1次
           MoveLabel(WorkJob, MOTOR_FORWARD, Value - OverHead, TRUE);

#if defined(TTP2410M_MACH) || defined(TTP286M_MACH)
           Continuously = TRUE;
           if (WorkJob->ReprintKey && WorkJob->Type == PRINT_JOB)
               Continuously = FALSE;
           else if (WorkJob->PrintKey && PrintKeyCnt == 0 && WorkJob->Type == PRINT_JOB)
               Continuously = FALSE;
           else if (WorkJob->PrintOutMode == CUTTER_MODE && (CutCnt + 1) >= WorkJob->CutterPieces)
               Continuously = FALSE;
           else if (WorkJob->PrintOutMode == PEEL_MODE)
               Continuously = FALSE;
           else if (GetOverHead() != 0)
               Continuously = FALSE;

           Value = GetOffsetDis(WorkJob);
           SetDeceleration((INT)WorkJob->fLabelSize, Value, WorkJob->Ribbon, Continuously);
           Value = WorkJob->Quantity ? WorkJob->Quantity - 1 : 0;
           SetJobRemainStep((INT)WorkJob->fLabelSize * Value, WorkJob->Ribbon);
#endif
           if (!WorkJob->Reprint && WorkJob->Quantity) // Feed paper... （//Click a key ,）
           {
           sysprintf("SP..5\n");
               if (!(WorkJob->ReprintKey && WorkJob->Type == PRINT_JOB))
                   WorkJob->Quantity -= 1;

//sysprintf("Q%d\t", WorkJob->Quantity); // ch_20220323
           }
           if (WorkJob->PrintOutMode == PEEL_MODE)
               PeelState = PeelLabel();

           PrtJobSeq = SEQ_PRINTING;
       }
       case SEQ_PRINTING:
       {
           if (Print && WorkJob->Type == PRINT_JOB)
           {
           INT nows=NowSpeed();
               if(nows>=WorkJob->Speed) {
sysprintf("SeqP..1\n"); //先执行SeqP..2一会再进来执行
                   ///
                   // ch_20220712
//                   CalculateHeatTime(WorkJob->Speed, WorkJob->Density, TPHTemp);
                   if (((WORD)pJobCfg->fDensity) < 13) { // ch_20220816
                       sysprintf("SeqP..1-1\n"); //先执行SeqP..2一会再进来执行
                       if (CurrTempLevel > InitialTempLevel)
                           FinalTempLevel = TPHTemp+CurrTempLevel-InitialTempLevel;
                       else if (CurrTempLevel < InitialTempLevel)
                           FinalTempLevel = TPHTemp-(InitialTempLevel-CurrTempLevel);
                       else
                           FinalTempLevel = TPHTemp;
                   }

                   // ch_20220816
                   else if (((WORD)pJobCfg->fDensity) < 15){
                   sysprintf("SeqP..1-2\n");
                       if (CurrTempLevel > InitialTempLevel+2)
                           FinalTempLevel = TPHTemp+((CurrTempLevel-InitialTempLevel)<<(((WORD)pJobCfg->fDensity)-10));
                       else if (CurrTempLevel+2 < InitialTempLevel)
                           FinalTempLevel = TPHTemp-(InitialTempLevel-CurrTempLevel);
                       else
//                           FinalTempLevel = TPHTemp;
                           FinalTempLevel = TPHTemp+(2<<(((WORD)pJobCfg->fDensity)-10));
                   }
                   else { // --> 15
                   sysprintf("SeqP..1-3\n");
                       if (CurrTempLevel > InitialTempLevel+2)
                           FinalTempLevel = TPHTemp+((CurrTempLevel-InitialTempLevel)<<(((WORD)pJobCfg->fDensity)-10));
                       else if (CurrTempLevel+2 < InitialTempLevel)
                           FinalTempLevel = TPHTemp-(InitialTempLevel-CurrTempLevel);
                       else
//                           FinalTempLevel = TPHTemp;
                           FinalTempLevel = TPHTemp+(2<<(((WORD)pJobCfg->fDensity)-10));
                   }

                   CalculateHeatTime(WorkJob->Speed, WorkJob->Density, FinalTempLevel); //再次计算加热时间
                   ///
               }
           else {
           sysprintf("SeqP..2\n"); //PC execute   -1
//sysprintf("X\n"); // ch_20220701

                   // ch_20220816
//                   CalculateHeatTime(WorkJob->Speed, (WorkJob->Speed-nows)+WorkJob->Density>15?15:(WorkJob->Speed-nows)+WorkJob->Density, TPHTemp/4);
                   if (((WORD)pJobCfg->fDensity) < 13) { // ch_20220816
//                   sysprintf("SeqP..2-1\n");   //PC execute   -2
                       if (CurrTempLevel > InitialTempLevel)
                           FinalTempLevel = TPHTemp+CurrTempLevel-InitialTempLevel;
                       else if (CurrTempLevel < InitialTempLevel)
                           FinalTempLevel = TPHTemp-(InitialTempLevel-CurrTempLevel);
                       else
                           FinalTempLevel = TPHTemp;
                   }
                   else if (((WORD)pJobCfg->fDensity) < 15){
                   sysprintf("SeqP..2-2\n");
                       if (CurrTempLevel > InitialTempLevel+2)
                           FinalTempLevel = TPHTemp+((CurrTempLevel-InitialTempLevel)<<(((WORD)pJobCfg->fDensity)-10));
                       else if (CurrTempLevel+2 < InitialTempLevel)
                           FinalTempLevel = TPHTemp-(InitialTempLevel-CurrTempLevel);
                       else
                           FinalTempLevel = TPHTemp+(2<<(((WORD)pJobCfg->fDensity)-10));
                   }
                   else {
                   sysprintf("SeqP..2-3\n");
                       if (CurrTempLevel > InitialTempLevel+2)
                           FinalTempLevel = TPHTemp+((CurrTempLevel-InitialTempLevel)<<(((WORD)pJobCfg->fDensity)-10));
                       else if (CurrTempLevel+2 < InitialTempLevel)
                           FinalTempLevel = TPHTemp-(InitialTempLevel-CurrTempLevel);
                       else
                           FinalTempLevel = TPHTemp+(2<<(((WORD)pJobCfg->fDensity)-10));
                   }
                   CalculateHeatTime(WorkJob->Speed, WorkJob->Density, FinalTempLevel);

               }

               PrintTPHLine(NowSpeed(), WorkJob->Density); //打印一点行数据
           }
           ///
           // ch_20220527
//           else if (GetCarriageOpenOrClose()&&(FEED_JOB == WorkJob->Type)) {
           else if (FEED_JOB == WorkJob->Type) {
sysprintf("SeqP..3\n");               // click key

               if (++FeedStepCnt > MaxLimitFeed) { // ch_20220627
//sysprintf("Feed too much!\n");
//                   RstCarriageOpenOrCloseFlg();
                   FeedStepCnt = 0;
                   ModifyMotorStep(1);

                   MJob->State = JOB_DELETE; // ch_20220604
                   break; // ch_20220604
               }
           }
           ///

//{
//sysprintf("n\t"); // ch_20220312
//}
           TPHTempStep++;
           if(TPHTempStep%3==1)
           {
           sysprintf("SeqP..4\n"); //PC execute   -3 ,click key
       StartADConvert(TPH_TEMP_AD);
}
else if(TPHTempStep%3==2)
{
Value = ReadAD(TPH_TEMP_AD);
sysprintf("SeqP..5\n"); //PC execute -5 ,click key
               if (Value > MAX_AD_VAL) Value = MAX_AD_VAL; // ch_20220712
               if (Value < MIN_AD_VAL) Value = MIN_AD_VAL; // ch_20220712

TPHTemp = CalculateTPHTempLevel(Value);
TPHTempStep = 0;
}
else if(TPHTempStep>=3)
TPHTempStep = 0;

           // if motor stop or print end line
           MotorStatus = GetMotorStatus();
           if ((OverPrintLine() && WorkJob->Type == PRINT_JOB)
               || (MotorStatus == STATUS_MOTOR_WILL_STOP)
               || (MotorStatus == STATUS_MOTOR_STOP)
               || (MotorStatus == STATUS_MOTOR_IDLE))
           {
           sysprintf("SeqP..6\n");   //PC execute -8 , click key
               if (WorkJob->Reprint && WorkJob->Quantity)
                   if (!(WorkJob->ReprintKey && WorkJob->Type == PRINT_JOB))
                       WorkJob->Quantity -= 1;

// ///

               PrtJobSeq = SEQ_FORM_FEED;
           }
           else
           {
           sysprintf("SeqP..7\n"); //PC execute   -4 , click key
               break;
           }
       }
       case SEQ_FORM_FEED: //PC下发打印循环执行SEQ_PRINTING一段时间后进来循环执行
       {
           MotorStatus = GetMotorStatus();
//sysprintf("%d\t", MotorStatus); // ch_20220314
           //如果电机状态为STATUS_MOTOR_FORWARD或STATUS_MOTOR_BACKWARD，表示电机正在前进或后退，此时跳出switch语句
           if (MotorStatus == STATUS_MOTOR_FORWARD || MotorStatus == STATUS_MOTOR_BACKWARD) //
               break;

           SetPositionState(DO_NOT_NEED); //设置位置状态为DO_NOT_NEED

#if defined(TTP2410M_MACH) || defined(TTP286M_MACH)
           if (WorkJob->Verifier && WorkJob->Type == PRINT_JOB) //如果当前工作任务的Verifier字段为真且任务类型为PRINT_JOB，那么会调用VerifyProcess函数进行验证处理。
           {
               if (VerifyProcess(WorkJob))
                   break;
           }
#endif

           if (WorkJob->PrintOutMode == CUTTER_MODE) //代码根据打印模式进行不同的处理。如果打印模式为CUTTER_MODE（切割模式），代码会增加CutCnt计数
           {
               CutCnt++;
               if (CutCnt >= WorkJob->CutterPieces) //判断是否达到了切割次数
               {
                   CutCnt = 0;
                   PrtJobSeq = SEQ_PRESENT; //设置PrtJobSeq为SEQ_PRESENT

                   // fabric cutter mode
                   if (IsFabricCutter()) //根据是否为切割模式调用FabricCutLabel函数进行处理
                   {
                           FabricCutLabel(WorkJob);
                       //如果当前作业状态不是JOB_PAUSE或JOB_CANCEL，且剩余数量不为零，则设置PrtJobSeq为SEQ_INIT。
                       if (MJob->State != JOB_PAUSE && MJob->State != JOB_CANCEL)
                       {
                           if (WorkJob->Quantity)
                               PrtJobSeq = SEQ_INIT;
                           else //否则，将作业状态设置为JOB_WAIT，并设置PrtJobSeq为SEQ_FINISHED。
                               MJob->State = JOB_WAIT;
                       }
                   }
               }
               // if have next paper need to print
               else if (WorkJob->Quantity && MJob->State != JOB_CANCEL)
               {
                   PrtJobSeq = SEQ_INIT;
               }
               else
               {
                   MJob->State = JOB_WAIT;
                   PrtJobSeq = SEQ_FINISHED;
               }
           }
           // peel mode
           else if (WorkJob->PrintOutMode == PEEL_MODE) //如果打印模式为PEEL_MODE（剥离模式），则将PrtJobSeq设置为SEQ_PRESENT。
           {
               PrtJobSeq = SEQ_PRESENT;
           }
           // other mode ( tear or off mode ) // 如果打印模式为其他模式（撕裂或关闭模式），则根据作业状态和其他条件进行判断。
           else
           {
//       sysprintf("SFF..3\n"); //PC Execute ,click key
               if (MJob->State == JOB_PAUSE || MJob->State == JOB_CANCEL) //如果当前作业状态为JOB_PAUSE或JOB_CANCEL，则将PrtJobSeq设置为SEQ_PRESENT
               {
                   PrtJobSeq = SEQ_PRESENT;
               }
#if defined(TTP2410M_MACH) || defined(TTP286M_MACH)
               else if (WorkJob->ReprintKey && WorkJob->Type == PRINT_JOB) //如果WorkJob的ReprintKey字段为真且任务类型为PRINT_JOB，则将PrtJobSeq设置为SEQ_PRESENT
               {
                   PrtJobSeq = SEQ_PRESENT;
               }
#endif //如果WorkJob的PrintKey字段为真且PrintKeyCnt为0且任务类型为PRINT_JOB，则将PrtJobSeq设置为SEQ_PRESENT
               else if (WorkJob->PrintKey && PrintKeyCnt == 0 && WorkJob->Type == PRINT_JOB) //
               {
                   PrtJobSeq = SEQ_PRESENT;
               }
               // if have next paper need to print
               else if (WorkJob->Quantity) //如果剩余数量不为零，则将PrtJobSeq设置为SEQ_INIT。
               {
//sysprintf("re-i\t%d\t", GetMotorCounter()); // ch_20220311
                   PrtJobSeq = SEQ_INIT;
               }
               else //否则，根据打印模式进行进一步处理
               {
//       sysprintf("SFF..3-4\n"); //PC Execute , click key
                   if (WorkJob->PrintOutMode == OFF_MODE) //如果为OFF_MODE，
                   {
                       ClrDelayTime(WaitTimeNum); //则清除延迟时间和等待时间编号
                       WaitTimeNum = DELAY_TIME_NULL;
                   }
                   MJob->State = JOB_WAIT; //然后将作业状态设置为JOB_WAIT，最后将PrtJobSeq设置为SEQ_WAIT_NEW_JOB。
                   PrtJobSeq = SEQ_WAIT_NEW_JOB;
               }
           }
           break;
       }
       case SEQ_CUTTER_INIT:
       {
           MotorStatus = GetMotorStatus();
           if (MotorStatus != STATUS_MOTOR_STOP && MotorStatus != STATUS_MOTOR_IDLE)
               break;

           if (CheckDelayTimer(CutWaitNum))
               break;
           ClrDelayTime(CutWaitNum);
           CutWaitNum = DELAY_TIME_NULL;

MJob->Monitor = MONITOR_CUTTING;

           TakeState = _NULL;
           if (IsLinerless())   // Linerless mode needed to take label
               TakeState = TakeLabel();

// 225 partial cutter is backward direction
{

#if defined(TDP225) || defined(TTP225) || defined(TTP323)
               BOOL CutDir = WorkJob->CutterBack ? CUT_DIR_FORWARD : CUT_DIR_BACKWARD;
#else
               BOOL CutDir = CUT_DIR_FORWARD;
#endif
               CutterState = CutterApplication(CutDir);
           }
           PrtJobSeq = SEQ_CUTTING;
           break;
       }
       case SEQ_CUTTING:
       {
#if defined(LCD_MODEL)
           if (TakeState && *TakeState == TAKE_LABEL_WAITING)
               SetDisplayStatus(DIS_TAKE_LABEL);
#endif

if (*CutterState == CUTTER_CUTTING)
break;

           if (*CutterState == CUTTER_ERROR)
           {
               MJob->ErrState |= ERROR_CUTTER;
               break;
           }

           if (TakeState && *TakeState != TAKE_LABEL_FINISHED)
           {
               MJob->Monitor = MONITOR_TAKE_LABEL;
               break;
           }

#if defined(LCD_MODEL)
           ClrDisplayStatus(DIS_TAKE_LABEL);
#endif
           if (WorkJob->CutterBack && !WorkJob->SuppressBack && !BackBeforePrinting)
           {
               if (RetractPresented(WorkJob)) //用于处理打印机的纸张位置调整操作
                   MJob->Monitor = MONITOR_RETRACT;
           }
           ReprintStatus = FALSE;
           PrtJobSeq = SEQ_END;
           break;
       }
       case SEQ_PEEL_INIT:
       {
           MotorStatus = GetMotorStatus();
           if (MotorStatus != STATUS_MOTOR_STOP && MotorStatus != STATUS_MOTOR_IDLE)
               break;

           MJob->Monitor = MONITOR_TAKE_LABEL;
           PrtJobSeq = SEQ_PEEL_ACTION;
           break;
       }
       case SEQ_PEEL_ACTION:
       {
#if defined(LCD_MODEL)
           if (*PeelState == PEEL_STATE_WAIT_TO_TAKE_LABEL)
               SetDisplayStatus(DIS_TAKE_LABEL);
#endif
           if (*PeelState != PEEL_STATE_IDLE)
               break;

           if (!WorkJob->SuppressBack)
           {
               if (RetractPresented(WorkJob)) //用于处理打印机的纸张位置调整操作
                   MJob->Monitor = MONITOR_RETRACT;
           }

#if defined(LCD_MODEL)
           ClrDisplayStatus(DIS_TAKE_LABEL);
#endif
           ReprintStatus = FALSE;
           PrtJobSeq = SEQ_END;
           break;
       }
       case SEQ_WAIT_NEW_JOB:
       {
//       sysprintf("1a10..\n"); //PC打印最后一张或只打印一张时最后会进来执行
           if (CheckDelayTimer(WaitTimeNum))
           {
               MJob->Monitor = MONITOR_IMAGING;
               break;
           }
           ClrDelayTime(WaitTimeNum);
           WaitTimeNum = DELAY_TIME_NULL;

           PrtJobSeq = SEQ_PRESENT;
       }
       case SEQ_PRESENT:
       {
//       sysprintf("1a11..\n"); PC打印最后一张或只打印一张时最后会进来执行
           MotorStatus = GetMotorStatus();
           if (MotorStatus == STATUS_MOTOR_FORWARD || MotorStatus == STATUS_MOTOR_BACKWARD)
               break;

           if (WorkJob->PrintOutMode != OFF_MODE)
           {
               if (LabelPresent(WorkJob)) //调用LabelPresent函数判断标签是否处于就绪状态（已经被送至打印位置）
                   MJob->Monitor = MONITOR_FORM_FEED;
           }

           if (WorkJob->PrintOutMode == CUTTER_MODE)
           {
               FabricCutterCancel();
               ClrDelayTime(CutWaitNum);
               CutWaitNum = SetDelayTime(CutWaitTime);

               if (MJob->State == JOB_WAIT)
                   MJob->State = JOB_PRINTING;
               PrtJobSeq = SEQ_CUTTER_INIT;
           }
           else if (WorkJob->PrintOutMode == PEEL_MODE)
           { //如果打印输出模式是PEEL_MODE（剥离模式），则将PrtJobSeq设置为SEQ_PEEL_INIT，表示进入剥离模式的初始化阶段
               PrtJobSeq = SEQ_PEEL_INIT;
           }
           else
           {
               ReprintStatus = FALSE;
               PrtJobSeq = SEQ_END;
           }
           break;
       }
       case SEQ_END:
       {
   //       sysprintf("1a12..\n"); //PC下发打印执行完1次SEQ_PRESENT之后循环进来执行一段时间
           MotorStatus = GetMotorStatus();
           if (MotorStatus != STATUS_MOTOR_STOP && MotorStatus != STATUS_MOTOR_IDLE)
               break;

#if defined(TTP2410M_MACH) || defined(TTP286M_MACH)
           if (WorkJob->ReprintKey && WorkJob->Type == PRINT_JOB)
           {
               INT status = ReprintKeyProcess(MJob->State == JOB_CANCEL, WorkJob->ReprintKeyCnt, ReprintKeyCnt);

               if (status == 0)
               {
                   MJob->Monitor = MONITOR_PRESS_KEY;
                   break;
               }
               else if (status == 1)   // press SELECT key
               {
                   ReprintStatus = TRUE;
                   ReprintKeyCnt += 1;
               }
               else if (status == 2)   // press DOWN key
                   WorkJob->Quantity -= 1;
           }
#endif
           PrtJobSeq = SEQ_FINISHED;
           if (WorkJob->Quantity)   // if have next paper need to print
               PrtJobSeq = SEQ_INIT;
           if (MJob->State == JOB_CANCEL || WorkJob->Type == CAL_JOB)
               PrtJobSeq = SEQ_FINISHED;
           if (PrtJobSeq == SEQ_FINISHED)
               ReprintKeyCnt = 0;
           break;
       }
       case SEQ_FINISHED:
       {
           // ch_20220605
//       sysprintf("1a13..\n"); //PC下发打印循环执行1段时间SEQ_END之后循环进来执行直到结束
           MotorStatus = GetMotorStatus();
           if (MotorStatus != STATUS_MOTOR_IDLE)
               break;

SetTPHPower(FALSE); //关闭打印头电源

           MJob->State = JOB_FINISHED; //
           MJob->Monitor = MONITOR_IDLE;
           PrtJobSeq = SEQ_NULL;

SetPrintRemain(WorkJob->DspTotal, WorkJob->DspBase + WorkJob->Quantity);

#if defined(LCD_MODEL)
           ClrDisplayStatus(DIS_PRINT_REMAIN);
#endif
           break;
       }
       case SEQ_NULL:
       default:
       {
           PrtJobSeq = SEQ_NULL;
           break;
       }
   }
}

/*MotionJobProcess函数:它接受一个_MotionJob结构体指针作为参数。该函数的主要作用是处理运动作业。

1 开头定义：函数开始部分定义了一些局部变量，包括MotorSataus（电机状态）、SensorPos（传感器位置）、iTemp1、u8Times等等。其中，MotorSataus用于表示电机状态，Print表示是否进行打印操作。

2 在获取定标状态之后，通过PeriodTimes计数器进行周期性的处理。如果作业状态为JOB_NULL，表示作业未开始，直接返回；如果作业状态为JOB_ERROR，表示作业出错，停止电机并返回。

3 根据周期计数器的值判断是否需要处理电机状态和打印操作。通过MotorProcess函数处理电机状态，通过MotionCallback函数回调处理其他相关操作。

在打印操作部分，首先更新打印点数，并进行一些特定操作，如检查色带错误（根据预定义的宏RIBBON_MODEL），检查传感器位置等。然后根据传感器位置进行一系列操作，
如回忆传感器位置、忽略太小的标签、调整间距线位置、检查标签长度等。

最后，通过FabricCutterProcess函数处理裁切操作，通过WorkJobProcess函数处理工作作业。

整体而言，该函数通过周期性地检查电机状态和处理打印操作，实现了运动作业的处理逻辑 */

//PC下发打印过程循环执行单击按键循环进来执行双击定标也循环进来执行
STATIC VOID MotionJobProcess(_MotionJob *MJob) //<- MotionISR(VOID) //PC下发打印时循环执行
{
   STATIC BOOL MotorSataus = FALSE; // 1 开头定义
//   STATIC INT PreSensorPos = POSITION_UNKNOW; // ch_20220314
   BOOL Print = FALSE;

   INT SensorPos;
   INT iTemp1 = 0; // ch_20220314
   STATIC UCHAR u8Times = 0; // ch_20220320
   INT sTemp1 = 0, sTemp2 = 0; // ch_20220314
   _WorkJob *WorkJob = &MJob->WorkJob;
   _CalResult *pCalResult = NULL;

       2
//sysprintf("MotionJobPr\n "); // ch_20220608
   if (GetCalibratedStat()) // 先获取定标状态，为真表示定标过
       pCalResult = GetCalResult();
   else
       pCalResult = GrabCalResult(); //未定标

   PeriodTimes++;

   // job doesn't start
   if (MJob->State == JOB_NULL) //作业未开始，直接返回
       return;

   if (MJob->State == JOB_ERROR) //作业出错，停止电机并返回
   {
       PreSensorPos = POSITION_UNKNOW;
       StopMotor();

       return;
   }
/
//sysprintf("123...\n ")   ;
   if (PeriodTimes % MOTOR_TIMES == 0) //周期计数器
       MotorSataus = MotorProcess(); //处理电机状态

   if (PeriodTimes % PRINT_TIMES == 0)
   {
   static INT SensorPos_bak;
       if (MotorSataus)
       {
           if (MotionCallback)         //回调函数处理其他操作
               MotionCallback();
           pEngRec->DotMilage += 1; //更新打印点数

#if defined(RIBBON_MODEL)
       if (pEngCfg->RibbonFlag) // ch_20220714 检查色带错误
           CheckRibbonError(MJob);
#endif
           SensorPos = CheckSensorPosition(MJob); //检查传感器位置
           if ( SensorPos !=SensorPos_bak )
           {
           SensorPos_bak = SensorPos;
//           debug_printf("s%d\r\n",SensorPos);
//sysprintf("\n%d,%d; ", PreSensorPos, SensorPos); // ch_20220221
           }
           SensorPos = RecallSensorPosition(MJob, SensorPos);       //
           SensorPos = IgnoreUndersize(MJob, SensorPos); //忽略太小的标签
           GapBlinePosition(MJob, SensorPos, PreSensorPos); //调整间距线位置
           CheckLabelLength(MJob, SensorPos, PreSensorPos);   //检查标签长度
           PreSensorPos = SensorPos;
//           //

           if (CheckPaperError(MJob, SensorPos))
               PreSensorPos = POSITION_UNKNOW;

           Print = TRUE;
       }
// ch_20220316
//else
//   sysprintf("F\n");
   }

FabricCutterProcess(MJob);
WorkJobProcess(MJob, Print);
}

VOID MotionHandler(VOID)//<-EnableMotion(VOID)
{
#if defined(AT91SAM9260)

#if defined(TTP245P_PCB)
   UINT status = AT91C_BASE_TC5->TC_SR;
   UINT mask = AT91C_BASE_TC5->TC_IMR;
#elif defined(T045_PCB) ||defined(T40_PCB)
   UINT status = AT91C_BASE_TC2->TC_SR;
   UINT mask = AT91C_BASE_TC2->TC_IMR;
#endif
   UINT interrupt = status & mask;
   if (interrupt & AT91C_TC_CPAS)
       MotorCtrlISR();
   if (interrupt & AT91C_TC_CPCS)
       MotionISR();
#elif defined(N3290)
   if (inpw(REG_TISR) & 0x00000002)
   {
       outpw(REG_TISR, 0x02);
       MotionISR();
   }
#endif

}
///
//运动中断函数
/* 1 从打印配置中减少编码器计数（如果设置了）。
2 清除运动状态和关闭看门狗（watchdog）。
3 获取下一个运动中断的时间，并设置运动时间。
4 如果定义了MOTOR_CTRL_TIME宏，根据速度时间检查电机电流是否下降，并启用电机控制中断。
5 处理打印任务的事件，并进行相关的运动作业处理。

根据条件编译的注释，代码中存在两个分支：
#if 1 分支：根据获取到的运动中断时间和打印任务的事件，进行运动作业的处理。
#else 分支：固定设置运动时间为10000，并设置电机电流和电机相位。
具体的运动作业处理和打印任务事件处理逻辑需要进一步了解MotionJobProcess和JobEventHand函数的实现 */
/
VOID MotionISR(VOID) //<-MotionHandler(VOID)
{
_MotionJob *MJob;
WORD SpeedTime;

_PrintCfg *CalCfg = GrabPrintConfig(); //抓取打印配置
if(CalCfg->my_encode_count) CalCfg->my_encode_count--;

CLEAR_MOTION_STATUS;
CLOSE_WATCH_DOG;

#if 1
   // get motion isr next time
   SpeedTime = GetSpeedTime(); //获取下一个运动中断时间
   MOTION_TIME(SpeedTime); //设置运动时间
   MOTION_TIME_CLEAR(); // ch_20220616

#if defined(MOTOR_CTRL_TIME)
   if (MOTOR_CTRL_TIME(CheckMotorCurrentDown(SpeedTime)))
       ENABLE_MOTOR_CTRL_ISR;
#endif

MJob = JobEventHand();

   MotionJobProcess(MJob);
#else
   MOTION_TIME(10000);
   SetStepMotorCurrent(CURRENT_100);
   MotorPhaseChange(MOTOR_FORWARD);
#endif
}

PrtEng.h 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

#ifndef PRTENG_H

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

#define PRTENG_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 */

#include "XImgMgr.h"
#include "XSensor.h"
#include "XRibbon.h"
#include "XPeel.h"
#include "XCutter.h"
#include "XTPH.h"
#include "XMotor.h"
#include "XCarriage.h"

#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(CPU_144MHZ_MODE)
#define MOTION_DIV 48UL
#else
#define MOTION_DIV 64UL
#endif

#define CLOCK_TIME (PERIPHERAL_CLOCK / MOTION_DIV) //192000000/64 = 3000000

#if defined(TPH_DPI_200)
   #if defined(XP_H500B_MACH) ||defined(DELUXE_2045_MACH)

   #define DT_ADD_PERCENT           1010   // x / 1000
   #define TT_ADD_PERCENT           1005   // x / 1000
//   #define TPH_GAP_DIS               514//503//499//(62.8*8) //62.8*8 出来多了减法 // ch_20220309 : changed to 504.
//   #define TPH_BLINE_DIS           208//200//208//208//(26*8)//208 //26*8
//   #define TPH_CUT_DIS               313
//   #define TPH_PEEL_DIS           104
//   #define TPH_TEAR_DIS           232//232-(1*8)//232//(29*8)//232 //29*8
//   #define FORWARD_SLACK           6//10//12
//   #define BACKWARD_SLACK           4//12//6//4//12 // ch_20220308 : changed to 4 from 12 to try to solve up-down-offset.
//   #define TPH_GAP_DIS_MIS           0

   #define TPH_GAP_DIS               510//502 //62.8*8 出来多了减法
   #define TPH_BLINE_DIS           208 //26*8
   #define TPH_CUT_DIS               313
   #define TPH_PEEL_DIS           104
   #define TPH_TEAR_DIS           232//+(2*8) //29*8 // ch_20220707 : add (2*8) based on 2022/07/06 *5pcs pilot-run.
   #define FORWARD_SLACK           8//12//8//12 // ch_20220818 : changed to 8 // ch_20220726 : changed to 8 from 12.
   #define BACKWARD_SLACK           12//4//8//12 // ch_20220818 : changed to 12 to keep the same with FORWARD_SLACK // ch_20220726 : changed to 4 from 8.
   #define TPH_GAP_DIS_MIS           0

   #elif defined(XP_DT108B_LABEL_MACH)

   #define DT_ADD_PERCENT           1010   // x / 1000
   #define TT_ADD_PERCENT           1005   // x / 1000
   #define TPH_GAP_DIS               240 //487 出来多了减法
   #define TPH_BLINE_DIS           233 //196
   #define TPH_CUT_DIS               313
   #define TPH_PEEL_DIS           104
   #define TPH_TEAR_DIS           208 //256 262
   #define FORWARD_SLACK           12
   #define BACKWARD_SLACK           12
   #define TPH_GAP_DIS_MIS           0

   #elif defined(XP_H400B_MACH)
   #define DT_ADD_PERCENT           1010   // x / 1000
   #define TT_ADD_PERCENT           1005   // x / 1000
   #define TPH_GAP_DIS               548 //487 出来多了减法
   #define TPH_BLINE_DIS           233 //196
   #define TPH_CUT_DIS               313
   #define TPH_PEEL_DIS           104
   #define TPH_TEAR_DIS           267 //256 262
   #define FORWARD_SLACK           12
   #define BACKWARD_SLACK           12
   #define TPH_GAP_DIS_MIS           0

   #elif defined(XP_470B_MACH) ||defined(DELUXE_2044_MACH) \
   ||defined(XP_450B_MACH) || defined(XPDT425B_MACH)\
   ||defined(XP_460B_MACH) ||defined(XP_490B_MACH)

   #define DT_ADD_PERCENT           1010   // x / 1000
   #define TT_ADD_PERCENT           1005   // x / 1000
   #define TPH_GAP_DIS               239 //247//239
   #define TPH_BLINE_DIS           239
   #define TPH_CUT_DIS               343
   #define TPH_PEEL_DIS           144
   #define TPH_TEAR_DIS           212
   #define FORWARD_SLACK           8
   #define BACKWARD_SLACK           8
   #define TPH_GAP_DIS_MIS           0

#elif defined(XPDT427B_MACH)

#define DT_ADD_PERCENT           1010   // x / 1000
   #define TT_ADD_PERCENT           1005   // x / 1000
   #define TPH_GAP_DIS               133 //打印头到间隙传感器距离8*dis(ms)
   #define TPH_BLINE_DIS           133       //黑标
   #define TPH_CUT_DIS               82
   #define TPH_PEEL_DIS           82
   #define TPH_TEAR_DIS           82
   #define FORWARD_SLACK           8
   #define BACKWARD_SLACK           8
   #define TPH_GAP_DIS_MIS           0

   #elif defined(XPT424B_MACH)
   #define DT_ADD_PERCENT           1010   // x / 1000
   #define TT_ADD_PERCENT           1005   // x / 1000
   #define TPH_GAP_DIS               514 //247//239
   #define TPH_BLINE_DIS           514
   #define TPH_CUT_DIS               203
   #define TPH_PEEL_DIS           78
   #define TPH_TEAR_DIS           143 //154
   #define FORWARD_SLACK           8
   #define BACKWARD_SLACK           8
   #define TPH_GAP_DIS_MIS           0

#elif defined(XP300B_MACH)

   #define DT_ADD_PERCENT           1010
   #define TT_ADD_PERCENT           1005
   #define TPH_GAP_DIS               234
   #define TPH_BLINE_DIS           234
   #define TPH_CUT_DIS               203
   #define TPH_PEEL_DIS           78
   #define TPH_TEAR_DIS           116
   #define FORWARD_SLACK           8
   #define BACKWARD_SLACK           8
   #define TPH_GAP_DIS_MIS           0

#endif

#elif defined(TPH_DPI_300)

   #if defined(XP_H500E_MACH) || defined(DELUXE_3044_MACH)||defined(XP_H400E_MACH)

   #define DT_ADD_PERCENT           1010   // x / 1000
   #define TT_ADD_PERCENT           1005   // x / 1000
   #define TPH_GAP_DIS               808
   #define TPH_BLINE_DIS           344
           #define TPH_CUT_DIS               464
   #define TPH_PEEL_DIS           141
   #define TPH_TEAR_DIS           408
   #define FORWARD_SLACK           12
   #define BACKWARD_SLACK           12
   #define TPH_GAP_DIS_MIS           0

   #elif defined(XP_470B_MACH)
   #define DT_ADD_PERCENT           1010   // x / 1000
   #define TT_ADD_PERCENT           1005   // x / 1000
   #define TPH_GAP_DIS               341
   #define TPH_BLINE_DIS           341
   #define TPH_CUT_DIS               506
   #define TPH_PEEL_DIS           212
   #define TPH_TEAR_DIS           161
   #define FORWARD_SLACK           18
   #define BACKWARD_SLACK           18
   #define TPH_GAP_DIS_MIS           0

#endif

#define ERROR_TPH_OPEN           (1 << 0)
#define ERROR_PAPER_JAM           (1 << 1)
#define ERROR_PAPER_EMPTY       (1 << 2)
#define ERROR_RIBBON_JAM       (1 << 3)
#define ERROR_RIBBON_EMPTY       (1 << 4)
#define ERROR_CUTTER           (1 << 5)
#define ERROR_TPH_OVERHEAT       (1 << 6)
#define ERROR_MOTOR_OVERHEAT   (1 << 7)
#define ERROR_JOB_ALL_STATE       0x00FF

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

typedef enum
{
   DO_NOT_NEED,
   TO_POSITION,
   AVOID_SKIP_LABEL,
} _ePositionState;

typedef enum
{
   MOTOR_JOB,               // move motor job
   FEED_JOB,               // feed label job
   PRINT_JOB,               // print job
   CAL_JOB,               // calibration job
}_eJobType;

typedef enum
{
   JOB_NULL,               // 0
   // to set up 建立相关的状态
   JOB_NEW,               // 1
   JOB_LOCK,               // 2
   JOB_DELETE,               // 3
   // running 运行相关的状态
   JOB_PRINTING,           // 4
   JOB_PAUSE,               // 5
   JOB_CANCEL,               // 6
   // to wind up 停止相关的状态
   JOB_WAIT,               // 7
   JOB_FINISHED,           // 8
   JOB_ERROR,               // 9
}_eJobState;

typedef enum
{
   MONITOR_IDLE,           // 0
   MONITOR_PRESS_KEY,       // 1
   MONITOR_RETRACT,       // 2 回退
   MONITOR_PRINTING,       // 3
   MONITOR_FORM_FEED,       // 4表单送纸：一种控制字符，传统上用于使打印机弹出当前输出页面并开始新页面，最近等同于回车符。
   MONITOR_TAKE_LABEL,       // 5
   MONITOR_CUTTING,       // 6
   MONITOR_IMAGING,       // 7
   MONITOR_ERROR,           // 8
}_eJobMonitor;

typedef enum
{
   SEQ_NULL,               // 0
   SEQ_INIT,               // 1
   SEQ_TOP_OF_FORM,       // 2
   SEQ_INIT_PRINT,           // 3
   SEQ_PRINTING,           // 4
   SEQ_FORM_FEED,           // 5
   SEQ_PEEL_INIT,           // 6
   SEQ_PEEL_ACTION,       // 7
   SEQ_CUTTER_INIT,       // 8
   SEQ_CUTTING,           // 9
   SEQ_WAIT_NEW_JOB,       // 10
   SEQ_PRESENT,           // 11
   SEQ_END,               // 12
   SEQ_FINISHED,           // 13
}_ePrintJobSeq;

typedef enum
{
   OFF_MODE,
   TEAR_MODE,
   PEEL_MODE,
   CUTTER_MODE,
}_ePrintOutMode;

typedef enum
{
   GAP_MODE,
   BLINE_MODE,
   CONTINUE_MODE_T,
   CONTINUE_MODE_R,
   FEED_CONTINUE_MODE,
}_eSensorMode;

typedef struct
{
   _eSensorMode   SensorMode;
   BYTE           GapInten;
   BYTE           BlineInten;
   BYTE           ContinuousInten;
   WORD           GapRef;
   WORD           BlineRef;
   WORD           ContinuousRef;
   FLOAT           fPaperSize;
   FLOAT           fGapSize;
   FLOAT           fBlineSize;
   INT               PrePaper;
   INT               PreGapBline;
   BOOL           AutoDetectType;
   BOOL           Ribbon;
   BOOL           SetSize;
   BOOL           Finish;
   INT            UpFilterAvg;   // ch_20220719
   INT               DownFilterAvg;   // ch_20220719
}_CalResult;

typedef struct
{
_ImgBuf ImgBuf;

   _eJobType       Type;
   _eMotorDir       MotorDir;
   _eSensorMode   SensorMode;
   _ePrintOutMode   PrintOutMode;

   BYTE           GapInten;
   BYTE           BlineInten;
   BYTE           ContinuousInten;
   BYTE           RibbonInten;
   WORD           GapRef;
   WORD           BlineRef;
   WORD           ContinuousRef;
   WORD           RibbonRef;
   BOOL           AutoSensorRef;

   FLOAT           fLabelSize;
   FLOAT           fPaperSize;
   FLOAT           fGapSize;
   FLOAT           fGapOffset;
   FLOAT           fBlineSize;
   FLOAT           fBlineOffset;
   WORD           PrintLength;
   WORD           IgnoreSize;
   SHORT           ShiftDis;
   SHORT           OffsetDis;

   INT               CutterPieces;
   INT               PrintKeyCnt;
   INT               ReprintKeyCnt;
   BOOL           Direction;
   BOOL           Mirror;
   BOOL           Measure;
   BOOL           Calibrate;
   BOOL           Ribbon;
   BOOL           Reprint;
   BOOL           PrintKey;
   BOOL           ReprintKey;
   BOOL           Verifier;
   BOOL           CutterBack;
   BOOL           SuppressBack;
   WORD           Density;
   WORD           Speed;
   WORD           OverHeat;
   WORD           PrintHeat;
   WORD           MotorOverHeat;
   WORD           MotorMoveHeat;
   WORD           LimitFeed;

   BOOL           PrintFullImage; // 完整图像
   BOOL           PreventJumpPage; //预防跳页
   BOOL           AutoDetectType;
   INT               PrePaper; //预设纸张
   INT               PreGapBline;
   INT               DspTotal;
   INT               DspBase;

UINT BatchNumber;
ULONG Quantity;

XCALLBACK Callback;
}_WorkJob;

typedef struct
{
   _eJobState        State; //建立的状态，运行的状态，停止的状态
   _eJobMonitor   Monitor;
   _WorkJob       WorkJob;
   WORD           ErrState;
}_MotionJob;

/******************************************************************************
* *
* 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 *
* *
******************************************************************************/

//--- PrtEng ---//
VOID InitialPrintEngine(VOID);
VOID SetReprintKey(BOOL);
BOOL GetReprintStatus(VOID);
VOID SetWaitTime(WORD);
VOID ReloadWaitTime(VOID);
BOOL IsMotion(VOID);
VOID EnableMotion(VOID);
VOID DisableMotion(VOID);
XCALLBACK SetMotionCallback(XCALLBACK);
INT GetPrevPaperLen(VOID); // ch_20220318
SHORT GetPaperLength(VOID);
SHORT GetGapBmLength(VOID);
VOID MotionHandler(VOID);
VOID MotionISR(VOID);
VOID MotorCtrlISR(VOID);
INT GetPrintRemain(VOID);

//--- Verifier ---//
BOOL VerifyProcess(_WorkJob *);

//--- Calibration ---//
VOID InitialCalibration(VOID);
_CalResult *GrabCalibrationResult(VOID);
BOOL CalibrationProcess(_WorkJob *, BOOL);
BOOL GetCalibratedStat(VOID); // ch_20211216
VOID ResetCalibratedStat(BOOL status); // ch_20211216

//--- PosMgr ---//
VOID InitialPositionManager(VOID);
SHORT GetOffsetDis(_WorkJob *);
SHORT GetShiftDis(_WorkJob *);

SHORT GetHeadDis(_WorkJob *); // ch_20220219
//FLOAT GetHeadDis(_WorkJob *); // ch_20220219

WORD GetNextPaperDis(_WorkJob *);
VOID SetPositionState(_ePositionState);
VOID SetPositionData(SHORT,SHORT,SHORT,SHORT,SHORT);
VOID GapBlinePosition(_MotionJob *, INT, INT);
UCHAR GetFakePosOnPaper(VOID); // ch_20220313
VOID ResetFakePosOnPaper(VOID); // ch_20220313

//--- JobMgr ---//
VOID InitialJobManager(VOID);
VOID StartJobManager(VOID);
VOID StopJobManager(VOID);
BOOL CheckJobLock(VOID);
_MotionJob *GetActiveJob(VOID);
_eJobState GetJobState(VOID);
VOID SetJobState(_eJobState);
_eJobMonitor GetJobMonitor(VOID);
VOID SetJobMonitor(_eJobMonitor);
WORD GetJobErrorState(VOID);
VOID SetJobErrorState(WORD);
VOID ClrJobErrorState(WORD);
VOID WaitWorkJobEnd(VOID);
UINT QueueWorkJob(_WorkJob *);
_MotionJob *JobEventHand(VOID);
VOID CancelActiveJob(VOID);
INT GetRestJobStep(INT);

//--- JobErrMgr ---//
VOID JobErrorManager(_MotionJob *, _MotionJob *);
VOID SetErrorEvent(XCALLBACK);
VOID ErrorHeadSound(VOID);
VOID ErrorPaperSound(VOID);
VOID ErrorRibbonSound(VOID);

INT CheckSensorPosition(_MotionJob *);

VOID ClrFeedStepCnt(VOID); // ch_20220527

VOID ClrTempLevel(VOID); // ch_20220623

VOID SetAllowPaperErrTimes(UCHAR Times); // ch_20220721

UCHAR GetContinuousCalTimes(VOID); // ch_20220721

UCHAR GetPrevWorkType(VOID); // ch_20220726

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

#endif

Verifier.c 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

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

#define VERIFIER_C

#include <string.h>

#include "Common.h"
#include "XCore.h"
#include "XKey.h"
#include "XTimer.h"
#include "XTask.h"
#include "XVarBank.h"
#include "XDisplay.h"
#include "PrtEng.h"

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

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

#define VERIFIER_VALID               0
#define VERIFIER_DELETE_JOB           1
#define VERIFIER_RENOUNCE           2
#define VERIFIER_REPRINT           3

#define VERIFIER_FAIL (-1)

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

typedef struct
{
INT Result;
BOOL End;
}_Verify;

/* None */

STATIC _Verify Verify;

STATIC VOID VerifyProgram(_Verify *Verify)
{
   INT timenum = SetDelayTime(3000);   // sample time 3 sec
   INT length;
   BYTE content[128];
   BYTE data;

#if defined(CARRIAGE_OPEN_MODEL)
StopCheckCarriageOpen();
#endif

ClrDisplayStatus(DIS_READY);
delay_msec(20);

DspClearDisplay();
ShowLCDString(2, 1, "Verifying...", 0);

// clear receive buffer
while (UartRxDataOut(&data));

// trigger a read
UartChar(STX_CHAR);

   // filter prefix character
   while (CheckDelayTimer(timenum))
   {
       if (UartRxDataOut(&data))
       {
           if (data == STX_CHAR)
               break;
       }
   }

   // read verify the results
   length = 0;
   while (CheckDelayTimer(timenum))
   {
       if (UartRxDataOut(&data))
       {
           if (data == CR_CHAR || data == LF_CHAR)
               break;
           content[length++] = data;
       }
   }
   content[length] = '\0';

Verify->Result = VERIFIER_VALID;

   // if time out
   if (!CheckDelayTimer(timenum))
       Verify->Result = VERIFIER_FAIL;
   ClrDelayTime(timenum);

   // if fail to read
   if (length != 0 && content[0] == CAN_CHAR)
       Verify->Result = VERIFIER_FAIL;

   if (Verify->Result == VERIFIER_FAIL)
   {
       StopKeyFunc();
       GetKey(MENU_KEY);
       GetKey(PAUSE_KEY);
       GetKey(FEED_KEY);

       DspClearDisplay();
       ShowLCDString(0, 0, " Invalid Read ", 0);
       ShowLCDString(0, 1, "MENU: Delete Job", 0);
       ShowLCDString(0, 2, "PAUSE: Renounce", 0);
       ShowLCDString(0, 3, "FEED: Reprint", 0);

       while (1)
       {
           if (GetKey(MENU_KEY))
           {
               Verify->Result = VERIFIER_DELETE_JOB;
               break;
           }
           if (GetKey(PAUSE_KEY))
           {
               Verify->Result = VERIFIER_RENOUNCE;
               break;
           }
           if (GetKey(FEED_KEY))
           {
               Verify->Result = VERIFIER_REPRINT;
               break;
           }
           NutSleep(10);
       }

StartKeyFunc(TRUE);
}

SetDisplayStatus(DIS_READY);

#if defined(CARRIAGE_OPEN_MODEL)
StartCheckCarriageOpen();
#endif

Verify->End = TRUE;
}

STATIC TASK(ExecuteVerifier, arg)
{
VerifyProgram((_Verify *)arg);
TaskExit();
}

BOOL VerifyProcess(_WorkJob *WorkJob)
{
STATIC BOOL state = FALSE;

   if (state)
   {
       if (Verify.End)
       {
           switch (Verify.Result)
           {
               case VERIFIER_VALID:
                   break;
               case VERIFIER_DELETE_JOB:
                   CancelActiveJob();
                   break;
               case VERIFIER_RENOUNCE:
                   break;
               case VERIFIER_REPRINT:
                   WorkJob->Quantity += 1;
                   break;
           }
           state = FALSE;
       }
   }
   else
   {
       Verify.End = FALSE;
       TaskCreate(ExecuteVerifier, &Verify, TASK_VERIFY_STACK);
       state = TRUE;
   }

return state;
}

#endif

qq_33772147

关注

5
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
T168_111\system\PrtEng：第5~7

////////////////////////////////Value_标签大小。//////////////////////////////////////////////////////////////////////////////////////////////////// //pc下发打印循环进来执行单击按键也循环进来执行双击定标也循环进来执行。//////////////////////////////////////////// 打印头温度ADC值。//再次计算加热时间。
复制链接

扫一扫