T168_111\core 文件：第1~最后一个文件

最新推荐文章于 2024-07-21 13:38:21 发布

qq_33772147

最新推荐文章于 2024-07-21 13:38:21 发布

阅读量737

点赞数 13

文章标签：算法

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

版权

AppMain.c 。。。。。。。。。。。。。。。。。。。。。。。。。。。。

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

#define APPMAIN_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 <stdio.h>
#include <stdlib.h>
#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 "XLib.h"
#include "XLED.h"
#include "XKey.h"
#include "XADC.h"
#include "XRTC.h"
#include "XGPIO.h"
#include "XFlash.h"
#include "XBuzzer.h"
#include "XTimer.h"
#include "XTask.h"
#include "XSDCard.h"
#include "XDisplay.h"
#include "XKeyboard.h"
#include "XVarBank.h"
#include "XProFile.h"
#include "XFuseFlash.h"
#include "XPrtEng.h"
#include "XNutOS.h"
#include "XEthernet.h"
#include "XText.h"
#include "XImgMgr.h"
#include "XFunction.h"
#include "XParser.h"
#include "XAppVer.h"
#include "AppMain.h"
#include "XBt.h"
#include "XPrtEng.h"

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

#define FIRMWARE_START_ADDR FLASH_START_ADDR
#define UPDATE_LENGTH (FLASH_FILE_ADDR - FLASH_START_ADDR + 0x20000)

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

extern VOID InitailDuraLabel(VOID);

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

#if defined(NUTOS)
STATIC CHAR NutHeap[NUT_HEAP_SIZE];
#endif

ch_20211218
//STATIC UCHAR powerOnDone = 0;
//UCHAR PowerOnStatus(VOID)
//{
// return powerOnDone;
//}

extern UCHAR PowerOnStatus(VOID); // ch_20211220

// ch_20220411
STATIC UCHAR CalStatPowerOn = 0;
UCHAR GetCalStatPowerOn(VOID) {
return CalStatPowerOn;
}

VOID SetCalStatPowerOn(VOID) {
CalStatPowerOn = 1;
}

VOID RstCalStatPowerOn(VOID) {
CalStatPowerOn = 0;
}

STATIC VOID MakeFileMessage(VOID)
{
#if defined(LCD_MODEL)
DspClearDisplay();
ShowMessage(0, 0, MSG_ERASING, 0);
#endif
}

STATIC VOID AppInitial(VOID)
{
#if defined(__HITACHI__)
   // initial heap
   free(malloc(HEAPSIZE - 4));
#endif
   // initial Profile
   InitialProfile();
   // initial library
   InitialLib();
   // initial system timer
   InitialSysTimer();
   // initial communication
   InitialCommLibry();
   // initial flash interface
   //InitialFlash();
   // initial SDCard interface
   InitialMCI();
   // initial key data
   InitialKey();

// initial general purpose input output
#if defined(GPIO_MODEL)
InitialGPIO();
#endif

// initial keyboard
#if defined(PS2_MODEL) || defined(USB_HOST_MODEL)
InitialKeyboard();
#endif

//sysprintf("AppInitial-->InitialBuzzer\n");

// initial buzzer
InitialBuzzer();

   //sysprintf("AppInitial-->InitialRTC\n");
   // initial RTC
   InitialRTC();

   //sysprintf("AppInitial-->InitialVarBank\n");
   // initial varbank
   InitialVarBank();

   //sysprintf("AppInitial-->InitialPrintEngine\n");
   // initial print engine
   InitialPrintEngine();

   //sysprintf("AppInitial-->InitialImgEng\n");
   // get image buffer
   InitialImgEng(IMAGE_BUFFER_SIZE);

#if defined(LCD_MODEL)
   // initial Dsiplay
   DspInitialize();
   InitialDspStatus();
#endif

   //sysprintf("AppInitial-->initial file system\n");
   // initial file system
   InitialFile(MakeFileMessage);

   //sysprintf("AppInitial-->InitialModel\n");
   // initial model name
   InitialModel();

   //sysprintf("AppInitial-->InitialFunction\n");
   // initial function
   InitialFunction();

   //sysprintf("AppInitial-->InitialParser\n");
   // initial parser
   InitialParser();

   //sysprintf("AppInitial-->SetBufferUart\n");

   SetBufferUart();
}
STATIC UCHAR CarriageHomeState = 0;
STATIC VOID CarriageHomeSend(VOID)
{
if(CarriageHomeState == 0)
{
CarriageHomeState=1;
}
}
STATIC VOID CarriageHomeLastPrintState(VOID)
{
if(GetJobErrorState()&0x00FE)
{
CarriageHomeState = 2;
}
else
{
if(CarriageHomeState == 1)
{

}
CarriageHomeState = 0;
}
//SendPrintf(" 0x%2x",GetJobErrorState());
}
STATIC UCHAR CarriageHomeGetOpen(VOID)
{
_PrintCfg *pPwrKeyCfg = GrabPrintConfig();
FLOAT data = 0;
if (GetProfileInt("CARRIAGE HOME", &data) == FALSE)
   data = 0;
   return ((BOOL)data == TRUE);
}
//
/* 这是一个线程函数，名为CarriageHomeProcess。该函数是在一个无限循环中运行的，通过检查CarriageHomeState变量的值来判断是否需要执行归位操作。

在循环中，首先获取打印配置参数pPwrKeyCfg。然后，如果CarriageHomeState的值为1，则执行归位操作。具体操作包括检查打印输出模式是否为PEEL_MODE，如果不是，则调用PaperHome函数执行纸张归位操作。
最后，将CarriageHomeState的值设为0，表示归位操作已完成。

在每次循环结束后，通过调用NutSleep函数使线程休眠20毫秒。这样可以降低线程的CPU占用率，避免过多的计算资源浪费。

总的来说，CarriageHomeProcess函数是一个用于处理打印机归位操作的线程函数。它会根据CarriageHomeState变量的值来触发相应的归位操作，并通过NutSleep函数控制线程的执行间隔。

*/
//
THREAD(CarriageHomeProcess, arg)
{
_PrintCfg *pPwrKeyCfg = GrabPrintConfig();

#ifdef DEBUG_PRNT
sysprintf("start app CarriageHomeProcess\r\n");
#endif

for (;;)
{
if(CarriageHomeState == 1)
{
if(pPwrKeyCfg->PrintOutMode!=PEEL_MODE)
PaperHome(pPwrKeyCfg);
CarriageHomeState = 0;
}
NutSleep(20);
}
}
/
extern void PowerOnFeed(void);
STATIC VOID AppMain(VOID)
{
_PrintCfg *pMainCfg = GrabPrintConfig();

TaskStart();

EnableInterrupt(0x0);

//   sysprintf("start app main\r\n"); // ch_20220309
//   sysprintf("2022-05-19 released.\r\n"); // ch_20220309
   sysprintf("%s\n", SrcRevName); // ch_20220520

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

   /*
   * Automatically senses ribbon presence
   */
#if defined(RIBBON_MODEL)

if (pMainCfg->RibbonFlag) // ch_20220714
CheckRibbonExists(FALSE, TRUE); //检查色带是否存在

#endif
//CutterHome();

   /*
   * Power on buzzing prompt
   */
   if (!CheckKeyPin(FEED_KEY)) // ch_20211229
   {
       EnableBuzzer(8, 100);
       while (CheckBuzzerStatus()) {}

delay_msec(50);

       EnableBuzzer(8, 100);
       while (CheckBuzzerStatus()) {}
   }
   // ch_20211229
   else
   {
       EnableBuzzer(0, 0);
       while (CheckBuzzerStatus()) {}
   }

   /*
   * Request to send
   */
   SetUsbHandShake(TRUE);
   SetUartHandShake(UART_STATUS_READY);
   UartChar(XOFF);
   UartChar(XON);

delay_msec(100); // Waiting KP200 Plus cancel AUTO.BAS

   /*
   * Boot key function
   */
   CheckPowerOnKey();
//powerOnDone = 1; // ch_20211218
   GetKey(MENU_KEY);
   GetKey(FEED_KEY);
   GetKey(PAUSE_KEY);
   StartKeyFunc(TRUE);

   /*
   * Lights and panel show ready
   */
#if defined(MONO_LED)
   ShowLED(HID_LED_ON, HID_LED_ON, HID_LED_OFF);
#elif defined(POLY_LED)
   SetLEDStat(LED_ON_BLUE); // ch_20220707
   ShowLED(HID_LED_GREEN);
#endif

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

#if defined(CARRIAGE_OPEN_MODEL)
   if (IsCarriageOpen() && pMainCfg->CarriageOpen)
   {
#if defined(MONO_LED)
       ShowLED(HID_LED_IDLE, HID_LED_OFF, HID_LED_ON);
#elif defined(POLY_LED)
       BackupPrevLEDStat(); // ch_20220609
       ShowLED(HID_LED_RED);
#endif
   }
#endif
if(CarriageHomeGetOpen())
{
SetCarriageCloseCallback(CarriageHomeSend);
SetCarriageOpenCallback(CarriageHomeLastPrintState);
NutThreadCreate("CarriageHome", CarriageHomeProcess, 0, NUT_THREAD_CARRIAGE_HOME_STACK);//THREAD(NutIdle, arg)
}

#if defined(DURALABEL)
// InitailDuraLabel();
#endif
#if defined(UART2_BT)
InitailBt();
#endif

   //PowerOnFeed();
//#ifdef DEBUG_PRNT
   sysprintf("Parser\r\n");
//#endif

   ClearRibbonEncode();
   //while(1);
   Parser();    //解析
}
/
#if defined(NUTOS)

/*!
* \brief Main thread.
*/
THREAD(NutMain, arg)
{
NutThreadSetPriority(NUT_THREAD_MAIN_PRIORITY);

EnableInterrupt(0x0);

   /* Assign stdio to the UART device. */
   NutRegisterDevice(&DEV_DEBUG, 0, 0);
   RegisterStandardIO(DEV_DEBUG_NAME, _O_WRONLY);

#ifdef NUTDEBUG
NutTraceOs(stdout, 0);
NutTraceHeap(stdout, 0);
#endif

#if defined(NUTNET)
InitialEthernet();
#endif

#if defined(USB_HOST_MODEL)
InitialUsbHost();
#endif

AppMain();

   for (;;)
   {
//       NutThreadYield(); // ch_20211220
       NutSleep(10); // ch_20211220
   }
}

/*!
* \brief Idle thread.
*
* \param arg Ignored by the idle thread.
*
* This function runs in an endless loop as a lowest priority thread.
*/

//void led_led(void);
THREAD(NutIdle, arg)
{
/* Initialize system timers. */
// unsigned int i;

NutTimerInit();

/* Create the main application thread. */
NutThreadCreate("main", NutMain, 0, NUT_THREAD_MAIN_STACK);//THREAD(NutMain, arg)

   /*
   * Run in an idle loop at the lowest priority. We can still
   * do something useful here, like killing terminated threads
   * or putting the CPU into sleep mode.
   */
   NutThreadSetPriority(NUT_THREAD_IDLE_PRIORITY);
   for (;;)
   {

       NutThreadYield();
       NutThreadDestroy();
   }
}

#endif
#if 0
void led_led(void)
{
unsigned int i;
__disable_interrupt();
__enable_interrupt();
   while(1)
   {
       LED1_DARK;
       LED2_DARK;
       for(i=1000000; i>0; i--);
       LED1_LIGHT;
       LED2_DARK;
       for(i=1000000; i>0; i--);
       LED1_DARK;
       LED2_DARK;
       for(i=1000000; i>0; i--);
       LED1_DARK;
       LED2_LIGHT;
       for(i=1000000; i>0; i--);
   }
}
#endif
/******************************************************************************
*
* Function:
*       main
*
* Description:
*       This global function is program start.
*
* Input:
*       None
*
* Output:
*       None.
*
******************************************************************************/
extern VOID CalculateCheckSumInit(VOID);
int main(VOID)
{
   INT mask;
   UINT32 index= 0;

   /*
#if defined(DRAM_PROGRAM_LENGTH)
       memcpy(DRAM_PROGRAM_ADDR, DRAM_PROGRAM_FLASH_ADDR, DRAM_PROGRAM_LENGTH);
#endif
   */

ii_main();

//sysprintf("main-->EnableInterrupt(0)\n");

EnableInterrupt(0);

//sysprintf("main-->spiFlashInit\n");
spiFlashInit();

//sysprintf("main-->spiFlashPDMARead\n");
spiFlashPDMARead(BOOT_FLASH_ADDR_END,sizeof(ProfileBuffer),(INT *)(((INT)ProfileBuffer)|NON_CACHE_BIT));

//sysprintf("main-->CalculateCheckSumInit\n");
CalculateCheckSumInit();

//sysprintf("main-->DisableInterrupt\n");
DisableInterrupt(INTERRUPT_MASK);

#if defined(MONO_LED)
   ShowLED(HID_LED_ON, HID_LED_OFF, HID_LED_OFF);
#elif defined(POLY_LED)
   ShowLED(HID_LED_ORANGE);
#endif
   //sysprintf("main-->AppInitial\n");
   AppInitial();
   //sysprintf("main-->EnableInterrupt\n");
   EnableInterrupt(mask);

#if defined(NUTOS)
   NutHeapAdd(NutHeap, sizeof(NutHeap));
   NutThreadCreate("idle", NutIdle, 0, NUT_THREAD_IDLE_STACK);//THREAD(NutIdle, arg)
#else
   AppMain();
#endif

}

#if defined(__HITACHI__)
#pragma section End
#endif

VOID ProgramEnd(VOID) {}

AppMain.h 。。。。。。。。。。。。。。。。。。。。。。。。。。。。

#ifndef APPMAIN_H

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

#define APPMAIN_H

/* None */

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

int main(void);

void ii_main(void);

UCHAR PowerOnStatus(VOID); // ch_20211218
VOID SetCalStatPowerOn(VOID); // ch_20220411
VOID RstCalStatPowerOn(VOID); // ch_20220411

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

#endif

ARM.h 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

#ifndef ARM_H

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

#define ARM_H

/* None */

#ifdef __cplusplus
extern "C" { /* Assume C declarations for C++ */
#endif /* __cplusplus */

/******************************************************************************
* *
* G L O B A L D E F I N E S *
* *
******************************************************************************/

#define ARM_MODE_USER           0x10
#define ARM_MODE_FIQ           0x11
#define ARM_MODE_IRQ           0x12
#define ARM_MODE_SVC           0x13
#define ARM_MODE_ABORT           0x17
#define ARM_MODE_UNDEF           0x1B
#define ARM_MODE_SYS           0x1F
#define ARM_MODE_MASK           0x1F

#define I_BIT                   0x80
#define ARM_CPSR_I_BIT           0x80
#define F_BIT                   0x40
#define ARM_CPSR_F_BIT           0x40
#define T_BIT                   0x20
#define ARM_CPSR_T_BIT           0x20

/* None */

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

#endif

Compiler.h 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

#ifndef COMPILER_H

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

#define COMPILER_H

#if defined(__HITACHI__)
#include <machine.h>
#endif

#if defined(__ICCARM__) ||defined(__MDKARM__)
#include <intrinsics.h>
#endif

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

#if defined(__HITACHI__)
#define __attribute__(x)
#define _NOP()                   nop()
#define NutEnterCritical()       set_imask(0xF)
#define NutExitCritical()       set_imask(0x0)
#define NutJumpOutCritical()   NutExitCritical()

#elif defined(__ICCARM__) || defined(__MDKARM__)
#define __attribute__(x)
#define _NOP()                   __nop()
#define NutEnterCritical()       __disable_interrupt()
#define NutExitCritical()       __enable_interrupt()
#define NutJumpOutCritical()   NutExitCritical()

#endif

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

#endif

Hardware.h 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

#ifndef HARDWARE_H

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

#define HARDWARE_H
#include "MachMdl.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 */

#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(AT91SAM9260)
   #define SLOWCLOCK               32768           // In Hz
   #define MAIN_OSC_CLK           18432000       // In Hz

   #define PROCESSOR_CLOCK           200000000       // In Hz
   #define PERIPHERAL_CLOCK       MASTER_CLOCK   // In Hz

   #if defined(TDP225) || defined(TTP225) || defined(TTP323)
   #define MASTER_CLOCK           FREQ_50MHZ
   #else
   #define MASTER_CLOCK           FREQ_100MHZ
   #endif

#define FREQ_50MHZ 50000000
#define FREQ_100MHZ 100000000

#elif defined(SH7040)
   #define CRYSTAL_OSCILLATOR       7159090UL
   #define CLOCK_FREQ_MULTIPLE       4
   #define SYSTEM_CLOCK           (CRYSTAL_OSCILLATOR * CLOCK_FREQ_MULTIPLE)
   #define PERIPHERAL_CLOCK       SYSTEM_CLOCK   // In Hz
#elif defined(N3290)
   #define SLOWCLOCK               32768           // In Hz
   #define MAIN_OSC_CLK           18432000       // In Hz
   #if defined(CPU_144MHZ_MODE)
   #define MASTER_CLOCK           144000000
   #else
   #define MASTER_CLOCK           192000000
   #endif
   #define PERIPHERAL_CLOCK       MASTER_CLOCK   // In Hz
#endif

#if defined(AT91SAM9260)
#define CLOSE_WATCH_DOG (AT91C_BASE_WDTC->WDTC_WDMR = AT91C_WDTC_WDDIS)
#define START_WATCH_DOG(X, Y) {}

#elif defined(SH7040)
// Watch Dog
// 0x5AXX write to WDT_TCNT
// 0xA5XX write to WDT_TCSR
// 0x5AXX write to WDT_RSTCSR => RSTE(bit6), RSTS(bit5)
// 0xA5XX write to WDT_RSTCSR => WOVF = 0
#define WDT_TCSR               (*(VOLATILE USHORT *)0xFFFF8610)
#define WDT_TCNT               (*(VOLATILE USHORT *)0xFFFF8610)
#define WDT_RSTCSR               (*(VOLATILE USHORT *)0xFFFF8612)

// X = 0 ~ 255   , Y = 0(17.9us) 5(9.15ms) 7(73.2ms)
#define START_WATCH_DOG(X, Y)   { WDT_TCNT = 0x5A00 + X; WDT_TCSR = 0xA5E0 + Y; WDT_RSTCSR = 0x5A40; }
#define RESET_WATCH_DOG(X)       { WDT_TCNT = 0x5A00 + X; }
#define CLOSE_WATCH_DOG           { WDT_TCSR = 0xA500; }
#elif defined(N3290)
#define CLOSE_WATCH_DOG
#define START_WATCH_DOG(X, Y)   {}

#endif

#if defined(AT91SAM9260)
#define FLASH_START_ADDR (UINT)AT91C_EBI_CS0
#define NONCACHE 0x80000000

#elif defined(SH7040)
#define FLASH_START_ADDR 0x00000000
#define MEMORY_CARD_ADDR 0x00400000

#define DRAM_PROGRAM_FLASH_ADDR   (VOLATILE VOID *)0x00011000
#define DRAM_PROGRAM_ADDR       (VOLATILE VOID *)0x011F1000
#define DRAM_PROGRAM_LENGTH       (0x5000)

#elif defined(N3290)

#define FLASH_START_BUFFER_ADDR ((UINT)ProfileBuffer)
#define FLASH_START_ADDR 0x20000000
#define NONCACHE 0x80000000

#endif

#define BOOT_CODE_AREA_ADDR FLASH_START_ADDR
#define BOOT_CODE_LEN 0x6644

#define APP_CODE_AREA_ADDR (FLASH_START_ADDR + 0x00020000)
#define APP_CODE_CHECKSUM (*(VOLATILE ULONG *)APP_CODE_AREA_ADDR)

#if defined(AT91SAM9260)

#define APP_CODE_LEN           (*(VOLATILE ULONG *)(APP_CODE_AREA_ADDR + 4) + 8)
#if defined(TSPL) && defined(EPL2) && defined(ZPL2) && defined(DPL)
#define FLASH_FILE_ADDR           (APP_CODE_AREA_ADDR + 0x160000)
#elif defined(TSPL) && defined(EPL2) && defined(ZPL2)
#define FLASH_FILE_ADDR           (APP_CODE_AREA_ADDR + 0x160000)
#endif

#elif defined(N3290)
#define APP_CODE_LEN (*(VOLATILE ULONG *)(APP_CODE_AREA_ADDR + 4) + 8)
#define FLASH_FILE_ADDR 0x8000000

#endif

#if defined(AT91SAM9260)

#if defined(TPH_DPI_200)

#if defined(XP470B) ||defined(DELUXE_2044)|| defined(XP450B) \
||defined(XPDT425B)|| defined(XPDT108BLABEL) || defined(XPDT427B)\
||defined(XP460B)||defined(XP490B)
#define IMAGE_INCH 90
#else
#define IMAGE_INCH 110
#endif

#elif defined(TPH_DPI_300)
#define IMAGE_INCH 40
#endif

#elif defined(SH7040)

#if defined(TPH_DPI_200)
#define IMAGE_INCH 26
#elif defined(TPH_DPI_300)
#define IMAGE_INCH 12
#endif

#elif defined(N3290)
#define IMAGE_INCH 70
#endif

#if defined(TPH_DPI_200)

#define TPH_DPI (FLOAT)203.2
#define MM_DOT (FLOAT)8

#if defined(TPH_MM_104)

#define TPH_WIDTH_DOT           832
#elif defined(XP300B)
#define TPH_WIDTH_DOT           640
#else
#define TPH_WIDTH_DOT           832//864 // ch_20220110 : the actual should be 832, not 864.
#endif

#elif defined(TPH_DPI_300)
#define TPH_DPI                   (FLOAT)300
#define MM_DOT                   (FLOAT)11.8
#if defined(TPH_MM_104)
#define TPH_WIDTH_DOT           1248
#else
#define TPH_WIDTH_DOT           1296
#endif
//#define TPH_WIDTH_DOT           1248

#elif defined(TPH_DPI_600)
#define TPH_DPI                   (FLOAT)600
#define MM_DOT                   (FLOAT)23.62
#define TPH_WIDTH_DOT           2496

#endif

#define TPH_WIDTH_BYTE (TPH_WIDTH_DOT / 8)
#define TPH_WIDTH_INT ((TPH_WIDTH_BYTE + (sizeof(INT) - 1)) / sizeof(INT))

#define MAX_IMAGE_LENGTH       (INT)(TPH_DPI * IMAGE_INCH)
#define HALF_IMAGE_LENGTH       (MAX_IMAGE_LENGTH / 2)
#define IMAGE_BUFFER_SIZE       (MAX_IMAGE_LENGTH * TPH_WIDTH_BYTE)

/* None */

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

#endif

HdwReg.c 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

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

#define HDWREG_C

/* None */

#include "Common.h"
#include "XCore.h"
#include "Xcomm.h"
#include "HdwReg.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 */

#if defined(__HITACHI__)
#pragma section ISR
#endif

/******************************************************************************
*
* Function:
* OutPin
*
* Description:
*       This global function out data to IO pin.
*
* Input:
*     None
*
* Output:
*     None.
*
******************************************************************************/
VOID OutPin(_eIOPort port, BYTE pin, INT data)
{
   INT imask;

imask = DisableInterrupt(INTERRUPT_MASK);

IOPort[port].Data = *IOPort[port].In;

   if ( data )
       IOPort[port].Data |= pin;
   else
       IOPort[port].Data &= ~pin;

*IOPort[port].Out = IOPort[port].Data;

EnableInterrupt(imask);
}

VOID EnableInterrupt(INT priority)
{
#if defined(__HITACHI__)
   set_imask(priority);
#elif defined(__ICCARM__)||defined(__MDKARM__)
   if ( !priority )
       __enable_interrupt();
#endif
}

INT DisableInterrupt(INT priority)
{
#if defined(__HITACHI__)
   INT imask = get_imask();
   if ( priority > imask )
       set_imask(priority);
   CLOSE_WATCH_DOG;
   return imask;

#elif defined(__ICCARM__)||defined(__MDKARM__)
   INT imask = (__get_CPSR() & 0x80);
   if ( priority )
       __disable_interrupt();
   CLOSE_WATCH_DOG;
   return imask;

#endif
}

VOID ProcessorReset(VOID)
{
#if defined(AT91SAM9260)
   DisableInterrupt(INTERRUPT_MASK);
   AT91F_RSTSoftReset(AT91C_BASE_RSTC, AT91C_RSTC_PROCRST | AT91C_RSTC_PERRST | AT91C_RSTC_EXTRST);
   while ( 1 ){}

#elif defined(SH7040)
   DisableInterrupt(INTERRUPT_MASK);
   WDT_TCNT = 0x5AFE;
   WDT_RSTCSR = 0x5A40;
   WDT_TCSR = 0xA5E0;
   while ( 1 ){}
#elif defined(N3290)
   DisableInterrupt(INTERRUPT_MASK);
   outpw(REG_WTCR, inpw(REG_WTCR) | 0x80);//ENABLE WDT
   outpw(REG_WTCR, inpw(REG_WTCR) | 0x02);//ENABLE WDT RESET
   while (1){};

#endif
}

#if defined(__HITACHI__)
#pragma section
#endif

HdwReg.h 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

#ifndef HWDREG_H

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

#define HWDREG_H

/* None */

#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(TTP243_PCB) || defined(TDP643_PCB) || defined(TTP244M_PCB)
#define PORTA_PROTECT PE.DR.BIT.B2

#endif

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

#define DATA_PORT_01 (VOLATILE BYTE *)0x30000000 // Centronic data port

#endif

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

typedef enum
{
EXT_IOPORT_01,
}_eIOPort;

#else

typedef INT _eIOPort;

#endif

typedef struct
{
   VOLATILE BYTE    *Out;
   VOLATILE BYTE    *In;
   VOLATILE BYTE   Data;
}_IOPort;

#ifdef HDWREG_C
#define EXTERN
#else
#define EXTERN extern
#endif

#ifdef HDWREG_C

#if defined(TTP245P_PCB) ||defined(T045_PCB) ||defined(T40_PCB)
EXTERN _IOPort IOPort[] =
{
// Centronic data port
{ &IOPort[0].Data, DATA_PORT_01, 0}, // Read
};

#else

EXTERN _IOPort IOPort[] = { &IOPort[0].Data, &IOPort[0].Data, 0 };

#endif

#else

EXTERN _IOPort IOPort[];

#endif

#define InPort(port)           ( *IOPort[port].In )
#define OutPort(port, data)       ( *IOPort[port].Out = IOPort[port].Data = data )
#define InPin(port, pin)       ( *IOPort[port].In & pin )

VOID OutPin(_eIOPort, BYTE, INT);

VOID EnableInterrupt(INT);
INT DisableInterrupt(INT);

VOID ProcessorReset(VOID);

#undef EXTERN

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

#endif

Priority.h 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

#ifndef PRIORITY_H

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

#define PRIORITY_H

/* None */

#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(AT91SAM9260)||defined(N3290)

#define EMAC_PRIORITY           0x0
#define USB_PRIORITY           0x1
#define PERIOD_PRIORITY           0x2
#define MOTION_PRIORITY           0x3
#define UART_PRIORITY           0x4
#define UART2_PRIORITY           0x5
#define TPH_DATA_PRIORITY       0x6
#define HEAT_PRIORITY           0x6
#define PS2_PRIORITY           0x7
#define POWER_DOWN_PRIORITY       0x0

#define INTERRUPT_MASK           0xC0
#define COMM_IMASK               INTERRUPT_MASK
#define FLASH_IMASK               0x00
#define MOTION_IMASK           INTERRUPT_MASK
#define PERIOD_IMASK           INTERRUPT_MASK
#define TASK_IMASK               INTERRUPT_MASK
#define PS2_IMASK               INTERRUPT_MASK

#elif defined(SH7040)

#define UART_IPR INTC.IPRF.BIT._SCI0 // SCI0
#define UART_PRIORITY 0xA

#define USB_IPR INTC.IPRA.BIT._IRQ3 // IRQ3
#define USB_PRIORITY 0x3

#define MOTION_IPR INTC.IPRF.BIT._MTU4G // MTU4
#define MOTION_PRIORITY 0x7

#define PERIOD_IPR INTC.IPRG.BIT._CMT0 // CMT0
#define PERIOD_PRIORITY 0x5

#define BUZZ_PRIORITY 0x9
#define TASK_PRIORITY 0x1

#define HEAT_IPR INTC.IPRG.BIT._CMT1 // CMT1
#define HEAT_PRIORITY 0xC

#define TPH_DATA_IPR INTC.IPRC.BIT._DMAC2 // DMA2
#define TPH_DATA_PRIORITY 0xC

#define POWER_DOWN_IPR INTC.IPRA.BIT._IRQ2 // IRQ2
#define POWER_DOWN_PRIORITY 0xE

#define PS2_IPR INTC.IPRA.BIT._IRQ0 // IRQ0
#define PS2_PRIORITY 0x6

#define INTERRUPT_MASK           0xF
#define COMM_IMASK               UART_PRIORITY
#define FLASH_IMASK               (UART_PRIORITY - 1)
#define MOTION_IMASK           MOTION_PRIORITY
#define PERIOD_IMASK           PERIOD_PRIORITY
#define TASK_IMASK               BUZZ_PRIORITY
#define PS2_IMASK               PS2_PRIORITY

#endif

/* None */

VOID InitialCommDrv(VOID);

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

#endif

SuperH.h 。。。。。。。。。。。。。。。。。。。。。。。。。。。。

#ifndef SUPERH_H

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

#define SUPERH_H

/* None */

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

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

#endif

qq_33772147

关注

13
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
T168_111\core 文件：第1~最后一个文件

然后，如果CarriageHomeState的值为1，则执行归位操作。具体操作包括检查打印输出模式是否为PEEL_MODE，如果不是，则调用PaperHome函数执行纸张归位操作。总的来说，CarriageHomeProcess函数是一个用于处理打印机归位操作的线程函数。它会根据CarriageHomeState变量的值来触发相应的归位操作，并通过NutSleep函数控制线程的执行间隔。该函数是在一个无限循环中运行的，通过检查CarriageHomeState变量的值来判断是否需要执行归位操作。
复制链接

扫一扫