T168_Backup\T168_111\appl\Function文件：Function.c

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

#define FUNCTION_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 "XLED.h"
#include "XKey.h"
#include "XTimer.h"
#include "XProFile.h"
#include "XDisplay.h"
#include "Function.h"

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

/* None */

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

/* None */

/******************************************************************************
 *                                                                            *
 *    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 BOOL MemoryFail;

STATIC VOID InsertDummyJob(VOID)
{
    _PrintCfg *pFuncCfg = GrabPrintConfig();
    if (GetJobState() == JOB_NULL)
        FeedBatch(0, pFuncCfg, TRUE, _NULL);
}

STATIC VOID ScanPeelSensorPauseJob(VOID)
{
    STATIC BOOL Pause = FALSE;
    STATIC WORD SensorNoise = 0;

    if (Pause)
    {
        if (!PeelSensorSignal())
            SensorNoise += 1;
        else
            SensorNoise = 0;

        if (SensorNoise >= (50 / PERIOD_TIMES))    // 50 ms
        {
            SensorNoise = 0;
            Pause = FALSE;
            PrinterStart();
        }
    }
    else
    {
        if (PeelSensorSignal())
            SensorNoise += 1;
        else
            SensorNoise = 0;

        if (SensorNoise >= (50 / PERIOD_TIMES))    // 50 ms
        {
            SensorNoise = 0;
            Pause = TRUE;
            PrinterPause();
        }
    }
}

VOID InitialFunction(VOID)
{
    FLOAT data;

    InitialFuncKey();

#if defined(PS2_MODEL) || defined(USB_HOST_MODEL)
    InitialFuncKB();
#endif

#if defined(GPIO_MODEL)
    InitialFuncIO();
#endif

#if defined(CARRIAGE_OPEN_MODEL)
    if (GetProfileInt("OPEN COVER MANUAL RECOVER", &data))
    {
        if ((BOOL)data == TRUE)
            SetCarriageOpenCallback(InsertDummyJob);
    }
#endif

    if (GetProfileInt("PEEL SENSOR PAUSE", &data))
    {
        if ((BOOL)data == TRUE)
            StartPeriodFunc(ScanPeelSensorPauseJob);
    }

    MemoryFail = FALSE;
}
#if defined(N3290)
STATIC UINT AppCheckSum=0;
STATIC UINT BootCheckSum=0;
UINT GetAppCheck(VOID)
{
        return AppCheckSum;
}
UINT GetCalculateCheck(VOID)
{
        UINT ret=0,i=0,Applen=128*1024+10,len=0,j=0,data=0;

        SPI_SwitchToFlash();
        outpw(REG_SPI0_SSR, inpw(REG_SPI0_SSR) | 0x01);    // CS0
        
        outpw(REG_SPI0_TX0, 03);
        spiTxLen(0, 0, 8);
        spiActive(0);

        outpw(REG_SPI0_TX0, 128*1024);
        spiTxLen(0, 0, 24);
        spiActive(0);

                spiTxLen(0, 0, 8);
        for(j=1,i=128*1024;i<Applen;i++)
        {
                outpb(REG_SPI0_TX0, 0xff);
                spiActive(0);
                data=inpb(REG_SPI0_RX0);
                ret+=data;
                if(i<128*1024+8&&i>=128*1024+4)
                {
                       len+=(data*j);
                       j<<=8;
                 }
                else if(i==128*1024+8)
                       Applen=len+8+128*1024;
        }
        return ret;
}
VOID CalculateCheckSumInit(VOID)
{
        UINT Bootlen=0x20,i=0,Applen=128*1024+10,j=0,data=0,chackmun=0;
        outpw(REG_SPI0_SSR, inpw(REG_SPI0_SSR) | 0x01);    // CS0
        
        outpw(REG_SPI0_TX0, 03);
        spiTxLen(0, 0, 8);
        spiActive(0);

        outpw(REG_SPI0_TX0, 0);
        spiTxLen(0, 0, 24);
        spiActive(0);

         spiTxLen(0, 0, 8);
        for(i=0;i<Bootlen;i++)
        {
               outpb(REG_SPI0_TX0, 0xff);
                spiActive(0);
                data=inpb(REG_SPI0_RX0);
                BootCheckSum+=data;
                if(i<12&&i>=8)
                       j+=(data<<((i-8)*8));
                else if(i==12)
                       Bootlen=j+0x38;
        }
    
    outpw(REG_SPI0_SSR, inpw(REG_SPI0_SSR) & 0xfe);    // CS0

    outpw(REG_SPI0_SSR, inpw(REG_SPI0_SSR) | 0x01);    // CS0
    outpw(REG_SPI0_TX0, 03);
        spiTxLen(0, 0, 8);
        spiActive(0);

        outpw(REG_SPI0_TX0, 128*1024);
        spiTxLen(0, 0, 24);
        spiActive(0);

         spiTxLen(0, 0, 8);
         for(j=1,i=128*1024;i<128*1024+4;i++,j<<=8)
         {
                outpb(REG_SPI0_TX0, 0xff);
                spiActive(0);
                data=inpb(REG_SPI0_RX0);
                chackmun+=data;
                AppCheckSum+=(data*j);
         }
         for ( ; i <128*1024+8 ; i++ )
         {
                outpb(REG_SPI0_TX0, 0xff);
                spiActive(0);
                chackmun+=inpb(REG_SPI0_RX0);
         }
         AppCheckSum+=chackmun;
         outpw(REG_SPI0_SSR, inpw(REG_SPI0_SSR) & 0xfe);    
}
#endif
DWORD CalculateCheckSum(VOID)
{
    DWORD CheckSum;
    INT i;

    CheckSum = 0;

#if defined(AT91SAM9260)
        
    for (i = 0; i < BOOT_CODE_LEN; i++)
        CheckSum += *((BYTE*)BOOT_CODE_AREA_ADDR + i);

    for (i = 0; i < APP_CODE_LEN; i++)
        CheckSum += *((BYTE*)APP_CODE_AREA_ADDR + i);
#elif defined(N3290)
    CheckSum=AppCheckSum+BootCheckSum;
#endif

    return CheckSum;
}

FLOAT CalculateLabelSize(_PrintCfg *PrtCfg)
{
    FLOAT fLabelSize;

    if (PrtCfg->SensorMode == GAP_MODE)
        fLabelSize = PrtCfg->fPaperSize + PrtCfg->fGapSize;
    else if (PrtCfg->SensorMode == BLINE_MODE)
        fLabelSize = PrtCfg->fPaperSize + PrtCfg->fBlineSize;
    else
        fLabelSize = PrtCfg->fPaperSize;

    return fLabelSize;
}

// ch_20220409
FLOAT CalLabelSizeWithCalRslt(_CalResult *CalRslt)
{
    FLOAT fLabelSize;

    if (CalRslt->SensorMode == GAP_MODE)
        fLabelSize = CalRslt->fPaperSize + CalRslt->fGapSize;
    else if (CalRslt->SensorMode == BLINE_MODE)
        fLabelSize = CalRslt->fPaperSize + CalRslt->fBlineSize;
    else
        fLabelSize = CalRslt->fPaperSize;

    return fLabelSize;
}

VOID ResetHeadPosition(VOID)
{
    _PrintCfg *pPosCfg = GrabPrintConfig();
    _WorkJob WorkJob;
//sysprintf("CogTJob...1\n");
    ConfigToWorkJob(&WorkJob, pPosCfg);
    pPosCfg->AdjustHead = GetShiftDis(&WorkJob);
    pPosCfg->OverHead   = 0;
}

VOID CutPaper(VOID)
{
    
    _PrintCfg *pCutCfg = GrabPrintConfig();
    _eCutterState *CutterState;
    BOOL Direction = CUT_DIR_FORWARD;

    WaitWorkJobEnd();

    SetJobMonitor(MONITOR_CUTTING);

#if defined(TDP225) || defined(TTP225) || defined(TTP323)
    Direction = pCutCfg->CutterBack ? CUT_DIR_FORWARD : CUT_DIR_BACKWARD;
#endif

    CutterState = CutterApplication(Direction);
    while (*CutterState == CUTTER_CUTTING)
        NutSleep(10);

    if (*CutterState == CUTTER_ERROR)
        CutterError();

    SetJobMonitor(MONITOR_IDLE);
}

VOID PrinterPause(VOID)
{
    INT imask = DisableInterrupt(INTERRUPT_MASK);
    _ePolyLEDStat LEDState = 0; // ch_20220608

    if (!GetJobErrorState())
    {
        StopJobManager();

#if defined(MONO_LED)
        StartPeriodFunc(FlashLED2);
#elif defined(POLY_LED)
        ///
        // ch_20220609
//sysprintf("P_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

#if defined(LCD_MODEL)
        SetDisplayStatus(DIS_PAUSE);
#endif
    }

    EnableInterrupt(imask);
}

VOID PrinterStart(VOID)
{
    INT imask = DisableInterrupt(INTERRUPT_MASK);

#ifdef DEBUG_PRNT
sysprintf("Enter PrinterStart...\n"); // ch_20211215
#endif

    StartJobManager();

#if defined(MONO_LED)
    CancelPeriodFunc(FlashLED2);
    ShowLED(HID_LED_IDLE, HID_LED_ON, HID_LED_IDLE);
#elif defined(POLY_LED)

    CancelPeriodFunc(FlashGreenLED);
    ResetPrevLEDStat(); // ch_20220609
    SetLEDStat(LED_ON_BLUE); // ch_20220609
    ShowLED(HID_LED_GREEN);
#endif
#if defined(LCD_MODEL)
    ClrDisplayStatus(DIS_PAUSE);
#endif

    EnableInterrupt(imask);
}

VOID PrinterReboot(VOID)
{
#ifdef DEBUG_PRNT
sysprintf("Enter PrinterReboot()...\n"); // ch_20211211
#endif

    DisableInterrupt(INTERRUPT_MASK);
    CloseStrongCurrent();
    SaveVarBank();
DelayTime(50000000); // ch_20220119    
    ProcessorReset();
}

VOID HexDumpMode(VOID)
{
    BOOL KeyFunc = StopKeyFunc();
    DumpText(NULL);
    StartKeyFunc(KeyFunc);
}

VOID ErasingFile(_eFileDevice device, CHAR *filename)
{

#if defined(LCD_MODEL)
    SetDisplayStatus(DIS_ERASING);
#endif

#if defined(MONO_LED)
    ShowLED(HID_LED_IDLE, HID_LED_IDLE, HID_LED_ON);
#elif defined(POLY_LED)
    ShowLED(HID_LED_ORANGE);
#endif

    DeleteFile(device, filename);

#if defined(MONO_LED)
    ShowLED(HID_LED_IDLE, HID_LED_IDLE, HID_LED_OFF);
#elif defined(POLY_LED)
    ShowLED(HID_LED_GREEN);
#endif

#if defined(LCD_MODEL)
    ClrDisplayStatus(DIS_ERASING);
#endif

}

VOID MemoryFailed(VOID)
{
    MemoryFail = TRUE;

#if defined(LCD_MODEL)
    SetDisplayStatus(DIS_OUT_OF_MEMORY);
#endif

    StopKeyFunc();

    while (!GetKey(FEED_KEY))
    {
#if defined(MONO_LED)
        CancelPeriodFunc(FlashLED2);
        ShowLED(HID_LED_IDLE, HID_LED_OFF, HID_LED_ON);
#elif defined(POLY_LED)
        CancelPeriodFunc(FlashGreenLED);
        ShowLED(HID_LED_RED);
#endif
    }

    StartKeyFunc(TRUE);

#if defined(MONO_LED)
    ShowLED(HID_LED_IDLE, HID_LED_ON, HID_LED_OFF);
#elif defined(POLY_LED)
    ShowLED(HID_LED_GREEN);
#endif

#if defined(LCD_MODEL)
    ClrDisplayStatus(DIS_OUT_OF_MEMORY);
#endif

    MemoryFail = FALSE;
}

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

BOOL IsMemoryFailed(VOID)
{
    return MemoryFail;
}

VOID SetSerialPort(LONG BaudRate, SHORT Data, CHAR Parity, SHORT Stop)
{
    _PrintCfg *pPortCfg = GrabPrintConfig();

    if (BaudRate == 1200)
        pPortCfg->UartSetting.Baud = UART_BAUD_1200;
    else if (BaudRate == 2400)
        pPortCfg->UartSetting.Baud = UART_BAUD_2400;
    else if (BaudRate == 4800)
        pPortCfg->UartSetting.Baud = UART_BAUD_4800;
    else if (BaudRate == 9600)
        pPortCfg->UartSetting.Baud = UART_BAUD_9600;
    else if (BaudRate == 19200)
        pPortCfg->UartSetting.Baud = UART_BAUD_19200;
    else if (BaudRate == 38400)
        pPortCfg->UartSetting.Baud = UART_BAUD_38400;
    else if (BaudRate == 57600)
        pPortCfg->UartSetting.Baud = UART_BAUD_57600;
    else if (BaudRate == 115200)
        pPortCfg->UartSetting.Baud = UART_BAUD_115200;

    if (Data == 7)
        pPortCfg->UartSetting.DataBits = UART_DATA_7;
    else if (Data == 8)
        pPortCfg->UartSetting.DataBits = UART_DATA_8;

    if (Parity == 'N')
        pPortCfg->UartSetting.Parity = UART_PARITY_NONE;
    else if (Parity == 'O')
        pPortCfg->UartSetting.Parity = UART_PARITY_ODD;
    else if (Parity == 'E')
        pPortCfg->UartSetting.Parity = UART_PARITY_EVEN;

    if (Stop == 1)
        pPortCfg->UartSetting.Stop = UART_STOP_ONE;
    else if (Stop == 2)
        pPortCfg->UartSetting.Stop = UART_STOP_TWO;

    UartSetting(pPortCfg->UartSetting);
}

ULONG GetNetworkIP(INT item)
{
#if defined(NUTNET)
    _PrintCfg *pNetCfg = GrabPrintConfig();

    ULONG ip_addr = pNetCfg->confnet.cdn_cip_addr;
    ULONG ip_mask = pNetCfg->confnet.cdn_ip_mask;
    ULONG gateway = pNetCfg->confnet.cdn_gateway;

    if ((ip_addr & ip_mask) == 0)    // Configuration from DHCP
        NetQueryIP(&ip_addr, &ip_mask, &gateway);

    if (item == ITEM_IP_ADDRESS)
        return ip_addr;
    if (item == ITEM_SUBNET_MASK)
        return ip_mask;
    if (item == ITEM_GATEWAY)
        return gateway;
#endif
    return 0L;
}

Function.h   /

#ifndef FUNCTION_H

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

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

#include "XPrtEng.h"
#include "XVarBank.h"
#include "FuncType.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                         *
 *                                                                            *
 ******************************************************************************/

/* None */

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

/* None */

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

//--- Function ---//
VOID InitialFunction(VOID);
DWORD CalculateCheckSum(VOID);
FLOAT CalculateLabelSize(_PrintCfg *);
FLOAT CalLabelSizeWithCalRslt(_CalResult *); // ch_20220409
VOID ResetHeadPosition(VOID);
VOID CutPaper(VOID);
VOID PrinterPause(VOID);
VOID PrinterStart(VOID);
VOID PrinterReboot(VOID);
VOID HexDumpMode(VOID);
VOID ErasingFile(_eFileDevice, CHAR *);
VOID MemoryFailed(VOID);
BOOL IsMemoryFailed(VOID);
VOID SetSerialPort(LONG, SHORT, CHAR, SHORT);
ULONG GetNetworkIP(INT);

//--- FuncJob ---//
VOID ConfigToWorkJob(_WorkJob *, _PrintCfg *);
UINT MotorMove(LONG, _PrintCfg *, _eMotorDir, XCALLBACK);
UINT FeedBatch(LONG, _PrintCfg *, BOOL, XCALLBACK);
UINT PrintBatch(UINT, LONG, _PrintCfg *, _ImgBuf *, BOOL, INT, INT, INT, XCALLBACK);
UINT Calibration(_PrintCfg *, BOOL, INT, INT);

//--- FuncMedia ---//
VOID PaperHome(_PrintCfg *);
BOOL DetectSensorInten(_PrintCfg *, BOOL, BOOL, INT, INT);
BOOL DetectGapInten(_PrintCfg *, BOOL);
BOOL DetectContinuousInten(_PrintCfg *);
BOOL DetectContinuousIntenBm(_PrintCfg *);
BOOL DetectLabelSize(_PrintCfg *, LONG, _ePrintOutMode);

//--- FuncKey ---//
VOID InitialFuncKey(VOID);
VOID KeyFuncSetting(INT, _KeySetting *);
VOID CheckPowerOnKey(VOID);

//--- FuncKB ---//
VOID InitialFuncKB(VOID);
VOID EntryInputKB(CHAR *, CHAR *, BOOL, INT);
VOID LeaveInputKB(VOID);

//--- FuncIO ---//
VOID InitialFuncIO(VOID);
VOID GPInFuncSetting(INT, _GPISetting *);
VOID GPOutFuncSetting(INT, _GPOSetting *);

VOID CalculateCheckSumInit(VOID);
VOID SPI_SwitchToFlash(VOID);
#ifdef __cplusplus
}                       /* End of extern "C" { */
#endif    /* __cplusplus */

#endif