Menu.h 。。。。。。。。。。。。。。。。。。。。。
#ifndef MENU_H
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define MENU_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 *
* *
******************************************************************************/
/******************************************************************************
* *
* 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"
#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 *
* *
******************************************************************************/
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
VOID MainMenu(VOID);
VOID JobMenu(VOID);
INT ErrorMenu(VOID);
VOID SensorMenu(_eSensorMode);
VOID KeyboardMenu(VOID);
VOID KeyboardFlashListMenu(VOID);
#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */
#endif
MenuKB.c 。。。。。。。。。。。。。。。。。。。。。。。。
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define MENUKB_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 "XTask.h"
#include "XBuzzer.h"
#include "XTimer.h"
#include "XFileSys.h"
#include "XDisplay.h"
#include "XKeyboard.h"
#include "XVarBank.h"
#include "Menu.h"
/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/
#if defined(PS2_MODEL) || defined(USB_HOST_MODEL)
#if defined(MENU_TSPL_3) || defined(MENU_TSPL_4)
#define KB_ESC_KEY 1
#define KB_UP_KEY 2
#define KB_DOWN_KEY 3
#define KB_ENTER_KEY 4
/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/
typedef struct
{
CHAR **tag;
CHAR **title;
_eFileDevice device;
}_FileItem;
/******************************************************************************
* *
* 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 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 _PrintCfg *pMenuCfg; // printer config data point
STATIC BOOL ExitMenu;
STATIC VOID InitialMenu(VOID)
{
pMenuCfg = GrabPrintConfig();
}
STATIC VOID EntryMenuFunc(VOID)
{
WaitWorkJobEnd();
#if defined(CARRIAGE_OPEN_MODEL)
StopCheckCarriageOpen();
#endif
StopKeyFunc();
}
STATIC VOID LeaveMenuFunc(VOID)
{
delay_msec(200);
StartKeyFunc(TRUE);
#if defined(CARRIAGE_OPEN_MODEL)
StartCheckCarriageOpen();
#endif
}
STATIC INT MenuWaitKey(VOID)
{
INT Status;
INT Key;
while (1)
{
if (Key = KeyboardOut())
{
if (Key == SCAN_KEY_ESC)
{
Status = KB_ESC_KEY;
break;
}
if (Key == SCAN_KEY_UP)
{
Status = KB_UP_KEY;
break;
}
if (Key == SCAN_KEY_DOWN)
{
Status = KB_DOWN_KEY;
break;
}
if (Key == SCAN_KEY_ENTER)
{
Status = KB_ENTER_KEY;
break;
}
}
NutSleep(10);
}
sysprintf("MenuWaitKey\r\n");
EnableBuzzer(26, 100);
return Status;
}
STATIC VOID FileListMenu(CHAR **title, _eFileDevice device)
{
CONST STATIC CHAR rev[] = " ";
_FileList list;
CHAR name[DSP_LINES][20];
INT index;
memset(name, 0, sizeof(name));
OpenList(&list, device);
if (!NextFile(&list, "*.*"))
{
DspClearDisplay();
ShowLCDString(0, 0, *(title + pMenuCfg->Language), 0);
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_NO_FILE][pMenuCfg->Language], 0);
while (CheckKeyPin(SELECT_KEY)){}
MenuWaitKey();
return;
}
#if (DSP_LINES == 2)
strcpy(name[0], list.FileName);
PrevFile(&list, "*.*");
#elif (DSP_LINES == 3)
strcpy(name[0], list.FileName);
if (NextFile(&list, "*.*"))
strcpy(name[1], list.FileName);
PrevFile(&list, "*.*");
PrevFile(&list, "*.*");
#elif (DSP_LINES == 4)
strcpy(name[0], list.FileName);
if (NextFile(&list, "*.*"))
strcpy(name[1], list.FileName);
if (NextFile(&list, "*.*"))
strcpy(name[2], list.FileName);
PrevFile(&list, "*.*");
PrevFile(&list, "*.*");
PrevFile(&list, "*.*");
#endif
index = 1;
while (1)
{
while (CheckBuzzerStatus()){}
#if (DSP_LINES == 2)
DspClearDisplay();
ShowLCDString(0, 0, *(title + pMenuCfg->Language), 0);
ShowLCDString(0, 1, name[0], 0);
#elif (DSP_LINES == 3)
DspClearDisplay();
ShowLCDString(0, index, ">", 0);
ShowLCDString(0, 0, *(title + pMenuCfg->Language), 0);
ShowLCDString(1, 1, name[0], 0);
ShowLCDString(1, 2, name[1], 0);
#elif (DSP_LINES == 4)
DspClearDisplay();
ShowLCDString(0, index, ">", 0);
ShowLCDString(1, index, (CHAR *)rev, 1);
ShowLCDString(0, 0, *(title + pMenuCfg->Language), 0);
ShowLCDString(1, 1, name[0], index == 1 ? 1 : 0);
ShowLCDString(1, 2, name[1], index == 2 ? 1 : 0);
ShowLCDString(1, 3, name[2], index == 3 ? 1 : 0);
#endif
while (CheckKeyPin(SELECT_KEY)){}
switch (MenuWaitKey())
{
case KB_ESC_KEY: // exit
return;
case KB_UP_KEY: // prev
if (PrevFile(&list, "*.*"))
{
if (--index < 1)
{
#if (DSP_LINES == 2)
strcpy(name[0], list.FileName);
#elif (DSP_LINES == 3)
strcpy(name[1], name[0]);
strcpy(name[0], list.FileName);
#elif (DSP_LINES == 4)
strcpy(name[2], name[1]);
strcpy(name[1], name[0]);
strcpy(name[0], list.FileName);
#endif
index = 1;
}
}
break;
case KB_DOWN_KEY: // next
if (NextFile(&list, "*.*"))
{
if (NextFile(&list, "*.*"))
{
if (++index > DSP_LINES - 1)
{
#if (DSP_LINES == 2)
strcpy(name[DSP_LINES - 2], list.FileName);
#elif (DSP_LINES == 3)
strcpy(name[DSP_LINES - 3], name[DSP_LINES - 2]);
strcpy(name[DSP_LINES - 2], list.FileName);
#elif (DSP_LINES == 4)
strcpy(name[DSP_LINES - 4], name[DSP_LINES - 3]);
strcpy(name[DSP_LINES - 3], name[DSP_LINES - 2]);
strcpy(name[DSP_LINES - 2], list.FileName);
#endif
index = DSP_LINES - 1;
}
}
PrevFile(&list, "*.*");
}
break;
case KB_ENTER_KEY: // run
if (strcmp(strchr(list.FileName, '.'), ".BAS"))
break;
RunBasicFile(device, list.FileName);
ExitMenu = TRUE;
return;
}
}
}
STATIC VOID DevListMenu(_FileItem *index, CHAR **title)
{
CONST STATIC CHAR rev[] = " ";
_FileItem *top, *mid, *bot;
CHAR buf[20];
INT item, total;
index += 1;
item = 1;
// caculate total item
total = 1;
while ((index + total)->tag)
total += 1;
#if (DSP_LINES == 2)
top = index;
mid = index;
bot = index;
#elif (DSP_LINES == 3)
top = index;
mid = index + 1;
bot = index + 1;
#elif (DSP_LINES == 4)
top = index;
mid = index + 1;
bot = index + 2;
#endif
ExitMenu = FALSE;
while (!ExitMenu)
{
while (CheckBuzzerStatus()){}
#if (DSP_LINES == 2)
DspClearDisplay();
ShowLCDString(0, 0, *(title + pMenuCfg->Language), 0);
ShowLCDString(0, 1, *(index->tag + pMenuCfg->Language), 0);
#elif (DSP_LINES == 3)
DspClearDisplay();
ShowLCDString(0, 0, *(title + pMenuCfg->Language), 0);
if (index == top)
{
ShowLCDString(1, 1, *(top->tag + pMenuCfg->Language), 0);
ShowLCDString(1, 2, *(bot->tag + pMenuCfg->Language), 0);
ShowLCDString(0, 1, ">", 0);
}
else if (index == mid)
{
ShowLCDString(1, 1, *(top->tag + pMenuCfg->Language), 0);
ShowLCDString(1, 2, *(bot->tag + pMenuCfg->Language), 0);
ShowLCDString(0, 2, ">", 0);
}
#elif (DSP_LINES == 4)
DspClearDisplay();
ShowLCDString(0, 0, *(title + pMenuCfg->Language), 0);
sprintf(buf, "%1d/%1d", item, total);
ShowLCDString((16 - strlen(buf)), 0, buf, 0);
if (index == top)
{
ShowLCDString(1, 1, (CHAR *)rev, 1);
ShowLCDString(1, 1, *(top->tag + pMenuCfg->Language), 1);
ShowLCDString(1, 2, *(mid->tag + pMenuCfg->Language), 0);
ShowLCDString(1, 3, *(bot->tag + pMenuCfg->Language), 0);
ShowLCDString(0, 1, ">", 0);
}
else if (index == mid)
{
ShowLCDString(1, 2, (CHAR *)rev, 1);
ShowLCDString(1, 1, *(top->tag + pMenuCfg->Language), 0);
ShowLCDString(1, 2, *(mid->tag + pMenuCfg->Language), 1);
ShowLCDString(1, 3, *(bot->tag + pMenuCfg->Language), 0);
ShowLCDString(0, 2, ">", 0);
}
else if (index == bot)
{
ShowLCDString(1, 3, (CHAR *)rev, 1);
ShowLCDString(1, 1, *(top->tag + pMenuCfg->Language), 0);
ShowLCDString(1, 2, *(mid->tag + pMenuCfg->Language), 0);
ShowLCDString(1, 3, *(bot->tag + pMenuCfg->Language), 1);
ShowLCDString(0, 3, ">", 0);
}
#endif
switch (MenuWaitKey())
{
case KB_ESC_KEY: // exit
return;
case KB_UP_KEY: // prev
if ((index - 1)->tag)
{
if (index == top)
{
top--;
mid--;
bot--;
}
index--;
item--;
}
break;
case KB_DOWN_KEY: // next
if ((index + 1)->tag)
{
if (index == bot)
{
top++;
mid++;
bot++;
}
index++;
item++;
}
break;
case KB_ENTER_KEY: // entry
if (!index->title)
return;
FileListMenu(index->title, index->device);
break;
}
}
}
VOID KeyboardMenu(VOID)
{
CONST STATIC _FileItem FileItem[] =
{
{_NULL, _NULL, (_eFileDevice)_NULL},
{(CHAR **)LCDMessage[MSG_DRAM], (CHAR **)LCDMessage[MSG_DRAM_FILE_LIST], DRAM_DEVICE},
{(CHAR **)LCDMessage[MSG_FLASH], (CHAR **)LCDMessage[MSG_FLASH_FILE_LIST], FLASH_DEVICE},
{(CHAR **)LCDMessage[MSG_CARD], (CHAR **)LCDMessage[MSG_CARD_FILE_LIST], CARD_DEVICE},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL, (_eFileDevice)_NULL},
{_NULL, _NULL, (_eFileDevice)_NULL}
};
ClrDisplayStatus(DIS_READY);
EntryMenuFunc();
InitialMenu();
EnableBuzzer(26, 100);
while (CheckBuzzerStatus()){}
DevListMenu((_FileItem *)FileItem, (CHAR **)LCDMessage[MSG_FILE_LIST]);
LeaveMenuFunc();
SetDisplayStatus(DIS_READY);
}
VOID KeyboardFlashListMenu(VOID)
{
ClrDisplayStatus(DIS_READY);
EntryMenuFunc();
InitialMenu();
sysprintf("KeyboardFlashListMenu\r\n");
EnableBuzzer(26, 100);
while (CheckBuzzerStatus()){}
FileListMenu((CHAR **)LCDMessage[MSG_FLASH_FILE_LIST], FLASH_DEVICE);
LeaveMenuFunc();
SetDisplayStatus(DIS_READY);
}
#endif
#endif
MenuVer1.c 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define MENUVER1_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 <string.h>
#include <stdlib.h>
#include <ctype.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 "XADC.h"
#include "XKey.h"
#include "XBuzzer.h"
#include "XTask.h"
#include "XVarBank.h"
#include "XFileSys.h"
#include "XRTC.h"
#include "XPrtEng.h"
#include "XDisplay.h"
#include "XCodePage.h"
#include "XAppVer.h"
#include "Tspl\TsplFunc.h"
#include "Tspl\TsplUtil.h"
#include "Menu.h"
/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/
#if defined(LCD_MODEL) && defined(MENU_TSPL_1)
/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/
typedef struct
{
INT FeedKeyIndex;
INT PauseKeyIndex;
INT MenuKeyIndex;
}_MenuKey;
typedef enum
{
MAIN_SHOW_PRINT_INFO,
MAIN_SHOW_FILE_INFO,
MAIN_SHOW_MEMORY_INFO,
MAIN_SHOW_DATE_TIME,
MAIN_PRINT_SETUP,
MAIN_ROTATE_CUTTER,
MAIN_TOTAL,
}_eMainItem;
typedef enum
{
INFO_VERSION,
INFO_SPEED,
INFO_DENSITY,
INFO_COM,
INFO_CODEPAGE,
INFO_COUNTRY,
INFO_SIZE,
INFO_GAP,
INFO_PEEL_MODE,
INFO_CUT_MODE,
INFO_RIBBON,
INFO_MILLAGE,
INFO_ITEM_TOTAL,
}_ePrintInfoItem;
typedef enum
{
MEMORY_SIZE_TOTAL,
MEMORY_SIZE_REMAIN,
MEMORY_ITEM_TOATL,
}_eMemoryInfoItem;
typedef enum
{
INFO_DATE,
INFO_TIME,
DATE_TIME_TOTAL,
}_eDateTimeInfo;
typedef enum
{
SETUP_LANGUAGE,
SETUP_SPEED,
SETUP_DENSITY,
SETUP_BAUD,
SETUP_PARITY,
SETUP_DATABITS,
SETUP_STOPBIT,
SETUP_TOTAL,
}_ePrintSetup;
/******************************************************************************
* *
* L O C A L F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
CONST STATIC CHAR *COM_BAUD_FULL[] =
{
"0",
"1200",
"2400",
"4800",
"9600",
"19200",
"38400",
"57600",
"115200",
};
CONST STATIC CHAR *COM_BAUD[] =
{
"0",
"12",
"24",
"48",
"96",
"19",
"38",
"57",
"115",
};
CONST STATIC CHAR *COM_PARITY_FULL[] =
{
"NONE",
"ODD",
"EVEN",
};
CONST STATIC CHAR *COM_PARITY[] =
{
"N",
"O",
"E",
};
CONST STATIC CHAR *COM_DATABITS[] =
{
"7",
"8",
};
CONST STATIC CHAR *COM_STOP[] =
{
"1",
"2",
};
/******************************************************************************
* *
* 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 _PrintCfg *pMenuCfg; // priner config data point
STATIC _PrintRecord* pMenuRec; // printer record
STATIC _FileList FileList;
STATIC _eFileDevice ListDevice;
STATIC INT FileTotal;
VOID InitialMenu(VOID)
{
pMenuCfg = GrabPrintConfig();
pMenuRec = GrabPrintRecord();
FileTotal = GetFileTotal(FLASH_DEVICE, "*.*");
FileTotal += GetFileTotal(CARD_DEVICE, "*.*");
FileTotal += GetFileTotal(DRAM_DEVICE, "*.*");
ListDevice = DRAM_DEVICE;
OpenList(&FileList, ListDevice);
}
INT MenuWaitKey(VOID)
{
while (1)
{
if ( GetKey(FEED_KEY) )
return FEED_KEY;
if ( GetKey(PAUSE_KEY) )
return PAUSE_KEY;
if ( GetKey(MENU_KEY) )
return MENU_KEY;
}
}
VOID DispatchSubMenuInfo(_MenuKey *pMenuKey)
{
CHAR InfoStr[256];
DspClearLine(1, LCD_LANG_ENG);
switch ( pMenuKey->FeedKeyIndex )
{
case INFO_VERSION:
sprintf( InfoStr,"%s %s", ModelName, VerName);
break;
case INFO_SPEED:
sprintf( InfoStr,"%s%s", LCDMessage[MSG_SPEED][pMenuCfg->Language], ToSpeedString(pMenuCfg->Speed));
break;
case INFO_DENSITY:
sprintf( InfoStr,"%s%d", LCDMessage[MSG_DENSITY][pMenuCfg->Language], (INT)pMenuCfg->fDensity);
break;
case INFO_COM:
sprintf( InfoStr,"%s%s,%s,%s,%s", LCDMessage[MSG_COM1][pMenuCfg->Language],
COM_BAUD[pMenuCfg->UartSetting.Baud], COM_PARITY[pMenuCfg->UartSetting.Parity],
COM_DATABITS[pMenuCfg->UartSetting.DataBits], COM_STOP[pMenuCfg->UartSetting.Stop] );
break;
case INFO_CODEPAGE:
sprintf( InfoStr,"%s%s", LCDMessage[MSG_CODEPAGE][pMenuCfg->Language], CodePageNameTable[pMenuCfg->CodePage]);
break;
case INFO_COUNTRY:
sprintf( InfoStr,"%s%s", LCDMessage[MSG_COUNTRY][pMenuCfg->Language], CountryNameTable[pMenuCfg->Country]);
break;
case INFO_SIZE:
sprintf( InfoStr,"%s%.2f,%.2f", LCDMessage[MSG_SIZE][pMenuCfg->Language], (FLOAT)pMenuCfg->PaperWidth / TPH_DPI, pMenuCfg->fPaperSize / TPH_DPI);
break;
case INFO_GAP:
if ( pMenuCfg->SensorMode == GAP_MODE )
sprintf( InfoStr,"%s%.2f,%.2f", LCDMessage[MSG_GAP][pMenuCfg->Language], pMenuCfg->fGapSize / TPH_DPI, pMenuCfg->fGapOffset / TPH_DPI);
else if ( pMenuCfg->SensorMode == BLINE_MODE )
sprintf( InfoStr,"%s%.2f,%.2f", LCDMessage[MSG_BLINE][pMenuCfg->Language], pMenuCfg->fBlineSize / TPH_DPI, pMenuCfg->fBlineOffset / TPH_DPI);
else
sprintf( InfoStr,"%s%.2f,%.2f", LCDMessage[MSG_GAP][pMenuCfg->Language], (FLOAT)0, (FLOAT)0);
break;
case INFO_PEEL_MODE:
if ( pMenuCfg->PrintOutMode == PEEL_MODE )
sprintf( InfoStr,"%s", LCDMessage[MSG_PEEL_ON][pMenuCfg->Language]);
else
sprintf( InfoStr,"%s", LCDMessage[MSG_PEEL_OFF][pMenuCfg->Language]);
break;
case INFO_CUT_MODE:
if ( pMenuCfg->PrintOutMode == CUTTER_MODE )
sprintf( InfoStr,"%s", LCDMessage[MSG_CUTTER_ON ][pMenuCfg->Language]);
else
sprintf( InfoStr,"%s", LCDMessage[MSG_CUTTER_OFF][pMenuCfg->Language]);
break;
case INFO_RIBBON:
if ( pMenuCfg->RibbonFlag )
sprintf( InfoStr,"%s", LCDMessage[MSG_RIBBON_ON ][pMenuCfg->Language]);
else
sprintf( InfoStr,"%s", LCDMessage[MSG_RIBBON_OFF][pMenuCfg->Language]);
break;
case INFO_MILLAGE:
sprintf( InfoStr,"%s%.2f", LCDMessage[MSG_MILAGE][pMenuCfg->Language], (FLOAT)pMenuRec->DotMilage / (MM_DOT * 1000000));
break;
}
ShowLCDString(0,1,InfoStr,0);
}
VOID DispatchSubMenuFileInfo(_MenuKey *pMenuKey)
{
DspClearLine(1, LCD_LANG_ENG);
if ( pMenuKey->FeedKeyIndex == FileTotal )
ShowMessage(0, 1, MSG_END_OF_FILE, 0);
else
{
while ( !NextFile(&FileList, "*.*") )
{
if ( ListDevice == DRAM_DEVICE )
ListDevice = FLASH_DEVICE;
else if ( ListDevice == FLASH_DEVICE )
ListDevice = CARD_DEVICE;
else if ( ListDevice == CARD_DEVICE )
ListDevice = DRAM_DEVICE;
OpenList(&FileList, ListDevice);
}
ShowLCDString(0, 1, FileList.FileName, 0);
}
}
VOID DispatchSubMenuMemoryInfo(_MenuKey *pMenuKey)
{
CHAR InfoStr[256];
DspClearLine(1, LCD_LANG_ENG);
switch ( pMenuKey->FeedKeyIndex )
{
case MEMORY_SIZE_TOTAL:
sprintf( InfoStr,"%s%4dK", LCDMessage[MSG_MEMORY_TOTAL][pMenuCfg->Language], TotalSpace( DRAM_DEVICE ));
break;
case MEMORY_SIZE_REMAIN:
sprintf( InfoStr,"%s%4dK", LCDMessage[MSG_MEMORY_REMAIN][pMenuCfg->Language], FreeSpace( DRAM_DEVICE ));
break;
}
ShowLCDString(0,1,InfoStr,0);
}
VOID DispatchSubMenuDateTimeInfo(_MenuKey *pMenuKey)
{
CHAR InfoStr[256];
DspClearLine(1, LCD_LANG_ENG);
switch ( pMenuKey->FeedKeyIndex )
{
case INFO_DATE:
sprintf( InfoStr, "%s%4d/%2d/%2d", LCDMessage[MSG_DATE][pMenuCfg->Language],
GetRTC(RTC_YEAR), GetRTC(RTC_MONTH), GetRTC(RTC_DATE) );
break;
case INFO_TIME:
sprintf( InfoStr, "%s%2d:%2d", LCDMessage[MSG_TIME][pMenuCfg->Language],
GetRTC(RTC_HOUR), GetRTC(RTC_MIN) );
break;
}
ShowLCDString(0,1,InfoStr,0);
}
VOID DispatchSubMenuPrintSetup(_MenuKey *pMenuKey)
{
CHAR InfoStr[256];
DspClearLine(1, LCD_LANG_ENG);
switch ( pMenuKey->FeedKeyIndex )
{
case SETUP_LANGUAGE:
sprintf( InfoStr,"%s", LCDMessage[MSG_LANG][pMenuCfg->Language]);
break;
case SETUP_SPEED:
sprintf( InfoStr,"%s%s", LCDMessage[MSG_SPEED][pMenuCfg->Language], ToSpeedString(pMenuCfg->Speed));
break;
case SETUP_DENSITY:
sprintf( InfoStr,"%s%d", LCDMessage[MSG_DENSITY][pMenuCfg->Language], (INT)pMenuCfg->fDensity);
break;
case SETUP_BAUD:
sprintf( InfoStr,"%s%s", LCDMessage[MSG_BAUD_RATE][pMenuCfg->Language], COM_BAUD_FULL[pMenuCfg->UartSetting.Baud]);
break;
case SETUP_PARITY:
sprintf( InfoStr,"%s%s", LCDMessage[MSG_PARITY][pMenuCfg->Language], COM_PARITY_FULL[pMenuCfg->UartSetting.Parity]);
break;
case SETUP_DATABITS:
sprintf( InfoStr,"%s%s", LCDMessage[MSG_DATA_BITS][pMenuCfg->Language], COM_DATABITS[pMenuCfg->UartSetting.DataBits]);
break;
case SETUP_STOPBIT:
sprintf( InfoStr,"%s%s", LCDMessage[MSG_STOP_BIT][pMenuCfg->Language], COM_STOP[pMenuCfg->UartSetting.Stop]);
break;
}
ShowLCDString(0,1,InfoStr,0);
}
VOID DispatchSubMenuRotateCutter(_MenuKey *pMenuKey)
{
CHAR InfoStr[256];
DspClearLine(1, LCD_LANG_ENG);
sprintf( InfoStr,"- +");
ShowLCDString(7,1,InfoStr,0);
}
INT DispatchSubMenu(_MenuKey *pMenuKey)
{
switch ( pMenuKey->MenuKeyIndex )
{
case MAIN_SHOW_PRINT_INFO:
DispatchSubMenuInfo(pMenuKey);
break;
case MAIN_SHOW_FILE_INFO:
DispatchSubMenuFileInfo(pMenuKey);
break;
case MAIN_SHOW_MEMORY_INFO:
DispatchSubMenuMemoryInfo(pMenuKey);
break;
case MAIN_SHOW_DATE_TIME:
DispatchSubMenuDateTimeInfo(pMenuKey);
break;
case MAIN_PRINT_SETUP:
DispatchSubMenuPrintSetup(pMenuKey);
break;
case MAIN_ROTATE_CUTTER:
DispatchSubMenuRotateCutter(pMenuKey);
break;
default:
return FALSE;
}
return TRUE;
}
INT DispatchMainMenu(_MenuKey *pMenuKey)
{
DspClearLine(0, LCD_LANG_ENG);
switch ( pMenuKey->MenuKeyIndex )
{
case MAIN_SHOW_PRINT_INFO:
ShowMessage(0,0, MSG_PRINTER_INFO, 0);
break;
case MAIN_SHOW_FILE_INFO:
ShowMessage(0,0, MSG_FILE_LIST, 0);
break;
case MAIN_SHOW_MEMORY_INFO:
ShowMessage(0,0, MSG_MEMORY_INFO, 0);
break;
case MAIN_SHOW_DATE_TIME:
ShowMessage(0,0, MSG_DATE_TIME, 0);
break;
case MAIN_PRINT_SETUP:
ShowMessage(0,0, MSG_PRINTER_SETUP, 0);
break;
case MAIN_ROTATE_CUTTER:
if ( pMenuCfg->PrintOutMode != CUTTER_MODE )
return FALSE;
ShowMessage(0,0, MSG_ROTATE_CUTTER, 0);
break;
default:
return FALSE;
}
DispatchSubMenu(pMenuKey);
return TRUE;
}
INT CheckMenuKeyItem( _MenuKey *pMenuKey, INT PressKey )
{
if ( pMenuKey->MenuKeyIndex != MAIN_ROTATE_CUTTER || PressKey == MENU_KEY )
{
sysprintf("CheckMenuKeyItem\r\n");
EnableBuzzer(26, 100);
while ( CheckBuzzerStatus() ){}
}
// Menu key press
if ( PressKey == MENU_KEY )
{
pMenuKey->MenuKeyIndex += 1;
pMenuKey->PauseKeyIndex = 0;
pMenuKey->FeedKeyIndex = 0;
return TRUE;
}
// Feed key press
else if ( PressKey == FEED_KEY )
{
switch ( pMenuKey->MenuKeyIndex )
{
case MAIN_SHOW_PRINT_INFO:
pMenuKey->FeedKeyIndex += 1;
if ( pMenuKey->FeedKeyIndex >= INFO_ITEM_TOTAL )
pMenuKey->FeedKeyIndex = 0;
return TRUE;
case MAIN_SHOW_FILE_INFO:
pMenuKey->FeedKeyIndex += 1;
if ( pMenuKey->FeedKeyIndex > FileTotal )
pMenuKey->FeedKeyIndex = 0;
return TRUE;
case MAIN_SHOW_MEMORY_INFO:
pMenuKey->FeedKeyIndex += 1;
if ( pMenuKey->FeedKeyIndex >= MEMORY_ITEM_TOATL )
pMenuKey->FeedKeyIndex = 0;
return TRUE;
case MAIN_SHOW_DATE_TIME:
pMenuKey->FeedKeyIndex += 1;
if ( pMenuKey->FeedKeyIndex >= DATE_TIME_TOTAL )
pMenuKey->FeedKeyIndex = 0;
return TRUE;
case MAIN_PRINT_SETUP:
pMenuKey->FeedKeyIndex += 1;
if ( pMenuKey->FeedKeyIndex >= SETUP_TOTAL )
pMenuKey->FeedKeyIndex = 0;
return TRUE;
case MAIN_ROTATE_CUTTER:
EnableCutter(CUT_DIR_FORWARD);
while ( CheckKeyPin(FEED_KEY) );
DisableCutter();
return TRUE;
}
}
// Pause key press
else if ( PressKey == PAUSE_KEY && pMenuKey->MenuKeyIndex == MAIN_PRINT_SETUP)
{
switch ( pMenuKey->FeedKeyIndex )
{
case SETUP_LANGUAGE:
pMenuCfg->Language += 1;
if (pMenuCfg->Language >= LANGUAGE_TOTAL)
pMenuCfg->Language = 0;
return TRUE;
case SETUP_SPEED:
pMenuCfg->Speed += 1;
if (pMenuCfg->Speed > PRINT_SPEED_MAX)
pMenuCfg->Speed = PRINT_SPEED_MIN;
return TRUE;
case SETUP_DENSITY:
pMenuCfg->fDensity += (FLOAT)1;
if (pMenuCfg->fDensity > DensityMax)
pMenuCfg->fDensity = DensityMin;
return TRUE;
case SETUP_BAUD:
pMenuCfg->UartSetting.Baud += 1;
if (pMenuCfg->UartSetting.Baud > UART_BAUD_38400)
pMenuCfg->UartSetting.Baud = UART_BAUD_1200;
return TRUE;
case SETUP_PARITY:
pMenuCfg->UartSetting.Parity += 1;
if (pMenuCfg->UartSetting.Parity > UART_PARITY_EVEN)
pMenuCfg->UartSetting.Parity = UART_PARITY_NONE;
return TRUE;
case SETUP_DATABITS:
pMenuCfg->UartSetting.DataBits += 1;
if (pMenuCfg->UartSetting.DataBits > UART_DATA_8)
pMenuCfg->UartSetting.DataBits= UART_DATA_7;
return TRUE;
case SETUP_STOPBIT:
pMenuCfg->UartSetting.Stop += 1;
if (pMenuCfg->UartSetting.Stop > UART_STOP_TWO)
pMenuCfg->UartSetting.Stop= UART_STOP_ONE;
return TRUE;
}
}
// Pause key press
else if ( PressKey == PAUSE_KEY && pMenuKey->MenuKeyIndex == MAIN_ROTATE_CUTTER )
{
EnableCutter(CUT_DIR_BACKWARD);
while ( CheckKeyPin(PAUSE_KEY) );
DisableCutter();
return TRUE;
}
return FALSE;
}
VOID MainMenu(VOID)
{
_MenuKey MenuKey;
INT PressKey;
ClrDisplayStatus(DIS_READY);
#if defined(CARRIAGE_OPEN_MODEL)
StopCheckCarriageOpen();
#endif
StopKeyFunc();
InitialMenu();
sysprintf("InitialMenu1\r\n");
EnableBuzzer(26, 100);
while ( CheckBuzzerStatus() ){}
MenuKey.FeedKeyIndex = 0;
MenuKey.PauseKeyIndex = 0;
MenuKey.MenuKeyIndex = 0;
DspClearDisplay();
DispatchMainMenu(&MenuKey);
while (1)
{
PressKey = MenuWaitKey();
if ( CheckMenuKeyItem( &MenuKey, PressKey ) )
{
if ( PressKey == MENU_KEY )
{
// dispatch menu key == flase is exit
if ( !DispatchMainMenu(&MenuKey) )
break;
}
else if ( PressKey == FEED_KEY )
{
DispatchSubMenu(&MenuKey);
}
if ( ( PressKey == PAUSE_KEY ) && ( MenuKey.MenuKeyIndex == MAIN_PRINT_SETUP ) )
{
DispatchSubMenu(&MenuKey);
}
}
}
StartKeyFunc(TRUE);
#if defined(CARRIAGE_OPEN_MODEL)
StartCheckCarriageOpen();
#endif
SetDisplayStatus(DIS_READY);
}
#endif
MenuVer2.c 。。。。。。。。。。。。。。。。。。。。。。。。。。。
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define MENUVER2_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 <string.h>
#include <stdlib.h>
#include <ctype.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 "XTask.h"
#include "XVarBank.h"
#include "XADC.h"
#include "XLED.h"
#include "XKey.h"
#include "XBuzzer.h"
#include "XTimer.h"
#include "XPrtEng.h"
#include "XFileSys.h"
#include "XDisplay.h"
#include "XCodePage.h"
#include "XFunction.h"
#include "Tspl\TsplFunc.h"
#include "Tspl\TsplUtil.h"
#include "Bsc\BscReport.h"
#include "Menu.h"
/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/
#if defined(LCD_MODEL) && defined(MENU_TSPL_2)
/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/
typedef struct
{
VOID (*DspFunc)(VOID);
VOID (*MenuFunc)(VOID *);
VOID (*PauseFunc)(VOID *);
VOID (*FeedFunc)(VOID *);
}_MenuItem;
/******************************************************************************
* *
* L O C A L F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
CONST STATIC CHAR *COM_BAUD_FULL[] =
{
"0",
"1200",
"2400",
"4800",
"9600",
"19200",
"38400",
"57600",
"115200",
};
CONST STATIC CHAR *COM_DATABITS[] =
{
"7",
"8",
};
CONST STATIC CHAR *COM_STOP[] =
{
"1",
"2",
};
/******************************************************************************
* *
* 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 _PrintCfg *pMenuCfg; // priner config data point
STATIC _PrintRecord* pMenuRec; // printer record
STATIC INT CodePageTotal;
STATIC INT CountryTotal;
STATIC _FileList DramList;
STATIC INT DramFile;
STATIC _FileList FlashList;
STATIC INT FlashFile;
STATIC _FileList CardList;
STATIC INT CardFile;
STATIC BOOL RotateTimes;
STATIC VOID InitialMenu(VOID)
{
pMenuCfg = GrabPrintConfig();
pMenuRec = GrabPrintRecord();
CodePageTotal = GetCodePageTotal();
CountryTotal = GetCountryTotal();
}
STATIC INT AddItemValue(INT Data, INT Step, INT Max, INT Min)
{
Data += Step;
if ( Data > Max )
Data = Min;
if ( Data < Min )
Data = Max;
return Data;
}
STATIC INT GetPrintOutMode(VOID)
{
if (pMenuCfg->PrintOutMode == PEEL_MODE)
return 1;
else if ( pMenuCfg->PrintOutMode == CUTTER_MODE && pMenuCfg->CutterPieces )
return 2;
else if ( pMenuCfg->PrintOutMode == CUTTER_MODE && pMenuCfg->CutterPieces == 0 )
return 3;
else
return 0;
}
STATIC VOID SetPrintOutMode(INT Kind)
{
if ( Kind > 3 )
Kind = 0;
if ( Kind < 0 )
Kind = 3;
switch ( Kind )
{
case 0:
pMenuCfg->PrintOutMode = TEAR_MODE;
break;
case 1:
pMenuCfg->PrintOutMode = PEEL_MODE;
break;
case 2:
pMenuCfg->PrintOutMode = CUTTER_MODE;
pMenuCfg->CutterPieces = 1;
break;
case 3:
pMenuCfg->PrintOutMode = CUTTER_MODE;
pMenuCfg->CutterPieces = 0;
break;
}
}
STATIC INT MenuWaitKey(VOID)
{
INT Status;
delay_msec(150);
while (1)
{
if ( CheckKeyPin(FEED_KEY) )
{
Status = FEED_KEY;
break;
}
if ( CheckKeyPin(PAUSE_KEY) )
{
Status = PAUSE_KEY;
break;
}
if ( CheckKeyPin(MENU_KEY) )
{
Status = MENU_KEY;
break;
}
}
sysprintf("MenuWaitKey\r\n");
EnableBuzzer(26, 100);
return Status;
}
STATIC VOID RunMenu(CONST _MenuItem *ItemIndex, INT def, CHAR **Title)
{
INT Total, Index;
CHAR buf[20];
// caculate total item
Total = 0;
while ( (ItemIndex + Total)->DspFunc )
Total += 1;
if ( ( def < Total ) && (ItemIndex + def)->DspFunc )
Index = def;
else
Index = 0;
while ( 1 )
{
if ( Index >= Total )
Index = 0;
if ( Index < 0 )
Index = Total - 1;
while ( CheckBuzzerStatus() ){}
DspClearDisplay();
sprintf(buf, "%-12s%1d/%1d", *(Title + pMenuCfg->Language), Index + 1, Total);
ShowLCDString(0, 0, buf, 0);
if ( (ItemIndex + Index)->DspFunc )
(ItemIndex + Index)->DspFunc();
switch ( MenuWaitKey() )
{
case MENU_KEY:
if ( (ItemIndex + Index)->MenuFunc )
(ItemIndex + Index)->MenuFunc(&Index);
else
return;
break;
case PAUSE_KEY:
if ( (ItemIndex + Index)->PauseFunc )
(ItemIndex + Index)->PauseFunc(&Index);
else
return;
break;
case FEED_KEY:
if ( (ItemIndex + Index)->FeedFunc )
(ItemIndex + Index)->FeedFunc(&Index);
else
return;
break;
}
}
}
STATIC VOID EntryMenuFunc(VOID)
{
WaitWorkJobEnd();
#if defined(CARRIAGE_OPEN_MODEL)
StopCheckCarriageOpen();
#endif
StopKeyFunc();
}
STATIC VOID LeaveMenuFunc(VOID)
{
delay_msec(200);
GetKey(MENU_KEY);
GetKey(PAUSE_KEY);
GetKey(FEED_KEY);
StartKeyFunc(TRUE);
#if defined(CARRIAGE_OPEN_MODEL)
StartCheckCarriageOpen();
#endif
}
STATIC VOID MenuNextItem(VOID *Num)
{
*(INT *)Num += 1;
}
STATIC VOID MenuBackItem(VOID *Num)
{
*(INT *)Num -= 1;
}
STATIC VOID MenuNULLKey(VOID *Num)
{
DisableBuzzer();
}
STATIC VOID MenuDspExit(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_EXIT][pMenuCfg->Language], 0);
}
STATIC VOID MenuSpeedNext(VOID *Num)
{
pMenuCfg->Speed = AddItemValue(pMenuCfg->Speed, 1, PRINT_SPEED_MAX, PRINT_SPEED_MIN);
}
STATIC VOID MenuSpeedBack(VOID *Num)
{
pMenuCfg->Speed = AddItemValue(pMenuCfg->Speed, -1, PRINT_SPEED_MAX, PRINT_SPEED_MIN);
}
STATIC VOID MenuDensityNext(VOID *Num)
{
pMenuCfg->fDensity = (FLOAT)AddItemValue((INT)pMenuCfg->fDensity, 1, DensityMax, DensityMin);
}
STATIC VOID MenuDensityBack(VOID *Num)
{
pMenuCfg->fDensity = (FLOAT)AddItemValue((INT)pMenuCfg->fDensity, -1, DensityMax, DensityMin);
}
STATIC VOID MenuDirectionNext(VOID *Num)
{
pMenuCfg->Direction = AddItemValue(pMenuCfg->Direction, 1, 1, 0);
}
STATIC VOID MenuDirectionBack(VOID *Num)
{
pMenuCfg->Direction = AddItemValue(pMenuCfg->Direction, -1, 1, 0);
}
STATIC VOID MenuPrintOutModeNext(VOID *Num)
{
SetPrintOutMode( GetPrintOutMode() + 1);
}
STATIC VOID MenuPrintOutModeBack(VOID *Num)
{
SetPrintOutMode( GetPrintOutMode() - 1);
}
STATIC VOID MenuOffsetNext(VOID *Num)
{
DisableBuzzer();
pMenuCfg->OffsetDis = AddItemValue(pMenuCfg->OffsetDis, 1, (INT)TPH_DPI, 0 - (INT)TPH_DPI);
}
STATIC VOID MenuOffsetBack(VOID *Num)
{
DisableBuzzer();
pMenuCfg->OffsetDis = AddItemValue(pMenuCfg->OffsetDis, -1, (INT)TPH_DPI, 0 - (INT)TPH_DPI);
}
STATIC VOID MenuReferenceXNext(VOID *Num)
{
DisableBuzzer();
pMenuCfg->ReferenceX = AddItemValue(pMenuCfg->ReferenceX, 1, 999, 0);
}
STATIC VOID MenuReferenceXBack(VOID *Num)
{
DisableBuzzer();
pMenuCfg->ReferenceX = AddItemValue(pMenuCfg->ReferenceX, -1, 999, 0);
}
STATIC VOID MenuReferenceYNext(VOID *Num)
{
DisableBuzzer();
pMenuCfg->ReferenceY = AddItemValue(pMenuCfg->ReferenceY, 1, 999, 0);
}
STATIC VOID MenuReferenceYBack(VOID *Num)
{
DisableBuzzer();
pMenuCfg->ReferenceY = AddItemValue(pMenuCfg->ReferenceY, -1, 999, 0);
}
STATIC VOID MenuDspSpeed(VOID)
{
CHAR Buf[20];
sprintf(Buf, "%s %s \"/S", LCDMessage[MSG_SPEED][pMenuCfg->Language], ToSpeedString(pMenuCfg->Speed));
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuDspDensity(VOID)
{
CHAR Buf[20];
sprintf(Buf, "%s %d", LCDMessage[MSG_DENSITY][pMenuCfg->Language], (INT)pMenuCfg->fDensity);
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuDspDirection(VOID)
{
CHAR Buf[20];
sprintf(Buf, "%s %d", LCDMessage[MSG_DIRECTION][pMenuCfg->Language], pMenuCfg->Direction);
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuDspPrintOutMode(VOID)
{
INT mode = GetPrintOutMode();
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_TEAR_MODE + mode][pMenuCfg->Language], 0);
}
STATIC VOID MenuDspOffset(VOID)
{
CHAR Buf[20];
sprintf(Buf, "%s %+04d", LCDMessage[MSG_OFFSET][pMenuCfg->Language], pMenuCfg->OffsetDis);
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuDspReferenceY(VOID)
{
CHAR Buf[20];
sprintf(Buf, "%s %03d", LCDMessage[MSG_REFERENCE_Y][pMenuCfg->Language], pMenuCfg->ReferenceY);
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuDspReferenceX(VOID)
{
CHAR Buf[20];
sprintf(Buf, "%s %03d", LCDMessage[MSG_REFERENCE_X][pMenuCfg->Language], pMenuCfg->ReferenceX);
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuSetup(VOID *Num)
{
CONST STATIC _MenuItem MenuItem[] =
{
{MenuDspSpeed, MenuNextItem, MenuSpeedNext, MenuSpeedBack},
{MenuDspDensity, MenuNextItem, MenuDensityNext, MenuDensityBack},
{MenuDspDirection, MenuNextItem, MenuDirectionNext, MenuDirectionBack},
{MenuDspPrintOutMode, MenuNextItem, MenuPrintOutModeNext, MenuPrintOutModeBack},
{MenuDspOffset, MenuNextItem, MenuOffsetNext, MenuOffsetBack},
{MenuDspReferenceX, MenuNextItem, MenuReferenceXNext, MenuReferenceXBack},
{MenuDspReferenceY, MenuNextItem, MenuReferenceYNext, MenuReferenceYBack},
{MenuDspExit, MenuNextItem, _NULL, MenuBackItem},
{_NULL, _NULL, _NULL, _NULL},
};
RunMenu(MenuItem , 0, (CHAR **)LCDMessage[MSG_PRINTER]);
}
STATIC VOID MenuManualGapNext(VOID *Num)
{
pMenuCfg->GapInten = AddItemValue(pMenuCfg->GapInten, 1, GAP_SENSOR_SCALE - 1, 0);
InitialCalibration();
}
STATIC VOID MenuManualGapBack(VOID *Num)
{
pMenuCfg->GapInten = AddItemValue(pMenuCfg->GapInten, -1, GAP_SENSOR_SCALE - 1, 0);
InitialCalibration();
}
STATIC VOID MenuManualBlineNext(VOID *Num)
{
pMenuCfg->BlineInten = AddItemValue(pMenuCfg->BlineInten, 1, BLINE_SENSOR_SCALE - 1, 0);
InitialCalibration();
}
STATIC VOID MenuManualBlineBack(VOID *Num)
{
pMenuCfg->BlineInten = AddItemValue(pMenuCfg->BlineInten, -1, BLINE_SENSOR_SCALE - 1, 0);
InitialCalibration();
}
STATIC VOID MenuManualRibbonNext(VOID *Num)
{
pMenuCfg->RibbonInten = AddItemValue(pMenuCfg->RibbonInten, 1, RIBBON_SENSOR_SCALE - 1, 0);
}
STATIC VOID MenuManualRibbonBack(VOID *Num)
{
pMenuCfg->RibbonInten = AddItemValue(pMenuCfg->RibbonInten, -1, RIBBON_SENSOR_SCALE - 1, 0);
}
STATIC VOID MenuAutoGap(VOID *Num)
{
#ifdef DEBUG_PRNT
sysprintf("Enter MenuAutoGap()...\n"); // ch_20211208
#endif
LeaveMenuFunc();
pMenuCfg->SensorMode = GAP_MODE;
DetectSensorInten(pMenuCfg, TRUE, FALSE, 0, 0);
EntryMenuFunc();
}
STATIC VOID MenuAutoBline(VOID *Num)
{
#ifdef DEBUG_PRNT
sysprintf("Enter MenuAutoBline()...\n"); // ch_20211208
#endif
LeaveMenuFunc();
pMenuCfg->SensorMode = BLINE_MODE;
DetectSensorInten(pMenuCfg, TRUE, FALSE, 0, 0);
EntryMenuFunc();
}
STATIC VOID MenuAutoRibbon(VOID *Num)
{
DetectRibbonInten();
}
STATIC VOID DspGapSensor(VOID)
{
STATIC INT PreSignal = SENSOR_FLOATING;
INT Signal;
CHAR Buf[20];
Signal = GetSensorSignal(GAP_SENSOR);
if ( PreSignal == Signal )
return;
PreSignal = Signal;
if ( Signal == SENSOR_DETECTED )
sprintf(Buf, "%-11s", LCDMessage[MSG_THROUGH][pMenuCfg->Language]);
else
sprintf(Buf, "%-11s", LCDMessage[MSG_NOT_THROUGH][pMenuCfg->Language]);
ShowLCDString(4, 1, Buf, 0);
}
STATIC VOID DspBlineSensor(VOID)
{
STATIC INT PreSignal = SENSOR_FLOATING;
INT Signal;
CHAR Buf[20];
Signal = GetSensorSignal(BLINE_SENSOR);
if ( PreSignal == Signal )
return;
PreSignal = Signal;
if ( Signal == SENSOR_DETECTED )
sprintf(Buf, "%-11s", LCDMessage[MSG_REFLECTED][pMenuCfg->Language]);
else
sprintf(Buf, "%-11s", LCDMessage[MSG_NOT_REFLECTE][pMenuCfg->Language]);
ShowLCDString(4, 1, Buf, 0);
}
STATIC VOID DspRibbonSensor(VOID)
{
STATIC INT PreSignal = SENSOR_FLOATING;
INT Signal;
CHAR Buf[20];
Signal = GetSensorSignal(RIBBON_SENSOR);
if ( PreSignal == Signal )
return;
PreSignal = Signal;
if ( Signal == SENSOR_DETECTED )
sprintf(Buf, "%-11s", LCDMessage[MSG_THROUGH][pMenuCfg->Language]);
else
sprintf(Buf, "%-11s", LCDMessage[MSG_NOT_THROUGH][pMenuCfg->Language]);
ShowLCDString(4, 1, Buf, 0);
}
STATIC VOID MenuDspManualGap(VOID)
{
CHAR Buf[20];
EnableSensor(GAP_SENSOR, pMenuCfg->GapInten, pMenuCfg->RibbonFlag, HALF_AD_SCALE);
CancelPeriodFunc(DspGapSensor);
DspClearLine(0, LCD_LANG_ENG);
ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_MANUAL_GAP][pMenuCfg->Language], 0);
if ( GetSensorSignal(GAP_SENSOR) == SENSOR_DETECTED )
sprintf(Buf, "%03d %s", pMenuCfg->GapInten, LCDMessage[MSG_THROUGH][pMenuCfg->Language]);
else
sprintf(Buf, "%03d %s", pMenuCfg->GapInten, LCDMessage[MSG_NOT_THROUGH][pMenuCfg->Language]);
ShowLCDString(0, 1, Buf, 0);
StartPeriodFunc(DspGapSensor);
}
STATIC VOID MenuDspManualBline(VOID)
{
CHAR Buf[20];
EnableSensor(BLINE_SENSOR, pMenuCfg->BlineInten, pMenuCfg->RibbonFlag, HALF_AD_SCALE);
CancelPeriodFunc(DspBlineSensor);
DspClearLine(0, LCD_LANG_ENG);
ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_MANUAL_BLINE][pMenuCfg->Language], 0);
if ( GetSensorSignal(BLINE_SENSOR) == SENSOR_DETECTED )
sprintf(Buf, "%03d %s", pMenuCfg->BlineInten, LCDMessage[MSG_REFLECTED][pMenuCfg->Language]);
else
sprintf(Buf, "%03d %s", pMenuCfg->BlineInten, LCDMessage[MSG_NOT_REFLECTE][pMenuCfg->Language]);
ShowLCDString(0, 1, Buf, 0);
StartPeriodFunc(DspBlineSensor);
}
STATIC VOID MenuDspManualRibbon(VOID)
{
CHAR Buf[20];
EnableSensor(RIBBON_SENSOR, pMenuCfg->RibbonInten, 0, HALF_AD_SCALE);
CancelPeriodFunc(DspRibbonSensor);
DspClearLine(0, LCD_LANG_ENG);
ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_MANUAL_RIBBON][pMenuCfg->Language], 0);
if ( GetSensorSignal(RIBBON_SENSOR) == SENSOR_DETECTED )
sprintf(Buf, "%03d %s", pMenuCfg->RibbonInten, LCDMessage[MSG_THROUGH][pMenuCfg->Language]);
else
sprintf(Buf, "%03d %s", pMenuCfg->RibbonInten, LCDMessage[MSG_NOT_THROUGH][pMenuCfg->Language]);
ShowLCDString(0, 1, Buf, 0);
StartPeriodFunc(DspRibbonSensor);
}
STATIC VOID MenuDspAutoGap(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_AUTO_GAP][pMenuCfg->Language], 0);
}
STATIC VOID MenuDspAutoBline(VOID)
{
DisableSensor(GAP_SENSOR);
CancelPeriodFunc(DspGapSensor);
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_AUTO_BLINE][pMenuCfg->Language], 0);
}
STATIC VOID MenuDspAutoRibbon(VOID)
{
DisableSensor(BLINE_SENSOR);
CancelPeriodFunc(DspBlineSensor);
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_AUTO_RIBBON][pMenuCfg->Language], 0);
}
STATIC VOID MenuDspSensorExit(VOID)
{
DisableSensor(RIBBON_SENSOR);
CancelPeriodFunc(DspRibbonSensor);
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_EXIT][pMenuCfg->Language], 0);
}
STATIC VOID MenuSensor(VOID *Num)
{
CONST STATIC _MenuItem MenuItem[] =
{
{MenuDspAutoGap, MenuNextItem, MenuAutoGap, MenuNULLKey},
{MenuDspManualGap, MenuNextItem, MenuManualGapNext, MenuManualGapBack},
{MenuDspAutoBline, MenuNextItem, MenuAutoBline, MenuNULLKey},
{MenuDspManualBline, MenuNextItem, MenuManualBlineNext, MenuManualBlineBack},
{MenuDspAutoRibbon, MenuNextItem, MenuAutoRibbon, MenuNULLKey},
{MenuDspManualRibbon, MenuNextItem, MenuManualRibbonNext, MenuManualRibbonBack},
{MenuDspSensorExit, MenuNextItem, _NULL, MenuBackItem},
{_NULL, _NULL, _NULL, _NULL},
};
RunMenu(MenuItem , 0, (CHAR **)LCDMessage[MSG_SENSOR]);
}
STATIC VOID MenuLanguageNext(VOID *Num)
{
pMenuCfg->Language = AddItemValue(pMenuCfg->Language, 1, LANGUAGE_TOTAL - 1, 0);
}
STATIC VOID MenuLanguageBack(VOID *Num)
{
pMenuCfg->Language = AddItemValue(pMenuCfg->Language, -1, LANGUAGE_TOTAL - 1, 0);
}
STATIC VOID MenuCodePageNext(VOID *Num)
{
pMenuCfg->CodePage = AddItemValue(pMenuCfg->CodePage, 1, CodePageTotal - 1, 0);
}
STATIC VOID MenuCodePageBack(VOID *Num)
{
pMenuCfg->CodePage = AddItemValue(pMenuCfg->CodePage, -1, CodePageTotal - 1, 0);
}
STATIC VOID MenuCountryNext(VOID *Num)
{
pMenuCfg->Country = AddItemValue(pMenuCfg->Country, 1, CountryTotal - 1, 0);
}
STATIC VOID MenuCountryBack(VOID *Num)
{
pMenuCfg->Country = AddItemValue(pMenuCfg->Country, -1, CountryTotal - 1, 0);
}
STATIC VOID MenuBaudNext(VOID *Num)
{
pMenuCfg->UartSetting.Baud = AddItemValue(pMenuCfg->UartSetting.Baud, 1, UART_BAUD_38400, UART_BAUD_2400);
}
STATIC VOID MenuBaudBack(VOID *Num)
{
pMenuCfg->UartSetting.Baud = AddItemValue(pMenuCfg->UartSetting.Baud, -1, UART_BAUD_38400, UART_BAUD_2400);
}
STATIC VOID MenuParityNext(VOID *Num)
{
pMenuCfg->UartSetting.Parity = AddItemValue(pMenuCfg->UartSetting.Parity, 1, UART_PARITY_EVEN, UART_PARITY_NONE);
}
STATIC VOID MenuParityBack(VOID *Num)
{
pMenuCfg->UartSetting.Parity = AddItemValue(pMenuCfg->UartSetting.Parity, -1, UART_PARITY_EVEN, UART_PARITY_NONE);
}
STATIC VOID MenuDataBitsNext(VOID *Num)
{
pMenuCfg->UartSetting.DataBits = AddItemValue(pMenuCfg->UartSetting.DataBits, 1, UART_DATA_8, UART_DATA_7);
}
STATIC VOID MenuDataBitsBack(VOID *Num)
{
pMenuCfg->UartSetting.DataBits = AddItemValue(pMenuCfg->UartSetting.DataBits, -1, UART_DATA_8, UART_DATA_7);
}
STATIC VOID MenuStopBitsNext(VOID *Num)
{
pMenuCfg->UartSetting.Stop = AddItemValue(pMenuCfg->UartSetting.Stop, 1, UART_STOP_TWO, UART_STOP_ONE);
}
STATIC VOID MenuStopBitsBack(VOID *Num)
{
pMenuCfg->UartSetting.Stop = AddItemValue(pMenuCfg->UartSetting.Stop, -1, UART_STOP_TWO, UART_STOP_ONE);
}
STATIC VOID MenuDspBaudRate(VOID)
{
CHAR Buf[20];
sprintf(Buf, "%s %s", LCDMessage[MSG_BAUD_RATE][pMenuCfg->Language], COM_BAUD_FULL[pMenuCfg->UartSetting.Baud]);
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuDspParity(VOID)
{
if ( pMenuCfg->UartSetting.Parity == 0 )
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_PARITY_NONE][pMenuCfg->Language], 0);
if ( pMenuCfg->UartSetting.Parity == 1 )
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_PARITY_ODD][pMenuCfg->Language], 0);
if ( pMenuCfg->UartSetting.Parity == 2 )
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_PARITY_EVEN][pMenuCfg->Language], 0);
}
STATIC VOID MenuDspDataBits(VOID)
{
CHAR Buf[20];
sprintf(Buf, "%s %s", LCDMessage[MSG_DATA_BITS][pMenuCfg->Language], COM_DATABITS[pMenuCfg->UartSetting.DataBits]);
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuDspStopBits(VOID)
{
CHAR Buf[20];
sprintf(Buf, "%s %s", LCDMessage[MSG_STOP_BITS][pMenuCfg->Language], COM_STOP[pMenuCfg->UartSetting.Stop]);
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuRS232Setup(VOID *Num)
{
CONST STATIC _MenuItem MenuItem[] =
{
{MenuDspBaudRate, MenuNextItem, MenuBaudNext, MenuBaudBack},
{MenuDspParity, MenuNextItem, MenuParityNext, MenuParityBack},
{MenuDspDataBits, MenuNextItem, MenuDataBitsNext, MenuDataBitsBack},
{MenuDspStopBits, MenuNextItem, MenuStopBitsNext, MenuStopBitsBack},
{MenuDspExit, MenuNextItem, _NULL, MenuBackItem},
{_NULL, _NULL, _NULL, _NULL},
};
RunMenu(MenuItem , 0, (CHAR **)LCDMessage[MSG_RS232_SETUP]);
UartSetting(pMenuCfg->UartSetting);
}
STATIC VOID MenuRestoreDef(VOID *Num)
{
InitialDefaultVar();
}
STATIC VOID MenuDspLanguage(VOID)
{
CHAR Buf[20];
sprintf(Buf, "%s %s", LCDMessage[MSG_LANG][pMenuCfg->Language], LCDMessage[MSG_LANG_DATA][pMenuCfg->Language]);
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuDspCodePage(VOID)
{
CHAR Buf[20];
sprintf(Buf, "%s %s", LCDMessage[MSG_CODEPAGE][pMenuCfg->Language], CodePageNameTable[pMenuCfg->CodePage]);
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuDspCountry(VOID)
{
CHAR Buf[20];
sprintf(Buf, "%s %s", LCDMessage[MSG_COUNTRY][pMenuCfg->Language], CountryNameTable[pMenuCfg->Country]);
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuDspRS232Setup(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_RS232_SETUP][pMenuCfg->Language], 0);
}
STATIC VOID MenuDspRestoreDef(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_RESTORE][pMenuCfg->Language], 0);
}
STATIC VOID MenuSystem(VOID *Num)
{
CONST STATIC _MenuItem MenuItem[] =
{
{MenuDspLanguage, MenuNextItem, MenuLanguageNext, MenuLanguageBack},
{MenuDspCodePage, MenuNextItem, MenuCodePageNext, MenuCodePageBack},
{MenuDspCountry, MenuNextItem, MenuCountryNext, MenuCountryBack},
{MenuDspRS232Setup, MenuNextItem, MenuRS232Setup, MenuNULLKey},
{MenuDspRestoreDef, MenuNextItem, MenuRestoreDef, MenuNULLKey},
{MenuDspExit, MenuNextItem, _NULL, MenuBackItem},
{_NULL, _NULL, _NULL, _NULL},
};
RunMenu(MenuItem , 0, (CHAR **)LCDMessage[MSG_SYSTEM]);
}
STATIC VOID MenuDspDram(VOID)
{
CHAR Buf[20];
sprintf(Buf, "%-15s", LCDMessage[MSG_DRAM_FILE_LIST][pMenuCfg->Language]);
ShowLCDString(0, 0, Buf, 0);
if ( DramFile )
{
sprintf(Buf, "%-15s", DramList.FileName);
ShowLCDString(0, 1, Buf, 0);
}
else
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_NO_FILE][pMenuCfg->Language], 0);
}
STATIC VOID MenuDramNextFile(VOID *Num)
{
if ( DramFile )
{
if ( !NextFile(&DramList, "*.*") )
{
OpenList(&DramList, DRAM_DEVICE);
DramFile = NextFile(&DramList, "*.*");
*(INT *)Num += 1;
}
}
else
*(INT *)Num += 1;
}
STATIC VOID MenuDramNextItem(VOID *Num)
{
OpenList(&DramList, DRAM_DEVICE);
DramFile = NextFile(&DramList, "*.*");
*(INT *)Num += 1;
}
STATIC VOID MenuDspFlash(VOID)
{
CHAR Buf[20];
sprintf(Buf, "%-15s", LCDMessage[MSG_FLASH_FILE_LIST][pMenuCfg->Language]);
ShowLCDString(0, 0, Buf, 0);
if ( FlashFile )
{
sprintf(Buf, "%-15s", FlashList.FileName);
ShowLCDString(0, 1, Buf, 0);
}
else
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_NO_FILE][pMenuCfg->Language], 0);
}
STATIC VOID MenuFlashNextFile(VOID *Num)
{
if ( FlashFile )
{
if ( !NextFile(&FlashList, "*.*") )
{
OpenList(&FlashList, FLASH_DEVICE);
FlashFile = NextFile(&FlashList, "*.*");
*(INT *)Num += 1;
}
}
else
*(INT *)Num += 1;
}
STATIC VOID MenuFlashNextItem(VOID *Num)
{
OpenList(&FlashList, FLASH_DEVICE);
FlashFile = NextFile(&FlashList, "*.*");
*(INT *)Num += 1;
}
STATIC VOID MenuDspCard(VOID)
{
CHAR Buf[20];
ShowLCDString(0, 0, "CARD File List ", 0);
if ( CardFile )
{
sprintf(Buf, "%-15s", CardList.FileName);
ShowLCDString(0, 1, Buf, 0);
}
else
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_NO_FILE][pMenuCfg->Language], 0);
}
STATIC VOID MenuCardNextFile(VOID *Num)
{
if ( CardFile )
{
if ( !NextFile(&CardList, "*.*") )
{
OpenList(&CardList, CARD_DEVICE);
CardFile = NextFile(&CardList, "*.*");
*(INT *)Num += 1;
}
}
else
*(INT *)Num += 1;
}
STATIC VOID MenuCardNextItem(VOID *Num)
{
OpenList(&CardList, CARD_DEVICE);
CardFile = NextFile(&CardList, "*.*");
*(INT *)Num += 1;
}
STATIC VOID MenuFileListNext(VOID *Num)
{
CONST STATIC _MenuItem MenuItem[] =
{
{MenuDspDram, MenuDramNextFile, MenuDramNextItem, _NULL},
{MenuDspFlash, MenuFlashNextFile, MenuFlashNextItem, _NULL},
{_NULL, _NULL, _NULL, _NULL},
};
CONST STATIC _MenuItem MenuItemCard[] =
{
{MenuDspDram, MenuDramNextFile, MenuDramNextItem, _NULL},
{MenuDspFlash, MenuFlashNextFile, MenuFlashNextItem, _NULL},
{MenuDspCard, MenuCardNextFile, MenuCardNextItem, _NULL},
{_NULL, _NULL, _NULL, _NULL},
};
OpenList(&DramList, DRAM_DEVICE);
DramFile = NextFile(&DramList, "*.*");
OpenList(&FlashList, FLASH_DEVICE);
FlashFile = NextFile(&FlashList, "*.*");
OpenList(&CardList, CARD_DEVICE);
CardFile = NextFile(&CardList, "*.*");
#if defined(FLASH_MCARD_MODEL) || defined(SDCARD_MODEL )
if ( IsCardDevice() )
RunMenu(MenuItemCard, 0, (CHAR **)LCDMessage[MSG_NULL_STR]);
else
#endif
RunMenu(MenuItem , 0, (CHAR **)LCDMessage[MSG_NULL_STR]);
}
STATIC VOID MenuDspAvailDram(VOID)
{
CHAR Buf[20];
sprintf(Buf,"%-15s",LCDMessage[MSG_DRAM][pMenuCfg->Language]);
ShowLCDString(0, 0, Buf, 0);
sprintf(Buf,"%d %s", FreeSpace(DRAM_DEVICE) , LCDMessage[MSG_KB_FREE][pMenuCfg->Language]);
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuDspAvailFlash(VOID)
{
CHAR Buf[20];
sprintf(Buf,"%-15s",LCDMessage[MSG_FLASH][pMenuCfg->Language]);
ShowLCDString(0, 0, Buf, 0);
sprintf(Buf,"%d %s", FreeSpace(FLASH_DEVICE) , LCDMessage[MSG_KB_FREE][pMenuCfg->Language]);
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuDspExtAvailFlash(VOID)
{
CHAR Buf[20];
sprintf(Buf,"%-15s",LCDMessage[MSG_MEMORY_CARD][pMenuCfg->Language]);
ShowLCDString(0, 0, Buf, 0);
sprintf(Buf,"%d %s", FreeSpace(CARD_DEVICE) , LCDMessage[MSG_KB_FREE][pMenuCfg->Language]);
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuAvailMemory(VOID *Num)
{
CONST STATIC _MenuItem MenuItem[] =
{
{MenuDspAvailDram, MenuNULLKey, MenuNextItem, MenuNextItem},
{MenuDspAvailFlash, MenuNULLKey, MenuNextItem, MenuNextItem},
{MenuDspExtAvailFlash, MenuNULLKey, _NULL, _NULL},
{_NULL, _NULL, _NULL, _NULL},
};
RunMenu(MenuItem , 0, (CHAR **)LCDMessage[MSG_NULL_STR]);
}
STATIC INT MenuKeyYesNo(VOID)
{
INT Key;
DspClearDisplay();
ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_PAUSE_YES][pMenuCfg->Language], 0);
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_FEED_NO][pMenuCfg->Language], 0);
while (1)
{
Key = MenuWaitKey();
if ( Key == PAUSE_KEY )
{
Key = TRUE;
break;
}
else if ( Key == FEED_KEY )
{
Key = FALSE;
break;
}
DisableBuzzer();
}
while ( CheckBuzzerStatus() ){}
return Key;
}
STATIC VOID MenuDeleteFiles(VOID *Num)
{
INT Key;
while ( CheckBuzzerStatus() ){}
DspClearDisplay();
#if defined(FLASH_MCARD_MODEL) || defined(SDCARD_MODEL )
if ( IsCardDevice() )
{
ShowLCDString(0, 0, "PAUSE:FLASH ALL ", 0);
ShowLCDString(0, 1, "FEED:M.CARD ALL ", 0);
}
else
#endif
{
ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_PAUSE_FLASH_ALL][pMenuCfg->Language], 0);
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_FEED_EXIT][pMenuCfg->Language], 0);
}
while (1)
{
Key = MenuWaitKey();
if ( Key == PAUSE_KEY || Key == FEED_KEY )
break;
DisableBuzzer();
}
while ( CheckBuzzerStatus() ){}
if ( Key == PAUSE_KEY )
{
if ( MenuKeyYesNo() )
{
ErasingFile(DRAM_DEVICE, "*");
ErasingFile(FLASH_DEVICE, "*");
}
}
#if defined(FLASH_MCARD_MODEL) || defined(SDCARD_MODEL )
else if ( Key == FEED_KEY && IsCardDevice() )
{
if ( MenuKeyYesNo() )
{
ErasingFile(DRAM_DEVICE, "*");
ErasingFile(CARD_DEVICE, "*");
}
}
#endif
}
STATIC VOID MenuDspFileList(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_FILE_LIST][pMenuCfg->Language], 0);
}
STATIC VOID MenuDspAvailMemory(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_AVAIL_MEM][pMenuCfg->Language], 0);
}
STATIC VOID MenuDspDeleteFiles(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_DELETE_FILE][pMenuCfg->Language], 0);
}
STATIC VOID MenuFileManager(VOID *Num)
{
CONST STATIC _MenuItem MenuItem[] =
{
{MenuDspFileList, MenuNextItem, MenuFileListNext, MenuFileListNext},
{MenuDspAvailMemory, MenuNextItem, MenuAvailMemory, MenuNULLKey},
{MenuDspDeleteFiles, MenuNextItem, MenuDeleteFiles, MenuNULLKey},
{MenuDspExit, MenuNextItem, _NULL, MenuBackItem},
{_NULL, _NULL, _NULL, _NULL},
};
RunMenu(MenuItem , 0, (CHAR **)LCDMessage[MSG_FILE]);
}
STATIC VOID MenuPrintCfg(VOID *Num)
{
REPORT *Report;
LeaveMenuFunc();
Report = SelfTestReport(NULL, FALSE, OUTPUT_LABEL);
#if defined(NUTNET)
if (GetThreadByName("ethernet"))
Report = IpConfigReport(Report, FALSE, OUTPUT_LABEL);
#endif
FileReport(Report, TRUE, OUTPUT_LABEL);
EntryMenuFunc();
}
STATIC VOID MenuDumpMode(VOID *Num)
{
LeaveMenuFunc();
HexDumpMode();
EntryMenuFunc();
}
STATIC VOID MenuRotateCutter(VOID *Num)
{
LeaveMenuFunc();
while ( CutterClear() == CUTTER_CUTTING ){}
EntryMenuFunc();
}
STATIC VOID DecRotateTimes(VOID)
{
RotateTimes -= 1;
}
STATIC VOID MenuRotateMotor(VOID *Num)
{
while ( CheckBuzzerStatus() ){}
DspClearDisplay();
ShowMessage(0,0, MSG_MENU_FWD, 0);
ShowMessage(0,1, MSG_PAUSE_REV, 0);
RotateTimes = 0;
while ( CheckKeyPin(MENU_KEY) || CheckKeyPin(PAUSE_KEY) || CheckKeyPin(FEED_KEY) ){}
while ( 1 )
{
if ( RotateTimes > 1 ){}
else if ( CheckKeyPin(MENU_KEY) )
{
RotateTimes += 1;
MotorMove((LONG)TPH_DPI>>4, pMenuCfg, MOTOR_FORWARD, DecRotateTimes);
}
else if ( CheckKeyPin(PAUSE_KEY) )
{
RotateTimes += 1;
MotorMove((LONG)TPH_DPI>>4, pMenuCfg, MOTOR_BACKWARD, DecRotateTimes);
}
else if ( CheckKeyPin(FEED_KEY) )
break;
}
}
STATIC VOID MenuDspMileageValue(VOID)
{
CHAR Buf[20];
sprintf(Buf,"%-15s",LCDMessage[MSG_MILEAGE][pMenuCfg->Language]);
ShowLCDString(0, 0, Buf, 0);
sprintf(Buf," %010d", pMenuRec->DotMilage / (INT)(MM_DOT * 1000));
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuDspLabelValue(VOID)
{
CHAR Buf[20];
sprintf(Buf,"%-15s", LCDMessage[MSG_LABEL][pMenuCfg->Language]);
ShowLCDString(0, 0, Buf, 0);
sprintf(Buf," %010d", pMenuRec->LabelMilage);
ShowLCDString(0, 1, Buf, 0);
}
STATIC VOID MenuMileageInfo(VOID *Num)
{
CONST STATIC _MenuItem MenuItem[] =
{
{MenuDspMileageValue, MenuNULLKey, MenuNextItem, MenuNextItem},
{MenuDspLabelValue, MenuNULLKey, _NULL, _NULL},
{_NULL, _NULL, _NULL, _NULL},
};
RunMenu(MenuItem , 0, (CHAR **)LCDMessage[MSG_NULL_STR]);
}
STATIC VOID MenuDspPrintCfg(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_PRINTER_CFG][pMenuCfg->Language], 0);
}
STATIC VOID MenuDspDumpMode(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_DUMPMODE][pMenuCfg->Language], 0);
}
STATIC VOID MenuDspCutter(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_ROTATE_CUTTER][pMenuCfg->Language], 0);
}
STATIC VOID MenuDspMotor(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_ROTATE_MOTOR][pMenuCfg->Language], 0);
}
STATIC VOID MenuDspMileage(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_MILEAGE_INFO][pMenuCfg->Language], 0);
}
STATIC VOID MenuPrinterTest(VOID *Num)
{
CONST STATIC _MenuItem MenuItem[] =
{
{MenuDspPrintCfg, MenuNextItem, MenuPrintCfg, MenuNULLKey},
{MenuDspDumpMode, MenuNextItem, MenuDumpMode, MenuNULLKey},
{MenuDspCutter, MenuNextItem, MenuRotateCutter, MenuNULLKey},
{MenuDspMotor, MenuNextItem, MenuRotateMotor, MenuNULLKey},
{MenuDspMileage, MenuNextItem, MenuMileageInfo, MenuNULLKey},
{MenuDspExit, MenuNextItem, _NULL, MenuBackItem},
{_NULL, _NULL, _NULL, _NULL},
};
RunMenu(MenuItem , 0, (CHAR **)LCDMessage[MSG_TEST]);
}
STATIC VOID MenuDspPrinterSetup(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_PRINTER_SETUP][pMenuCfg->Language], 0);
}
STATIC VOID MenuDspSensorCalib(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_SENSOR_CALIB][pMenuCfg->Language], 0);
}
STATIC VOID MenuDspSystemSetup(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_SYSTEM_SETUP][pMenuCfg->Language], 0);
}
STATIC VOID MenuDspFileManage(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_FILE_MANAGE][pMenuCfg->Language], 0);
}
STATIC VOID MenuDspPrinterTest(VOID)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_PRINTER_TEST][pMenuCfg->Language], 0);
}
VOID MainMenu(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{MenuDspPrinterSetup, MenuNextItem, MenuSetup, MenuBackItem},
{MenuDspSensorCalib, MenuNextItem, MenuSensor, MenuBackItem},
{MenuDspSystemSetup, MenuNextItem, MenuSystem, MenuBackItem},
{MenuDspFileManage, MenuNextItem, MenuFileManager, MenuBackItem},
{MenuDspPrinterTest, MenuNextItem, MenuPrinterTest, MenuBackItem},
{MenuDspExit, MenuNextItem, _NULL, MenuBackItem},
{_NULL, _NULL, _NULL, _NULL},
};
ClrDisplayStatus(DIS_READY);
EntryMenuFunc();
InitialMenu();
sysprintf("MainMenu2\r\n");
EnableBuzzer(26, 100);
while ( CheckBuzzerStatus() ){}
DspClearDisplay();
RunMenu(MenuItem , 0, (CHAR **)LCDMessage[MSG_MAIN_MENU]);
LeaveMenuFunc();
SetDisplayStatus(DIS_READY);
}
#endif
MenuVer3.c 、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define MENUVER3_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 <string.h>
#include <stdlib.h>
#include <ctype.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 "XTask.h"
#include "XADC.h"
#include "XLED.h"
#include "XLCD.h"
#include "XRTC.h"
#include "XKey.h"
#include "XBuzzer.h"
#include "XTimer.h"
#include "XFileSys.h"
#include "XProFile.h"
#include "XVarBank.h"
#include "XDisplay.h"
#include "XCodePage.h"
#include "XFunction.h"
#include "Parser.h"
#include "ParserUtil.h"
#include "Zpl2\Zpl2Report.h"
#include "Zpl2\Zpl2Control.h"
#include "Tspl\TsplFunc.h"
#include "Tspl\TsplUtil.h"
#include "Bsc\BscReport.h"
#include "Menu.h"
/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/
#if defined(TTP2410M)
#define MENU_SPEED_MAX 12
#define MENU_SPEED_MIN 4
#elif defined(TTP246MP)
#define MENU_SPEED_MAX 8
#define MENU_SPEED_MIN 4
#elif defined(TTP346M)
#define MENU_SPEED_MAX 8
#define MENU_SPEED_MIN 3
#elif defined(TTP344MP)
#define MENU_SPEED_MAX 6
#define MENU_SPEED_MIN 3
#elif defined(TTP644M)
#define MENU_SPEED_MAX 4
#define MENU_SPEED_MIN 2
#elif defined(TTP384M) || defined(DL9000)
#define MENU_SPEED_MAX 4
#define MENU_SPEED_MIN 2
#endif
#if defined(LCD_MODEL) && defined(MENU_TSPL_3)
#define SET_ITEM_EXIT 0x80000000
/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/
typedef struct
{
CHAR **tag;
VOID (*func)(VOID);
}_MenuItem;
typedef struct
{
CHAR **tag;
INT num;
}_SetItem;
/******************************************************************************
* *
* L O C A L F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/
/******************************************************************************
* *
* 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 CONST BYTE IcoPrev[] = {0x00,0x10,0x18,0x7c,0x7e,0x7c,0x18,0x10}; // Prev icon
STATIC CONST BYTE IcoNext[] = {0x00,0x08,0x18,0x3e,0x7e,0x3e,0x18,0x08}; // Next icon
/******************************************************************************
* *
* 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 _PrintCfg *pMenuCfg; // priner config data point
STATIC _PrintRecord* pMenuRec; // printer record
STATIC INT CodePageTotal;
STATIC INT CountryTotal;
STATIC BOOL WriteProtect;
STATIC BOOL WritePassword;
STATIC BOOL ExitMenu;
STATIC BOOL ExitFile;
STATIC BOOL FileRunning;
STATIC VOID InitialMenu(VOID)
{
CHAR Buf[128];
pMenuCfg = GrabPrintConfig();
pMenuRec = GrabPrintRecord();
CodePageTotal = GetCodePageTotal();
CountryTotal = GetCountryTotal();
WriteProtect = FALSE;
WritePassword = FALSE;
if (GetProfileString("MENU WR PROTECT", Buf))
{
if (strcmp("ENABLE", Buf) == 0)
WriteProtect = TRUE;
if (strcmp("PASSWORD", Buf) == 0)
WritePassword = TRUE;
}
}
STATIC BOOL EntryMenuFunc(VOID)
{
WaitWorkJobEnd();
#if defined(CARRIAGE_OPEN_MODEL)
StopCheckCarriageOpen();
#endif
return StopKeyFunc();
}
STATIC VOID LeaveMenuFunc(BOOL EnableKey)
{
delay_msec(200);
GetKey(MENU_KEY);
GetKey(PAUSE_KEY);
GetKey(FEED_KEY);
GetKey(UP_KEY);
GetKey(DOWN_KEY);
GetKey(SELECT_KEY);
StartKeyFunc(EnableKey);
#if defined(CARRIAGE_OPEN_MODEL)
StartCheckCarriageOpen();
#endif
}
STATIC INT MenuWaitKey(VOID)
{
STATIC INT interval = 150;
INT key;
delay_msec(interval);
while (1)
{
if (CheckKeyPin(key = MENU_KEY))
break;
if (CheckKeyPin(key = UP_KEY))
break;
if (CheckKeyPin(key = DOWN_KEY))
break;
if (CheckKeyPin(key = SELECT_KEY))
break;
interval = 150 + 5;
NutSleep(10);
}
sysprintf("MenuWaitKey\r\n");
EnableBuzzer(26, 100);
interval -= 5;
if (interval < 0)
interval = 0;
return key;
}
STATIC BOOL MenuWriteProtect(VOID)
{
CHAR *msgProtect = (CHAR *)LCDMessage[MSG_WRITE_PROTECT][pMenuCfg->Language];
CHAR *msgPassword = (CHAR *)LCDMessage[MSG_PASSWORD][pMenuCfg->Language];
CHAR editBuf[20] = "0000", rev[2] = " ";
INT index;
if (WriteProtect)
{
while (CheckBuzzerStatus()){}
DspClearDisplay();
ShowLCDString(((16 - strlen(msgProtect)) / 2), 1, msgProtect, 0);
while (CheckKeyPin(SELECT_KEY)){}
MenuWaitKey();
return TRUE;
}
index = 0;
while (WritePassword)
{
while (CheckBuzzerStatus()){}
DspClearDisplay();
ShowLCDString(((16 - strlen(msgPassword)) / 2), 1, msgPassword, 0);
ShowLCDString(((16 - strlen(editBuf)) / 2), 2, editBuf, 0);
rev[0] = editBuf[index];
ShowLCDString(((16 - strlen(editBuf)) / 2) + index, 2, rev, 1);
while (CheckKeyPin(SELECT_KEY)){}
switch (MenuWaitKey())
{
case MENU_KEY: // exit
return TRUE;
case UP_KEY: // inc
editBuf[index] += 1;
if (editBuf[index] > '9')
editBuf[index] = '0';
break;
case DOWN_KEY: // shift
index += 1;
if (index >= strlen(editBuf))
index = 0;
break;
case SELECT_KEY: // entry
if (strcmp(editBuf, "8888") == 0)
WritePassword = FALSE;
break;
}
}
return FALSE;
}
STATIC BOOL SureMenu(CHAR **title)
{
CHAR *msg = *(title + pMenuCfg->Language);
CHAR buf[20];
INT key = SELECT_KEY;
while (1)
{
DspClearDisplay();
ShowLCDString(((16 - strlen(msg)) / 2), 0, msg, 0);
sprintf(buf, "SELECT:%9s", LCDMessage[MSG_YES][pMenuCfg->Language]);
ShowLCDString(0, 2, buf, 0);
sprintf(buf, "MENU:%11s", LCDMessage[MSG_NO][pMenuCfg->Language]);
ShowLCDString(0, 3, buf, 0);
while (CheckKeyPin(key)){}
switch (key = MenuWaitKey())
{
case MENU_KEY: // no
return FALSE;
case SELECT_KEY: // sure
if (MenuWriteProtect())
break;
return TRUE;
}
}
}
STATIC VOID RunMenu(_MenuItem *index, INT def, CHAR **title)
{
CONST STATIC CHAR rev[] = " ";
_MenuItem *top, *mid, *bot;
CHAR buf[20];
INT i, total;
index += 1;
// caculate total item
total = 1;
while ((index + total)->tag)
total += 1;
i = 0;
if (def < total && (index + i)->func)
i = def;
index += i;
top = index;
mid = index + 1;
bot = index + 2;
ExitMenu = FALSE;
while (!ExitMenu)
{
while (CheckBuzzerStatus()){}
DspClearDisplay();
ShowLCDString(0, 0, *(title + pMenuCfg->Language), 0);
sprintf(buf, "%1d/%1d", i + 1, total);
ShowLCDString((16 - strlen(buf)), 0, buf, 0);
if (index == top)
{
ShowLCDString(1, 1, (CHAR *)rev, 1);
ShowLCDString(1, 1, *(top->tag + pMenuCfg->Language), 1);
ShowLCDString(1, 2, *(mid->tag + pMenuCfg->Language), 0);
ShowLCDString(1, 3, *(bot->tag + pMenuCfg->Language), 0);
ShowLCDString(0, 1, ">", 0);
}
else if (index == mid)
{
ShowLCDString(1, 2, (CHAR *)rev, 1);
ShowLCDString(1, 1, *(top->tag + pMenuCfg->Language), 0);
ShowLCDString(1, 2, *(mid->tag + pMenuCfg->Language), 1);
ShowLCDString(1, 3, *(bot->tag + pMenuCfg->Language), 0);
ShowLCDString(0, 2, ">", 0);
}
else if (index == bot)
{
ShowLCDString(1, 3, (CHAR *)rev, 1);
ShowLCDString(1, 1, *(top->tag + pMenuCfg->Language), 0);
ShowLCDString(1, 2, *(mid->tag + pMenuCfg->Language), 0);
ShowLCDString(1, 3, *(bot->tag + pMenuCfg->Language), 1);
ShowLCDString(0, 3, ">", 0);
}
while (CheckKeyPin(SELECT_KEY)){}
switch (MenuWaitKey())
{
case MENU_KEY: // exit
return;
case UP_KEY: // prev
if ((index - 1)->tag)
{
if (index == top)
{
top--;
mid--;
bot--;
}
index--;
i--;
}
break;
case DOWN_KEY: // next
if ((index + 1)->tag)
{
if (index == bot)
{
top++;
mid++;
bot++;
}
index++;
i++;
}
break;
case SELECT_KEY: // entry
if (index->func)
index->func();
else
return;
break;
}
}
}
STATIC INT SetMenu(_SetItem *index, INT def, CHAR **title)
{
CONST STATIC CHAR rev[] = " ";
_SetItem *top, *mid, *bot;
CHAR buf[20];
INT i, total;
index += 1;
// caculate total item
total = 1;
while ((index + total)->tag)
total += 1;
i = 0;
while ((index + i)->tag)
{
if ((index + i)->num == def)
break;
i++;
}
if (i >= total)
i = 0;
if ((index + i)->tag)
index += i;
if ((index + 2)->tag)
{
top = index;
mid = index + 1;
bot = index + 2;
}
else
{
top = index -1;
mid = index;
bot = index + 1;
}
while (1)
{
while (CheckBuzzerStatus()){}
DspClearDisplay();
ShowLCDString(0, 0, *(title + pMenuCfg->Language), 0);
sprintf(buf, "%1d/%1d", i + 1, total);
ShowLCDString((16 - strlen(buf)), 0, buf, 0);
if (index == top)
{
ShowLCDString(1, 1, (CHAR *)rev, 1);
ShowLCDString(1, 1, *(top->tag + pMenuCfg->Language), 1);
ShowLCDString(1, 2, *(mid->tag + pMenuCfg->Language), 0);
ShowLCDString(1, 3, *(bot->tag + pMenuCfg->Language), 0);
ShowLCDString(0, 1, ">", 0);
}
else if (index == mid)
{
ShowLCDString(1, 2, (CHAR *)rev, 1);
ShowLCDString(1, 1, *(top->tag + pMenuCfg->Language), 0);
ShowLCDString(1, 2, *(mid->tag + pMenuCfg->Language), 1);
ShowLCDString(1, 3, *(bot->tag + pMenuCfg->Language), 0);
ShowLCDString(0, 2, ">", 0);
}
else if (index == bot)
{
ShowLCDString(1, 3, (CHAR *)rev, 1);
ShowLCDString(1, 1, *(top->tag + pMenuCfg->Language), 0);
ShowLCDString(1, 2, *(mid->tag + pMenuCfg->Language), 0);
ShowLCDString(1, 3, *(bot->tag + pMenuCfg->Language), 1);
ShowLCDString(0, 3, ">", 0);
}
while (CheckKeyPin(SELECT_KEY)){}
switch (MenuWaitKey())
{
case MENU_KEY: // exit
return def;
case UP_KEY: // prev
if ((index - 1)->tag)
{
if (index == top)
{
top--;
mid--;
bot--;
}
index--;
i--;
}
break;
case DOWN_KEY: // next
if ((index + 1)->tag)
{
if (index == bot)
{
top++;
mid++;
bot++;
}
index++;
i++;
}
break;
case SELECT_KEY: // entry
if (index->num != SET_ITEM_EXIT && index->num != def)
{
if (MenuWriteProtect())
break;
return index->num;
}
return def;
}
}
}
STATIC VOID FileFinish(VOID)
{
BasClearHandle();
FileRunning = FALSE;
}
STATIC VOID FileContMenu(_eFileDevice device, CHAR *name, INT size)
{
CHAR buf[32];
INT key = SELECT_KEY;
while (1)
{
while (CheckBuzzerStatus()){}
DspClearDisplay();
ShowLCDString(0, 0, name, 0);
if (strcmp(strchr(name, '.'), ".BAS") == 0)
{
sprintf(buf, "UP:%13s", LCDMessage[MSG_AUTO][pMenuCfg->Language]);
ShowLCDString(0, 1, buf, 0);
sprintf(buf, "DOWN:%11s", LCDMessage[MSG_DELETE][pMenuCfg->Language]);
ShowLCDString(0, 2, buf, 0);
sprintf(buf, "SELECT:%9s", LCDMessage[MSG_RUN][pMenuCfg->Language]);
ShowLCDString(0, 3, buf, 0);
}
else
{
sprintf(buf, "%8d Byte(s)", size);
if (size > 1024)
sprintf(buf, "%13.2f KB", (FLOAT)size / 1024);
if (size > 1024 * 1024)
sprintf(buf, "%13.2f MB", (FLOAT)size / 1024 / 1024);
ShowLCDString(0, 1, buf, 0);
sprintf(buf, "DOWN:%11s", LCDMessage[MSG_DELETE][pMenuCfg->Language]);
ShowLCDString(0, 3, buf, 0);
}
while (CheckKeyPin(key)){}
switch (key = MenuWaitKey())
{
case MENU_KEY: // exit
return;
case UP_KEY: // set to AutoRun
if (strcmp(strchr(name, '.'), ".BAS"))
break;
if (MenuWriteProtect())
break;
strcpy((CHAR *)pMenuCfg->AutoRun, name);
return;
case DOWN_KEY: // delete
if (MenuWriteProtect())
break;
if (!SureMenu((CHAR **)LCDMessage[MSG_DELETE]))
break;
DspClearDisplay();
ErasingFile(device, name);
ExitFile = TRUE;
return;
case SELECT_KEY: // run
if (strcmp(strchr(name, '.'), ".BAS"))
break;
LeaveMenuFunc(TRUE);
SetDisplayStatus(DIS_READY);
UserDataIn(CR_CHAR);
// UserDataIn(LF_CHAR);
RemoveLF(); // for INPUT command
sBasicData.UseHandle = RunFile(device, name, BasFileKey, FileFinish);
if (sBasicData.UseHandle != _NULL)
{
BasInitialBASIC();
FileRunning = TRUE;
while (FileRunning)
NutSleep(255);
}
ClrDisplayStatus(DIS_READY);
EntryMenuFunc();
return;
}
}
}
STATIC VOID FileMenu(CHAR **title, _eFileDevice device)
{
CONST STATIC CHAR rev[] = " ";
_FileList list;
CHAR name[3][20];
INT index;
memset(name, 0, sizeof(name));
OpenList(&list, device);
if (!NextFile(&list, "*.*"))
{
DspClearDisplay();
ShowLCDString(0, 0, *(title + pMenuCfg->Language), 0);
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_NO_FILE][pMenuCfg->Language], 0);
while (CheckKeyPin(SELECT_KEY)){}
MenuWaitKey();
return;
}
strcpy(name[0], list.FileName);
if (NextFile(&list, "*.*"))
strcpy(name[1], list.FileName);
if (NextFile(&list, "*.*"))
strcpy(name[2], list.FileName);
PrevFile(&list, "*.*");
PrevFile(&list, "*.*");
PrevFile(&list, "*.*");
index = 1;
ExitFile = FALSE;
while (!ExitFile)
{
while (CheckBuzzerStatus()){}
DspClearDisplay();
ShowLCDString(0, index, ">", 0);
ShowLCDString(1, index, (CHAR *)rev, 1);
ShowLCDString(0, 0, *(title + pMenuCfg->Language), 0);
ShowLCDString(1, 1, name[0], index == 1 ? 1 : 0);
ShowLCDString(1, 2, name[1], index == 2 ? 1 : 0);
ShowLCDString(1, 3, name[2], index == 3 ? 1 : 0);
if (strcmp(name[0], (CHAR *)pMenuCfg->AutoRun) == 0)
ShowLCDString(0, 1, "*", 0);
if (strcmp(name[1], (CHAR *)pMenuCfg->AutoRun) == 0)
ShowLCDString(0, 2, "*", 0);
if (strcmp(name[2], (CHAR *)pMenuCfg->AutoRun) == 0)
ShowLCDString(0, 3, "*", 0);
while (CheckKeyPin(SELECT_KEY)){}
switch (MenuWaitKey())
{
case MENU_KEY: // exit
return;
case UP_KEY: // prev
if (PrevFile(&list, "*.*"))
{
if (--index < 1)
{
strcpy(name[2], name[1]);
strcpy(name[1], name[0]);
strcpy(name[0], list.FileName);
index = 1;
}
}
break;
case DOWN_KEY: // next
if (NextFile(&list, "*.*"))
{
if (NextFile(&list, "*.*"))
{
if (++index > 3)
{
strcpy(name[0], name[1]);
strcpy(name[1], name[2]);
strcpy(name[2], list.FileName);
index = 3;
}
}
PrevFile(&list, "*.*");
}
break;
case SELECT_KEY: // entry
FileContMenu(device, list.FileName, list.FileSize);
break;
}
}
}
STATIC INT NumMenu(CHAR **title, INT def, INT higher, INT lower, INT step)
{
CHAR *msg = *(title + pMenuCfg->Language);
CHAR buf[20];
INT num;
num = def;
while (1)
{
while (CheckBuzzerStatus()){}
DspClearDisplay();
ShowLCDString(((16 - strlen(msg)) / 2), 1, msg, 0);
sprintf((CHAR *)buf, "%d", num);
ShowLCDString(((16 - strlen(buf)) / 2), 2, buf, 0);
while (CheckKeyPin(SELECT_KEY)){}
switch (MenuWaitKey())
{
case MENU_KEY: // exit
return def;
case UP_KEY: // +
if (MenuWriteProtect())
break;
if (num + step <= higher)
num += step;
break;
case DOWN_KEY: // -
if (MenuWriteProtect())
break;
if (num - step >= lower)
num -= step;
break;
case SELECT_KEY: // entry
if (num != def)
return num;
return def;
}
}
}
STATIC INT ToUnitNumber(CHAR *buf, INT unit)
{
if (unit == 0) // dot
return atoi(buf);
if (unit == 1) // mm
return atof(buf) * MM_DOT;
if (unit == 2) // inch
return atof(buf) * TPH_DPI;
return 0;
}
STATIC INT ToUnitString(CHAR *buf, INT num, INT unit)
{
if (unit == 0) // dot
return sprintf(buf, "%d", abs(num));
if (unit == 1) // mm
return sprintf(buf, "%.01f", (FLOAT)abs(num) / MM_DOT);
if (unit == 2) // inch
return sprintf(buf, "%.02f", (FLOAT)abs(num) / TPH_DPI);
return 0;
}
STATIC INT EditNumMenu(CHAR **title, INT def, INT range, BOOL sign, BOOL useUnit, INT *keyback)
{
STATIC CONST CHAR *unitMsg[3] = { "dot", "mm", "inch" };
CHAR *msg = *(title + pMenuCfg->Language);
CHAR editBuf[20], rev[2] = " ";
CHAR tempBuf[20];
INT tempLen, unitLen[3];
INT index;
INT unit;
INT num;
num = MAX(abs(def), abs(range));
unitLen[0] = ToUnitString(tempBuf, num, 0);
unitLen[1] = ToUnitString(tempBuf, num, 1);
unitLen[2] = ToUnitString(tempBuf, num, 2);
editBuf[0] = (def < 0) ? '-' : '+';
tempLen = unitLen[0] - ToUnitString(tempBuf, def, 0);
for (num = (sign ? 1 : 0); tempLen > 0; tempLen--)
editBuf[num++] = '0';
strcpy((CHAR *)&editBuf[num], tempBuf);
index = 0;
unit = 0;
while (1)
{
while (CheckBuzzerStatus()){}
tempLen = strlen(editBuf);
if (useUnit)
tempLen += 1 + strlen(unitMsg[unit]);
tempLen = (16 - tempLen) / 2;
DspClearDisplay();
ShowLCDString(((16 - strlen(msg)) / 2), 1, msg, 0);
ShowLCDString(tempLen, 2, editBuf, 0);
if (index != (-1))
{
rev[0] = editBuf[index];
ShowLCDString(tempLen + index, 2, rev, 1);
if (useUnit)
ShowLCDString(tempLen + strlen(editBuf) + 1, 2, (CHAR *)unitMsg[unit], 0);
}
else if (useUnit)
ShowLCDString(tempLen + strlen(editBuf) + 1, 2, (CHAR *)unitMsg[unit], 1);
while (CheckKeyPin(SELECT_KEY)){}
switch (MenuWaitKey())
{
case MENU_KEY: // exit
if (keyback)
*keyback = MENU_KEY;
return def;
case UP_KEY: // inc
if (MenuWriteProtect())
break;
if (index == (-1)) // select unit
{
num = ToUnitNumber(editBuf, unit);
unit += 1;
if (unit >= 3)
unit = 0;
tempLen = unitLen[unit] - ToUnitString(tempBuf, num, unit);
for (num = (sign ? 1 : 0); tempLen > 0; tempLen--)
editBuf[num++] = '0';
strcpy((CHAR *)&editBuf[num], tempBuf);
}
else if (editBuf[index] == '+')
editBuf[index] = '-';
else if (editBuf[index] == '-')
editBuf[index] = '+';
else if (editBuf[index] == '9')
editBuf[index] = '0';
else
{
tempLen = unitLen[unit] - ToUnitString(tempBuf, range, unit);
if (strcmp(editBuf + tempLen + (sign ? 1 : 0), tempBuf) != 0)
{
editBuf[index] += 1;
num = ToUnitNumber(editBuf, unit);
if (abs(num) > abs(range))
{
for (num = (sign ? 1 : 0); tempLen > 0; tempLen--)
editBuf[num++] = '0';
strcpy((CHAR *)&editBuf[num], tempBuf);
}
}
else
editBuf[index] = '0';
}
break;
case DOWN_KEY: // shift
index += 1;
if (editBuf[index] == '.')
index += 1;
if (index >= strlen(editBuf))
index = useUnit ? (-1) : 0;
break;
case SELECT_KEY: // entry
if (keyback)
*keyback = SELECT_KEY;
num = ToUnitNumber(editBuf, unit);
if (num != def)
return num;
return def;
}
}
}
STATIC ULONG EditAddrMenu(CHAR **title, ULONG def, INT *keyback)
{
CHAR *msg = *(title + pMenuCfg->Language);
CHAR editBuf[20], rev[2] = " ";
BYTE *IP = (BYTE *)&def;
INT index;
sprintf(editBuf, "%03d.%03d.%03d.%03d", IP[0], IP[1], IP[2], IP[3]);
index = 0;
while (1)
{
while (CheckBuzzerStatus()){}
DspClearDisplay();
ShowLCDString(((16 - strlen(msg)) / 2), 1, msg, 0);
ShowLCDString(((16 - strlen(editBuf)) / 2), 2, editBuf, 0);
rev[0] = editBuf[index];
ShowLCDString(((16 - strlen(editBuf)) / 2) + index, 2, rev, 1);
while (CheckKeyPin(SELECT_KEY)){}
switch (MenuWaitKey())
{
case MENU_KEY: // exit
if (keyback)
*keyback = MENU_KEY;
return def;
case UP_KEY: // next
if (MenuWriteProtect())
break;
editBuf[index] += 1;
if ((index % 4) == 0)
{
if (editBuf[index] == '3')
editBuf[index] = '0';
}
else if ((index % 4) == 1)
{
if (editBuf[index-1] == '2' && editBuf[index] > '5')
editBuf[index] = '0';
else if (editBuf[index] > '9')
editBuf[index] = '0';
}
else if ((index % 4) == 2)
{
if (editBuf[index-2] == '2' && editBuf[index-1] == '5'
&& editBuf[index] > '5')
editBuf[index] = '0';
else if (editBuf[index] > '9')
editBuf[index] = '0';
}
break;
case DOWN_KEY: // shift
index += 1;
if (index >= strlen(editBuf))
index = 0;
else if ((index % 4) == 3)
index += 1;
break;
case SELECT_KEY: // entry
if (keyback)
*keyback = SELECT_KEY;
return inet_addr(editBuf);
}
}
}
STATIC BYTE EditCharMenu(CHAR **title, BYTE def)
{
CHAR *msg = *(title + pMenuCfg->Language);
CHAR buf[20], rev[2] = " ";
BYTE num = def;
BYTE mask;
INT shift;
INT index = 1;
while (1)
{
while (CheckBuzzerStatus()){}
DspClearDisplay();
ShowLCDString(((16 - strlen(msg)) / 2), 1, msg, 0);
sprintf((CHAR *)buf, "<%c> %02XH", num ? num : ' ', num);
ShowLCDString(((16 - strlen(buf)) / 2), 2, buf, 0);
rev[0] = buf[5 + (1 - index)];
ShowLCDString(((16 - strlen(buf)) / 2) + 5 + (1 - index), 2, rev, 1);
while (CheckKeyPin(SELECT_KEY)){}
switch (MenuWaitKey())
{
case MENU_KEY: // exit
return def;
case UP_KEY: // inc
if (MenuWriteProtect())
break;
shift = index * 4;
mask = 0xF << shift;
num = (num + (1 << shift)) & mask | (num & ~mask);
break;
case DOWN_KEY: // shift
index += 1;
if (index > 1)
index = 0;
break;
case SELECT_KEY: // entry
if (num != def)
return num;
return def;
}
}
}
STATIC VOID GapSensorRepeat(VOID)
{
STATIC WORD Scan;
CHAR buf[20];
INT StockAD;
if (++Scan > (250 / PERIOD_TIMES)) // each 250 msec
{
Scan = 0;
DspClearLine(3, LCD_LANG_ENG);
StartADConvert(GAP_SENSOR_AD);
StockAD = ReadAD(GAP_SENSOR_AD);
sprintf(buf, "%-12s%4d", LCDMessage[MSG_REF_LEVEL][pMenuCfg->Language], StockAD);
ShowLCDString(((16 - strlen(buf)) / 2), 3, buf, 0);
}
}
STATIC VOID BlineSensorRepeat(VOID)
{
STATIC WORD Scan;
CHAR buf[20];
INT StockAD;
if (++Scan > (250 / PERIOD_TIMES)) // each 250 msec
{
Scan = 0;
DspClearLine(3, LCD_LANG_ENG);
StartADConvert(BLINE_SENSOR_AD);
StockAD = ReadAD(BLINE_SENSOR_AD);
sprintf(buf, "%-12s%4d", LCDMessage[MSG_REF_LEVEL][pMenuCfg->Language], StockAD);
ShowLCDString(((16 - strlen(buf)) / 2), 3, buf, 0);
}
}
STATIC INT EditGainMenu(_eSensorType Type, INT def, INT higher, INT lower, INT *keyback)
{
PERIODFUNC SensorRepeat = (Type == GAP_SENSOR) ? GapSensorRepeat : BlineSensorRepeat;
CHAR buf[20];
INT num, ret, key;
num = def;
ret = FALSE;
while (CheckKeyPin(UP_KEY) || CheckKeyPin(DOWN_KEY)){}
EnableSensor(Type, num, pMenuCfg->RibbonFlag, 0);
StartPeriodFunc(SensorRepeat);
while (!ret)
{
while (CheckBuzzerStatus()){}
DspClearLine(2, LCD_LANG_ENG);
sprintf(buf, "%-13s%3d", LCDMessage[MSG_INTENSITY][pMenuCfg->Language], num);
ShowLCDString(((16 - strlen(buf)) / 2), 2, buf, 0);
while (CheckKeyPin(MENU_KEY) || CheckKeyPin(SELECT_KEY)){}
key = MenuWaitKey();
switch (key)
{
case MENU_KEY: // exit
num = def;
ret = TRUE;
break;
case UP_KEY: // +
if (num + 1 <= higher)
num += 1;
break;
case DOWN_KEY: // -
if (num - 1 >= lower)
num -= 1;
break;
case SELECT_KEY: // entry
CancelPeriodFunc(SensorRepeat);
if (MenuWriteProtect())
break;
ret = TRUE;
break;
}
EnableSensor(Type, num, pMenuCfg->RibbonFlag, 0);
StartPeriodFunc(SensorRepeat);
}
CancelPeriodFunc(SensorRepeat);
DisableSensor(Type);
if (keyback)
*keyback = key;
return num;
}
STATIC VOID MenuTsplSpeed(VOID)
{
INT Speed = atoi(ToSpeedString(pMenuCfg->Speed));
Speed = NumMenu((CHAR **)LCDMessage[MSG_SPEED], Speed, MENU_SPEED_MAX, MENU_SPEED_MIN, 1);
pMenuCfg->Speed = ToMotorSpeed(Speed);
}
STATIC VOID MenuTsplDensity(VOID)
{
pMenuCfg->fDensity =
(FLOAT)NumMenu((CHAR **)LCDMessage[MSG_DENSITY], (INT)pMenuCfg->fDensity, DensityMax, DensityMin, 1);
}
STATIC VOID MenuTsplDirection(VOID)
{
pMenuCfg->Direction =
NumMenu((CHAR **)LCDMessage[MSG_DIRECTION], pMenuCfg->Direction, 1, 0, 1);
}
STATIC VOID MenuTsplPrintMode(VOID)
{
CONST STATIC _SetItem SetItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_NONE], OFF_MODE},
{(CHAR **)LCDMessage[MSG_BATCH_MODE], TEAR_MODE},
{(CHAR **)LCDMessage[MSG_PEELER_MODE], PEEL_MODE},
{(CHAR **)LCDMessage[MSG_CUTTER_MODE], CUTTER_MODE},
{(CHAR **)LCDMessage[MSG_CUTTER_BATCH], CUTTER_MODE + 1},
{(CHAR **)LCDMessage[MSG_EXIT], SET_ITEM_EXIT},
{(CHAR **)_NULL, _NULL}
};
INT Removal = pMenuCfg->PrintOutMode;
if (Removal == CUTTER_MODE && pMenuCfg->CutterPieces == 0)
Removal += 1;
pMenuCfg->PrintOutMode =
(_ePrintOutMode)SetMenu((_SetItem *)SetItem, Removal, (CHAR **)LCDMessage[MSG_PRINT_MODE]);
if (pMenuCfg->PrintOutMode == OFF_MODE)
pMenuCfg->TearMode = FALSE;
else if (pMenuCfg->PrintOutMode == TEAR_MODE)
pMenuCfg->TearMode = TRUE;
else if (pMenuCfg->PrintOutMode == CUTTER_MODE)
pMenuCfg->CutterPieces = 1;
else if (pMenuCfg->PrintOutMode == CUTTER_MODE + 1)
{
pMenuCfg->PrintOutMode = CUTTER_MODE;
pMenuCfg->CutterPieces = 0;
}
}
STATIC VOID MenuTsplOffset(VOID)
{
pMenuCfg->OffsetDis =
EditNumMenu((CHAR **)LCDMessage[MSG_OFFSET], pMenuCfg->OffsetDis, 999, TRUE, FALSE, _NULL);
}
STATIC VOID MenuTsplShiftX(VOID)
{
pMenuCfg->ShiftDisX =
EditNumMenu((CHAR **)LCDMessage[MSG_SHIFT_X], pMenuCfg->ShiftDisX, 999, TRUE, FALSE, _NULL);
}
STATIC VOID MenuTsplShiftY(VOID)
{
pMenuCfg->ShiftDisY =
EditNumMenu((CHAR **)LCDMessage[MSG_SHIFT_Y], pMenuCfg->ShiftDisY, 999, TRUE, FALSE, _NULL);
}
STATIC VOID MenuTsplReferenceX(VOID)
{
pMenuCfg->ReferenceX =
EditNumMenu((CHAR **)LCDMessage[MSG_REFERENCE_X], pMenuCfg->ReferenceX, 999, FALSE, FALSE, _NULL);
}
STATIC VOID MenuTsplReferenceY(VOID)
{
pMenuCfg->ReferenceY =
EditNumMenu((CHAR **)LCDMessage[MSG_REFERENCE_Y], pMenuCfg->ReferenceY, 999, FALSE, FALSE, _NULL);
}
STATIC VOID MenuTsplCodePage(VOID)
{
CONST STATIC _SetItem ItemExit = {(CHAR **)LCDMessage[MSG_EXIT], SET_ITEM_EXIT};
CONST STATIC _SetItem ItemNull = {(CHAR **)_NULL, _NULL};
_SetItem *pSetItem;
CHAR **pSetTag;
INT item;
INT i, j;
pSetItem = malloc((CodePageTotal + 3) * sizeof(_SetItem));
pSetTag = malloc(CodePageTotal * LANGUAGE_TOTAL * sizeof(CHAR *));
item = 0;
*(pSetItem + item++) = ItemNull;
for (i = 0; i < CodePageTotal; i++)
{
for (j = 0; j < LANGUAGE_TOTAL; j++)
*(pSetTag + i * LANGUAGE_TOTAL + j) = (CHAR *)CodePageNameTable[i];
(pSetItem + item)->tag = pSetTag + i * LANGUAGE_TOTAL;
(pSetItem + item)->num = i;
item++;
}
*(pSetItem + item++) = ItemExit;
*(pSetItem + item++) = ItemNull;
pMenuCfg->CodePage = SetMenu(pSetItem, pMenuCfg->CodePage, (CHAR **)LCDMessage[MSG_CODEPAGE]);
free(pSetTag);
free(pSetItem);
}
STATIC VOID MenuTsplCountry(VOID)
{
CONST STATIC _SetItem ItemExit = {(CHAR **)LCDMessage[MSG_EXIT], SET_ITEM_EXIT};
CONST STATIC _SetItem ItemNull = {(CHAR **)_NULL, _NULL};
_SetItem *pSetItem;
CHAR **pSetTag;
INT item;
INT i, j;
pSetItem = malloc((CountryTotal + 3) * sizeof(_SetItem));
pSetTag = malloc(CountryTotal * LANGUAGE_TOTAL * sizeof(CHAR *));
item = 0;
*(pSetItem + item++) = ItemNull;
for (i = 0; i < CountryTotal; i++)
{
for (j = 0; j < LANGUAGE_TOTAL; j++)
*(pSetTag + i * LANGUAGE_TOTAL + j) = (CHAR *)CountryNameTable[i];
(pSetItem + item)->tag = pSetTag + i * LANGUAGE_TOTAL;
(pSetItem + item)->num = i;
item++;
}
*(pSetItem + item++) = ItemExit;
*(pSetItem + item++) = ItemNull;
pMenuCfg->Country = SetMenu(pSetItem, pMenuCfg->Country, (CHAR **)LCDMessage[MSG_COUNTRY]);
free(pSetTag);
free(pSetItem);
}
STATIC VOID MenuTsplSetup(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_SPEED], MenuTsplSpeed},
{(CHAR **)LCDMessage[MSG_DENSITY], MenuTsplDensity},
{(CHAR **)LCDMessage[MSG_DIRECTION], MenuTsplDirection},
{(CHAR **)LCDMessage[MSG_PRINT_MODE], MenuTsplPrintMode},
{(CHAR **)LCDMessage[MSG_OFFSET], MenuTsplOffset},
{(CHAR **)LCDMessage[MSG_SHIFT_X], MenuTsplShiftX},
{(CHAR **)LCDMessage[MSG_SHIFT_Y], MenuTsplShiftY},
{(CHAR **)LCDMessage[MSG_REFERENCE_X], MenuTsplReferenceX},
{(CHAR **)LCDMessage[MSG_REFERENCE_Y], MenuTsplReferenceY},
{(CHAR **)LCDMessage[MSG_CODEPAGE], MenuTsplCodePage},
{(CHAR **)LCDMessage[MSG_COUNTRY], MenuTsplCountry},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_PRINT_SETUP]);
}
#if defined(ZPL2)
STATIC VOID MenuZpl2Darkness(VOID)
{
PrintDarkness =
NumMenu((CHAR **)LCDMessage[MSG_DARKNESS], PrintDarkness, 30, 0, 1);
}
STATIC VOID MenuZpl2PrintSpeed(VOID)
{
INT Speed = atoi(ToSpeedString(ToSpeed(PrintSpeed)));
PrintSpeed =
NumMenu((CHAR **)LCDMessage[MSG_PRINT_SPEED], Speed, MENU_SPEED_MAX, MENU_SPEED_MIN, 1);
}
STATIC VOID MenuZpl2TearOff(VOID)
{
AdjustPosition =
EditNumMenu((CHAR **)LCDMessage[MSG_ADJUST_POSITION], AdjustPosition, 120, TRUE, FALSE, _NULL);
}
STATIC VOID MenuZpl2PrintMode(VOID)
{
CONST STATIC _SetItem SetItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_TEAR_OFF], 'T'},
{(CHAR **)LCDMessage[MSG_PEEL_OFF], 'P'},
{(CHAR **)LCDMessage[MSG_CUTTER], 'C'},
{(CHAR **)LCDMessage[MSG_EXIT], SET_ITEM_EXIT},
{(CHAR **)_NULL, _NULL}
};
// Accepted Values: T = Tear-off, P = Peel-off, C = Cutter
PrintMode =
(_ePrintOutMode)SetMenu((_SetItem *)SetItem, PrintMode, (CHAR **)LCDMessage[MSG_PRINT_MODE]);
}
STATIC VOID MenuZpl2PrintWidth(VOID)
{
LabelWidth =
EditNumMenu((CHAR **)LCDMessage[MSG_PRINT_WIDTH], LabelWidth, MAX_LABEL_WIDTH, FALSE, TRUE, _NULL);
}
STATIC VOID MenuZpl2MaximumLength(VOID)
{
MaxLabelLength =
EditNumMenu((CHAR **)LCDMessage[MSG_MAXIMUM_LENGTH], MaxLabelLength, MAX_LABEL_LENGTH, FALSE, TRUE, _NULL);
}
STATIC VOID MenuZpl2ListFonts(VOID)
{
_ObjFile FileTTF = {'*', "*.TTF"};
_ObjFile FileFNT = {'*', "*.FNT"};
LeaveMenuFunc(TRUE);
SetDisplayStatus(DIS_SELFTEST);
DirectoryList(&FileTTF, OUTPUT_LABEL);
DirectoryList(&FileFNT, OUTPUT_LABEL);
ClrDisplayStatus(DIS_SELFTEST);
EntryMenuFunc();
}
STATIC VOID MenuZpl2ListImages(VOID)
{
_ObjFile FileGRF = {'*', "*.GRF"};
LeaveMenuFunc(TRUE);
SetDisplayStatus(DIS_SELFTEST);
DirectoryList(&FileGRF, OUTPUT_LABEL);
ClrDisplayStatus(DIS_SELFTEST);
EntryMenuFunc();
}
STATIC VOID MenuZpl2ListFormats(VOID)
{
_ObjFile FileZPL = {'*', "*.ZPL"};
LeaveMenuFunc(TRUE);
SetDisplayStatus(DIS_SELFTEST);
DirectoryList(&FileZPL, OUTPUT_LABEL);
ClrDisplayStatus(DIS_SELFTEST);
EntryMenuFunc();
}
STATIC VOID MenuZpl2ListSetup(VOID)
{
LeaveMenuFunc(TRUE);
SetDisplayStatus(DIS_SELFTEST);
ConfigLabel(OUTPUT_LABEL);
ClrDisplayStatus(DIS_SELFTEST);
EntryMenuFunc();
}
STATIC VOID MenuZpl2ControlPrefix(VOID)
{
TildeChar =
(CHAR)EditCharMenu((CHAR **)LCDMessage[MSG_CONTROL_PREFIX], (BYTE)TildeChar);
}
STATIC VOID MenuZpl2FormatPrefix(VOID)
{
CaretChar =
(CHAR)EditCharMenu((CHAR **)LCDMessage[MSG_FORMAT_PREFIX], (BYTE)CaretChar);
}
STATIC VOID MenuZpl2DelimiterChar(VOID)
{
DelimiterChar =
(CHAR)EditCharMenu((CHAR **)LCDMessage[MSG_DELIMITER_CHAR], (BYTE)DelimiterChar);
}
STATIC VOID MenuZpl2MediaPowerUp(VOID)
{
CONST STATIC _SetItem SetItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_FEED], 'F'},
{(CHAR **)LCDMessage[MSG_CALIBRATION], 'C'},
{(CHAR **)LCDMessage[MSG_LENGTH], 'L'},
{(CHAR **)LCDMessage[MSG_NO_MOTION], 'N'},
{(CHAR **)LCDMessage[MSG_EXIT], SET_ITEM_EXIT},
{(CHAR **)_NULL, _NULL}
};
// Accepted Values: F = feed, C = calibration, L = length, N = no motion
FeedPowerUp =
(_ePrintOutMode)SetMenu((_SetItem *)SetItem, FeedPowerUp, (CHAR **)LCDMessage[MSG_MEDIA_POWER_UP]);
}
STATIC VOID MenuZpl2HeadClose(VOID)
{
CONST STATIC _SetItem SetItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_FEED], 'F'},
{(CHAR **)LCDMessage[MSG_CALIBRATION], 'C'},
{(CHAR **)LCDMessage[MSG_LENGTH], 'L'},
{(CHAR **)LCDMessage[MSG_NO_MOTION], 'N'},
{(CHAR **)LCDMessage[MSG_EXIT], SET_ITEM_EXIT},
{(CHAR **)_NULL, _NULL}
};
// Accepted Values: F = feed, C = calibration, L = length, N = no motion
FeedCloseHead =
(_ePrintOutMode)SetMenu((_SetItem *)SetItem, FeedCloseHead, (CHAR **)LCDMessage[MSG_HEAD_CLOSE]);
}
STATIC VOID MenuZpl2LabelTop(VOID)
{
LabelTop =
EditNumMenu((CHAR **)LCDMessage[MSG_LABEL_TOP], LabelTop, 120, TRUE, FALSE, _NULL);
}
STATIC VOID MenuZpl2LeftPosition(VOID)
{
LabelShift =
EditNumMenu((CHAR **)LCDMessage[MSG_LEFT_POSITION], LabelShift, 9999, TRUE, FALSE, _NULL);
}
STATIC VOID MenuZpl2ReprintMode(VOID)
{
}
STATIC VOID MenuZpl2Setup(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_DARKNESS], MenuZpl2Darkness},
{(CHAR **)LCDMessage[MSG_PRINT_SPEED], MenuZpl2PrintSpeed},
{(CHAR **)LCDMessage[MSG_ADJUST_POSITION], MenuZpl2TearOff},
{(CHAR **)LCDMessage[MSG_PRINT_MODE], MenuZpl2PrintMode},
{(CHAR **)LCDMessage[MSG_PRINT_WIDTH], MenuZpl2PrintWidth},
// {(CHAR **)LCDMessage[MSG_MAXIMUM_LENGTH], MenuZpl2MaximumLength},
{(CHAR **)LCDMessage[MSG_LIST_FONTS], MenuZpl2ListFonts},
{(CHAR **)LCDMessage[MSG_LIST_IMAGES], MenuZpl2ListImages},
{(CHAR **)LCDMessage[MSG_LIST_FORMATS], MenuZpl2ListFormats},
{(CHAR **)LCDMessage[MSG_LIST_SETUP], MenuZpl2ListSetup},
{(CHAR **)LCDMessage[MSG_CONTROL_PREFIX], MenuZpl2ControlPrefix},
{(CHAR **)LCDMessage[MSG_FORMAT_PREFIX], MenuZpl2FormatPrefix},
{(CHAR **)LCDMessage[MSG_DELIMITER_CHAR], MenuZpl2DelimiterChar},
{(CHAR **)LCDMessage[MSG_MEDIA_POWER_UP], MenuZpl2MediaPowerUp},
{(CHAR **)LCDMessage[MSG_HEAD_CLOSE], MenuZpl2HeadClose},
{(CHAR **)LCDMessage[MSG_LABEL_TOP], MenuZpl2LabelTop},
{(CHAR **)LCDMessage[MSG_LEFT_POSITION], MenuZpl2LeftPosition},
// {(CHAR **)LCDMessage[MSG_REPRINT_MODE], MenuZpl2ReprintMode},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
ConfigurationUpdata(RECALL_LAST_SAVED_VALUES);
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_PRINT_SETUP]);
ConfigurationUpdata(SAVE_CURRENT_SETTINGS);
}
#endif
STATIC VOID MenuPrinterSetup(VOID)
{
#if defined(ZPL2)
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_TSPL2], MenuTsplSetup},
{(CHAR **)LCDMessage[MSG_ZPL2], MenuZpl2Setup},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_PRINT_SETUP]);
#else
MenuTsplSetup();
#endif
}
STATIC VOID MenuSensorStatus(VOID)
{
CHAR Buf[20];
DspClearDisplay();
sprintf(Buf, "%-11s%5d", LCDMessage[MSG_PAPER_LEN][pMenuCfg->Language], (INT)pMenuCfg->fPaperSize);
ShowLCDString(0, 0, Buf, 0);
if (pMenuCfg->SensorMode == GAP_MODE)
sprintf(Buf, "%-12s%4d", LCDMessage[MSG_GAP_SIZE][pMenuCfg->Language], (INT)pMenuCfg->fGapSize);
else if (pMenuCfg->SensorMode == BLINE_MODE)
sprintf(Buf, "%-12s%4d", LCDMessage[MSG_BLINE_SIZE][pMenuCfg->Language], (INT)pMenuCfg->fBlineSize);
else
sprintf(Buf, "%-12s%4d", LCDMessage[MSG_GAP_SIZE][pMenuCfg->Language], 0);
ShowLCDString(0, 1, Buf, 0);
if (pMenuCfg->SensorMode == GAP_MODE)
sprintf(Buf, "%-13s%3d", LCDMessage[MSG_INTENSITY][pMenuCfg->Language], (INT)pMenuCfg->GapInten);
else if (pMenuCfg->SensorMode == BLINE_MODE)
sprintf(Buf, "%-13s%3d", LCDMessage[MSG_INTENSITY][pMenuCfg->Language], (INT)pMenuCfg->BlineInten);
else
sprintf(Buf, "%-13s%3d", LCDMessage[MSG_INTENSITY][pMenuCfg->Language], (INT)pMenuCfg->ContinuousInten);
ShowLCDString(0, 2, Buf, 0);
if (pMenuCfg->AutoSensorRef && (pMenuCfg->SensorMode == GAP_MODE || pMenuCfg->SensorMode == BLINE_MODE))
sprintf(Buf, "%-12s%4s", LCDMessage[MSG_REF_LEVEL][pMenuCfg->Language], LCDMessage[MSG_AUTO][pMenuCfg->Language]);
else if (pMenuCfg->SensorMode == GAP_MODE)
sprintf(Buf, "%-12s%4d", LCDMessage[MSG_REF_LEVEL][pMenuCfg->Language], (INT)pMenuCfg->GapRef);
else if (pMenuCfg->SensorMode == BLINE_MODE)
sprintf(Buf, "%-12s%4d", LCDMessage[MSG_REF_LEVEL][pMenuCfg->Language], (INT)pMenuCfg->BlineRef);
else
sprintf(Buf, "%-12s%4d", LCDMessage[MSG_REF_LEVEL][pMenuCfg->Language], (INT)pMenuCfg->ContinuousRef);
ShowLCDString(0, 3, Buf, 0);
while (CheckKeyPin(SELECT_KEY)){}
MenuWaitKey();
}
STATIC BOOL MenuSensorManual(_eSensorMode mode, INT *intenback, INT *refback)
{
CHAR buf[20], *title, *msg[2];
_eSensorType type;
INT step, stock[2][MAX_SENSOR_SCALE], *max, *min;
INT scale, gain;
INT inten, ref;
INT keyback;
INT i;
BOOL status = FALSE;
if (mode == GAP_MODE)
{
title = (CHAR *)LCDMessage[MSG_GAP_MODE][pMenuCfg->Language];
msg[0] = (CHAR *)LCDMessage[MSG_SCAN_BACKING][pMenuCfg->Language];
msg[1] = (CHAR *)LCDMessage[MSG_SCAN_PAPER][pMenuCfg->Language];
scale = GAP_SENSOR_SCALE;
type = GAP_SENSOR;
gain = pMenuCfg->GapInten;
}
else if (mode == BLINE_MODE)
{
title = (CHAR *)LCDMessage[MSG_BLINE_MODE][pMenuCfg->Language];
msg[0] = (CHAR *)LCDMessage[MSG_SCAN_MARK][pMenuCfg->Language];
msg[1] = (CHAR *)LCDMessage[MSG_SCAN_PAPER][pMenuCfg->Language];
scale = BLINE_SENSOR_SCALE;
type = BLINE_SENSOR;
gain = pMenuCfg->BlineInten;
}
else
{
title = (CHAR *)LCDMessage[MSG_CONTINUOUS_MODE][pMenuCfg->Language];
msg[0] = (CHAR *)LCDMessage[MSG_REMOVE_LABEL][pMenuCfg->Language];
msg[1] = (CHAR *)LCDMessage[MSG_SCAN_PAPER][pMenuCfg->Language];
scale = GAP_SENSOR_SCALE;
type = GAP_SENSOR;
gain = pMenuCfg->ContinuousInten;
}
DspClearDisplay();
ShowLCDString(0, 0, title, 0);
for (step = 0; step < 2; step++)
{
DspClearLine(1, LCD_LANG_ENG);
ShowLCDString(0, 1, msg[step], 0);
gain = EditGainMenu(type, gain, scale - 1, 0, &keyback);
if (keyback == MENU_KEY)
return status;
for (i = 0; i < scale; i++)
{
EnableSensor(type, i, pMenuCfg->RibbonFlag, HALF_AD_SCALE);
DelayTime(0x800000 / scale);
StartADConvert(GAP_SENSOR_AD);
stock[step][i] = ReadAD(GAP_SENSOR_AD);
}
DisableSensor(type);
}
max = stock[0];
min = stock[1];
#if defined(GAP_LEVEL_DOWN)
if (type == GAP_SENSOR)
{
min = stock[0];
max = stock[1];
}
#endif
#if defined(BLINE_LEVEL_DOWN)
if (type == BLINE_SENSOR)
{
min = stock[0];
max = stock[1];
}
#endif
if (mode == GAP_MODE && GetGapSensorReverse())
{
INT *tmp = max;
max = min;
min = tmp;
}
inten = 0;
for (i = 0; i < scale; i++)
{
if (max[i] < min[i])
continue;
if (max[inten] - min[inten] < max[i] - min[i])
inten = i;
}
ref = GetSensorRef(type, max[inten], min[inten]);
DspClearDisplay();
ShowLCDString(0, 0, title, 0);
if (max[inten] - min[inten] < 128)
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_CANT_CALIBRATE][pMenuCfg->Language], 0);
status = FALSE;
}
else
{
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_COMPLETE][pMenuCfg->Language], 0);
sprintf(buf, "%-13s%3d", LCDMessage[MSG_INTENSITY][pMenuCfg->Language], inten);
ShowLCDString(0, 2, buf, 0);
sprintf(buf, "%-12s%4d", LCDMessage[MSG_REF_LEVEL][pMenuCfg->Language], ref);
ShowLCDString(0, 3, buf, 0);
*intenback = inten;
*refback = ref;
status = TRUE;
}
while (CheckKeyPin(SELECT_KEY)){}
MenuWaitKey();
return status;
}
STATIC VOID MenuGapAuto(VOID)
{
#ifdef DEBUG_PRNT
sysprintf("Enter MenuGapAuto()...\n"); // ch_20211208
#endif
DspClearDisplay();
ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_GAP_MODE][pMenuCfg->Language], 0);
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_AUTOMATIC][pMenuCfg->Language], 0);
LeaveMenuFunc(TRUE);
pMenuCfg->SensorMode = GAP_MODE;
pMenuCfg->AutoSensorRef = TRUE;
DetectSensorInten(pMenuCfg, TRUE, FALSE, 0, 0);
EntryMenuFunc();
}
STATIC VOID MenuGapManual(VOID)
{
INT paper, gap;
INT inten, ref;
INT keyback;
paper = EditNumMenu((CHAR **)LCDMessage[MSG_PAPER_LEN],
(INT)pMenuCfg->fPaperSize, MAX_IMAGE_LENGTH, FALSE, TRUE, &keyback);
if (keyback == MENU_KEY)
return;
gap = EditNumMenu((CHAR **)LCDMessage[MSG_GAP_SIZE],
(INT)pMenuCfg->fGapSize, (TPH_DPI * 5), FALSE, TRUE, &keyback);
if (keyback == MENU_KEY)
return;
if (MenuSensorManual(GAP_MODE, &inten, &ref))
{
pMenuCfg->SensorMode = GAP_MODE;
pMenuCfg->fPaperSize = paper;
pMenuCfg->fGapSize = gap;
pMenuCfg->AutoSensorRef = FALSE;
pMenuCfg->GapInten = inten;
pMenuCfg->GapRef = ref;
InitialCalibration();
}
}
STATIC VOID MenuGapPreprint(VOID)
{
INT PrePaper, PreGapBline;
INT keyback;
#ifdef DEBUG_PRNT
sysprintf("Enter MenuGapPreprint()...\n"); // ch_20211208
#endif
PrePaper = EditNumMenu((CHAR **)LCDMessage[MSG_PAPER_LEN],
(INT)pMenuCfg->fPaperSize, MAX_IMAGE_LENGTH, FALSE, TRUE, &keyback);
if (keyback == MENU_KEY)
return;
PreGapBline = EditNumMenu((CHAR **)LCDMessage[MSG_GAP_SIZE],
(INT)pMenuCfg->fGapSize, (TPH_DPI * 5), FALSE, TRUE, &keyback);
if (keyback == MENU_KEY)
return;
DspClearDisplay();
ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_GAP_MODE][pMenuCfg->Language], 0);
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_PRE_PRINTED][pMenuCfg->Language], 0);
LeaveMenuFunc(TRUE);
pMenuCfg->SensorMode = GAP_MODE;
pMenuCfg->AutoSensorRef = FALSE;
DetectSensorInten(pMenuCfg, TRUE, FALSE, PrePaper, PreGapBline);
EntryMenuFunc();
}
STATIC VOID MenuGapMode(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_AUTOMATIC], MenuGapAuto},
{(CHAR **)LCDMessage[MSG_MANUAL], MenuGapManual},
{(CHAR **)LCDMessage[MSG_PRE_PRINTED], MenuGapPreprint},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_GAP_MODE]);
}
STATIC VOID MenuBlineAuto(VOID)
{
#ifdef DEBUG_PRNT
sysprintf("Enter MenuBlineAuto()...\n"); // ch_20211208
#endif
DspClearDisplay();
ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_BLINE_MODE][pMenuCfg->Language], 0);
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_AUTOMATIC][pMenuCfg->Language], 0);
LeaveMenuFunc(TRUE);
pMenuCfg->SensorMode = BLINE_MODE;
pMenuCfg->AutoSensorRef = TRUE;
DetectSensorInten(pMenuCfg, TRUE, FALSE, 0, 0);
EntryMenuFunc();
}
STATIC VOID MenuBlineManual(VOID)
{
INT paper, bline;
INT inten, ref;
INT keyback;
paper = EditNumMenu((CHAR **)LCDMessage[MSG_PAPER_LEN],
(INT)pMenuCfg->fPaperSize, MAX_IMAGE_LENGTH, FALSE, TRUE, &keyback);
if (keyback == MENU_KEY)
return;
bline = EditNumMenu((CHAR **)LCDMessage[MSG_BLINE_SIZE],
(INT)pMenuCfg->fGapSize, (TPH_DPI * 5), FALSE, TRUE, &keyback);
if (keyback == MENU_KEY)
return;
if (MenuSensorManual(BLINE_MODE, &inten, &ref))
{
pMenuCfg->SensorMode = BLINE_MODE;
pMenuCfg->fPaperSize = paper;
pMenuCfg->fBlineSize = bline;
pMenuCfg->AutoSensorRef = FALSE;
pMenuCfg->BlineInten = inten;
pMenuCfg->BlineRef = ref;
InitialCalibration();
}
}
STATIC VOID MenuBlinePreprint(VOID)
{
INT PrePaper, PreGapBline;
INT keyback;
#ifdef DEBUG_PRNT
sysprintf("Enter MenuBlinePreprint()...\n"); // ch_20211208
#endif
PrePaper = EditNumMenu((CHAR **)LCDMessage[MSG_PAPER_LEN],
(INT)pMenuCfg->fPaperSize, MAX_IMAGE_LENGTH, FALSE, TRUE, &keyback);
if (keyback == MENU_KEY)
return;
PreGapBline = EditNumMenu((CHAR **)LCDMessage[MSG_BLINE_SIZE],
(INT)pMenuCfg->fBlineSize, (TPH_DPI * 5), FALSE, TRUE, &keyback);
if (keyback == MENU_KEY)
return;
DspClearDisplay();
ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_BLINE_MODE][pMenuCfg->Language], 0);
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_PRE_PRINTED][pMenuCfg->Language], 0);
LeaveMenuFunc(TRUE);
pMenuCfg->SensorMode = BLINE_MODE;
pMenuCfg->AutoSensorRef = FALSE;
DetectSensorInten(pMenuCfg, TRUE, FALSE, PrePaper, PreGapBline);
EntryMenuFunc();
}
STATIC VOID MenuBlineMode(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_AUTOMATIC], MenuBlineAuto},
{(CHAR **)LCDMessage[MSG_MANUAL], MenuBlineManual},
{(CHAR **)LCDMessage[MSG_PRE_PRINTED], MenuBlinePreprint},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_BLINE_MODE]);
}
STATIC VOID MenuContAuto(VOID)
{
DspClearDisplay();
ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_CONTINUOUS_MODE][pMenuCfg->Language], 0);
ShowLCDString(0, 1, (CHAR *)LCDMessage[MSG_AUTOMATIC][pMenuCfg->Language], 0);
delay_msec(500);
LeaveMenuFunc(TRUE);
pMenuCfg->SensorMode = CONTINUE_MODE_T;
DetectContinuousInten(pMenuCfg);
EntryMenuFunc();
}
STATIC VOID MenuContManual(VOID)
{
INT inten, ref;
if (MenuSensorManual(CONTINUE_MODE_T, &inten, &ref))
{
pMenuCfg->SensorMode = CONTINUE_MODE_T;
pMenuCfg->ContinuousInten = inten;
pMenuCfg->ContinuousRef = ref;
InitialCalibration();
}
}
STATIC VOID MenuContMode(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_AUTOMATIC], MenuContAuto},
{(CHAR **)LCDMessage[MSG_MANUAL], MenuContManual},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_CONTINUOUS_MODE]);
}
STATIC VOID MenuSensorCalibration(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_GAP_MODE], MenuGapMode},
{(CHAR **)LCDMessage[MSG_BLINE_MODE], MenuBlineMode},
{(CHAR **)LCDMessage[MSG_CONTINUOUS_MODE], MenuContMode},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_CALIBRATION]);
}
STATIC VOID MenuSensor(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_STATUS], MenuSensorStatus},
{(CHAR **)LCDMessage[MSG_CALIBRATION], MenuSensorCalibration},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_SENSOR]);
}
STATIC VOID MenuSerialBaudRate(VOID)
{
CONST STATIC _SetItem SetItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_1200BPS], UART_BAUD_1200},
{(CHAR **)LCDMessage[MSG_2400BPS], UART_BAUD_2400},
{(CHAR **)LCDMessage[MSG_4800BPS], UART_BAUD_4800},
{(CHAR **)LCDMessage[MSG_9600BPS], UART_BAUD_9600},
{(CHAR **)LCDMessage[MSG_19200BPS], UART_BAUD_19200},
{(CHAR **)LCDMessage[MSG_38400BPS], UART_BAUD_38400},
{(CHAR **)LCDMessage[MSG_57600BPS], UART_BAUD_57600},
{(CHAR **)LCDMessage[MSG_115200BPS], UART_BAUD_115200},
{(CHAR **)LCDMessage[MSG_EXIT], SET_ITEM_EXIT},
{(CHAR **)_NULL, _NULL}
};
pMenuCfg->UartSetting.Baud =
SetMenu((_SetItem *)SetItem, pMenuCfg->UartSetting.Baud, (CHAR **)LCDMessage[MSG_BAUD_RATE]);
}
STATIC VOID MenuSerialParity(VOID)
{
CONST STATIC _SetItem SetItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_NONE], UART_PARITY_NONE},
{(CHAR **)LCDMessage[MSG_ODD], UART_PARITY_ODD},
{(CHAR **)LCDMessage[MSG_EVEN], UART_PARITY_EVEN},
{(CHAR **)LCDMessage[MSG_EXIT], SET_ITEM_EXIT},
{(CHAR **)_NULL, _NULL}
};
pMenuCfg->UartSetting.Parity =
SetMenu((_SetItem *)SetItem, pMenuCfg->UartSetting.Parity, (CHAR **)LCDMessage[MSG_PARITY]);
}
STATIC VOID MenuSerialDataBits(VOID)
{
CONST STATIC _SetItem SetItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_7DATA_BITS], UART_DATA_7},
{(CHAR **)LCDMessage[MSG_8DATA_BITS], UART_DATA_8},
{(CHAR **)LCDMessage[MSG_EXIT], SET_ITEM_EXIT},
{(CHAR **)_NULL, _NULL}
};
pMenuCfg->UartSetting.DataBits =
SetMenu((_SetItem *)SetItem, pMenuCfg->UartSetting.DataBits, (CHAR **)LCDMessage[MSG_DATA_BITS]);
}
STATIC VOID MenuSerialStopBits(VOID)
{
CONST STATIC _SetItem SetItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_ONE_STOP_BIT], UART_STOP_ONE},
{(CHAR **)LCDMessage[MSG_TWO_STOP_BITS], UART_STOP_TWO},
{(CHAR **)LCDMessage[MSG_EXIT], SET_ITEM_EXIT},
{(CHAR **)_NULL, _NULL}
};
pMenuCfg->UartSetting.Stop =
SetMenu((_SetItem *)SetItem, pMenuCfg->UartSetting.Stop, (CHAR **)LCDMessage[MSG_STOP_BITS]);
}
STATIC VOID MenuSerialComm(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_BAUD_RATE], MenuSerialBaudRate},
{(CHAR **)LCDMessage[MSG_PARITY], MenuSerialParity},
{(CHAR **)LCDMessage[MSG_DATA_BITS], MenuSerialDataBits},
{(CHAR **)LCDMessage[MSG_STOP_BITS], MenuSerialStopBits},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_SERIAL_COMM]);
UartSetting(pMenuCfg->UartSetting);
}
STATIC VOID MenuSetDate(VOID)
{
STATIC CONST LONG mdays[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
CHAR *msg = (CHAR *)LCDMessage[MSG_DATE][pMenuCfg->Language];
CHAR buf[20], rev[12];
LONG date[3] = { GetRTC(RTC_YEAR), GetRTC(RTC_MONTH), GetRTC(RTC_DATE) };
INT index = 0;
DspClearDisplay();
ShowLCDString(((16 - strlen(msg)) / 2), 1, msg, 0);
while (1)
{
sprintf(buf, "%04u/%02u/%02u", date[0], date[1], date[2]);
sprintf(rev, "%0*u", (index ? 2 : 4), date[index]);
ShowLCDString(((16 - strlen(buf)) / 2), 2, buf, 0);
ShowLCDString(((16 - strlen(buf)) / 2) + (index * 3) + (index ? 2 : 0), 2, rev, 1);
while (CheckKeyPin(SELECT_KEY)){}
while (CheckBuzzerStatus()){}
switch (MenuWaitKey())
{
case MENU_KEY: // exit
return;
case UP_KEY: // next
if (MenuWriteProtect())
break;
date[index] += 1;
if (date[0] > 2030)
date[0] = 1970;
if (date[1] > 12)
date[1] = 1;
if (date[2] > mdays[date[1] - 1])
date[2] = 1;
break;
case DOWN_KEY: // shift
index = (index + 1) % 3;
break;
case SELECT_KEY: // entry
SetRTC(RTC_YEAR, date[0]);
SetRTC(RTC_MONTH, date[1]);
SetRTC(RTC_DATE, date[2]);
return;
}
}
}
STATIC VOID MenuSetTime(VOID)
{
CHAR *msg = (CHAR *)LCDMessage[MSG_TIME][pMenuCfg->Language];
CHAR buf[20], rev[12];
LONG time[3] = { GetRTC(RTC_HOUR), GetRTC(RTC_MIN), GetRTC(RTC_SEC) };
INT index = 0;
DspClearDisplay();
ShowLCDString(((16 - strlen(msg)) / 2), 1, msg, 0);
while (1)
{
sprintf(buf, "%02u:%02u:%02u", time[0], time[1], time[2]);
sprintf(rev, "%02u", time[index]);
ShowLCDString(((16 - strlen(buf)) / 2), 2, buf, 0);
ShowLCDString(((16 - strlen(buf)) / 2) + (index * 3), 2, rev, 1);
while (CheckKeyPin(SELECT_KEY)){}
while (CheckBuzzerStatus()){}
switch (MenuWaitKey())
{
case MENU_KEY: // exit
return;
case UP_KEY: // next
if (MenuWriteProtect())
break;
time[index] = (time[index] + 1) % (index ? 60 : 24);
break;
case DOWN_KEY: // shift
index = (index + 1) % 3;
break;
case SELECT_KEY: // entry
SetRTC(RTC_HOUR, time[0]);
SetRTC(RTC_MIN, time[1]);
SetRTC(RTC_SEC, time[2]);
return;
}
}
}
STATIC VOID MenuDateTime(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_DATE], MenuSetDate},
{(CHAR **)LCDMessage[MSG_TIME], MenuSetTime},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_DATE_TIME]);
}
STATIC VOID MenuRibbonWound(VOID)
{
CONST STATIC _SetItem SetItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_INK_SIDE_IN], TRUE},
{(CHAR **)LCDMessage[MSG_INK_SIDE_OUT], FALSE},
{(CHAR **)LCDMessage[MSG_EXIT], SET_ITEM_EXIT},
{(CHAR **)_NULL, _NULL}
};
pMenuCfg->RibbonInside =
(_ePrintOutMode)SetMenu((_SetItem *)SetItem, pMenuCfg->RibbonInside, (CHAR **)LCDMessage[MSG_RIBBON_WOUND]);
}
#if defined(NUTNET)
STATIC VOID MenuNetShowIP(VOID)
{
INT Key = SELECT_KEY;
INT Page = 0;
while (1)
{
DspClearDisplay();
if (Page == 0)
{
ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_IP_ADDRESS][pMenuCfg->Language], 0);
ShowLCDString(0, 1, inet_ntoa(GetNetworkIP(ITEM_IP_ADDRESS)), 0);
ShowLCDString(0, 2, (CHAR *)LCDMessage[MSG_SUBNET_MASK][pMenuCfg->Language], 0);
ShowLCDString(0, 3, inet_ntoa(GetNetworkIP(ITEM_SUBNET_MASK)), 0);
LcdPut(119, 55, 8, 8, (UCHAR *)IcoNext, 0);
}
else if (Page == 1)
{
ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_GATEWAY][pMenuCfg->Language], 0);
ShowLCDString(0, 1, inet_ntoa(GetNetworkIP(ITEM_GATEWAY)), 0);
LcdPut(119, 0, 8, 8, (UCHAR *)IcoPrev, 0);
}
while (CheckKeyPin(Key)){}
Key = MenuWaitKey();
if (Key == UP_KEY) // up page
Page = 0;
if (Key == DOWN_KEY) // down page
Page = 1;
if (Key == MENU_KEY || Key == SELECT_KEY) // exit
return;
}
}
STATIC VOID MenuNetShowMac(VOID)
{
CHAR Buf[20];
DspClearDisplay();
ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_MAC_ADDRESS][pMenuCfg->Language], 0);
sprintf(Buf, "%02X%02X%02X-%02X%02X%02X",
pMenuCfg->confnet.cdn_mac[0], pMenuCfg->confnet.cdn_mac[1],
pMenuCfg->confnet.cdn_mac[2], pMenuCfg->confnet.cdn_mac[3],
pMenuCfg->confnet.cdn_mac[4], pMenuCfg->confnet.cdn_mac[5]);
ShowLCDString(0, 1, Buf, 0);
while (CheckKeyPin(SELECT_KEY)){}
MenuWaitKey();
}
//STATIC VOID MenuNetShowProtocol(VOID)
//{
// DspClearDisplay();
// ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_TCPIP_PROTOCOL][pMenuCfg->Language], 0);
// while (CheckKeyPin(SELECT_KEY)){}
// MenuWaitKey();
//}
STATIC VOID MenuNetStatus(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_IP_ADDRESS], MenuNetShowIP},
{(CHAR **)LCDMessage[MSG_MAC], MenuNetShowMac},
// {(CHAR **)LCDMessage[MSG_PROTOCOL], MenuNetShowProtocol},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_STATUS]);
}
STATIC VOID MenuNetDHCP(VOID)
{
if (!SureMenu((CHAR **)LCDMessage[MSG_DHCP]))
return;
// If this address is set to 0.0.0.0, will try
// to obtain one from the DHCP server.
pMenuCfg->confnet.cdn_cip_addr = 0;
DspClearDisplay();
PrinterReboot();
}
STATIC VOID MenuNetStaticIP(VOID)
{
ULONG ip, mask, geteway;
INT keyback;
ip = EditAddrMenu((CHAR **)LCDMessage[MSG_IP_ADDRESS], pMenuCfg->confnet.cdn_cip_addr, &keyback);
if (keyback == MENU_KEY)
return;
mask = EditAddrMenu((CHAR **)LCDMessage[MSG_SUBNET_MASK], pMenuCfg->confnet.cdn_ip_mask, &keyback);
if (keyback == MENU_KEY)
return;
geteway = EditAddrMenu((CHAR **)LCDMessage[MSG_GATEWAY], pMenuCfg->confnet.cdn_gateway, &keyback);
if (keyback == MENU_KEY)
return;
if (!SureMenu((CHAR **)LCDMessage[MSG_STATIC_IP]))
return;
// Configure IP address
pMenuCfg->confnet.cdn_cip_addr = ip;
pMenuCfg->confnet.cdn_ip_mask = mask;
pMenuCfg->confnet.cdn_gateway = geteway;
DspClearDisplay();
PrinterReboot();
}
STATIC VOID MenuNetConfigure(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_DHCP], MenuNetDHCP},
{(CHAR **)LCDMessage[MSG_STATIC_IP], MenuNetStaticIP},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_CONFIGURE]);
}
//STATIC VOID MenuNetReset(VOID)
//{
// if (!SureMenu((CHAR **)LCDMessage[MSG_RESET]))
// return;
//
// DspClearDisplay();
// PrinterReboot();
//}
STATIC VOID MenuEthernet(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_STATUS], MenuNetStatus},
{(CHAR **)LCDMessage[MSG_CONFIGURE], MenuNetConfigure},
// {(CHAR **)LCDMessage[MSG_RESET], MenuNetReset},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_ETHERNET]);
}
#endif
STATIC VOID MenuSetup(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_PRINT_SETUP], MenuPrinterSetup},
{(CHAR **)LCDMessage[MSG_SENSOR], MenuSensor},
{(CHAR **)LCDMessage[MSG_SERIAL_COMM], MenuSerialComm},
{(CHAR **)LCDMessage[MSG_DATE_TIME], MenuDateTime},
#if defined(TTP286M_MACH)
{(CHAR **)LCDMessage[MSG_RIBBON_WOUND], MenuRibbonWound},
#endif
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
#if defined(NUTNET)
CONST STATIC _MenuItem MenuItemNet[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_PRINT_SETUP], MenuPrinterSetup},
{(CHAR **)LCDMessage[MSG_SENSOR], MenuSensor},
{(CHAR **)LCDMessage[MSG_SERIAL_COMM], MenuSerialComm},
{(CHAR **)LCDMessage[MSG_DATE_TIME], MenuDateTime},
#if defined(TTP286M_MACH)
{(CHAR **)LCDMessage[MSG_RIBBON_WOUND], MenuRibbonWound},
#endif
{(CHAR **)LCDMessage[MSG_ETHERNET], MenuEthernet},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
if (GetThreadByName("ethernet"))
RunMenu((_MenuItem *)MenuItemNet, 0, (CHAR **)LCDMessage[MSG_SETUP]);
else
#endif
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_SETUP]);
}
STATIC VOID MenuFilesListDram(VOID)
{
FileMenu((CHAR **)LCDMessage[MSG_DRAM_FILE_LIST], DRAM_DEVICE);
}
STATIC VOID MenuFilesListFlash(VOID)
{
FileMenu((CHAR **)LCDMessage[MSG_FLASH_FILE_LIST], FLASH_DEVICE);
}
STATIC VOID MenuFilesListCard(VOID)
{
FileMenu((CHAR **)LCDMessage[MSG_CARD_FILE_LIST], CARD_DEVICE);
}
STATIC VOID MenuFileList(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_DRAM], MenuFilesListDram},
{(CHAR **)LCDMessage[MSG_FLASH], MenuFilesListFlash},
{(CHAR **)LCDMessage[MSG_CARD], MenuFilesListCard},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_FILE_LIST]);
}
STATIC VOID MenuAvailMemory(VOID)
{
CHAR Buf[20];
DspClearDisplay();
ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_AVAIL_MEM][pMenuCfg->Language], 0);
sprintf(Buf, "DRAM: %7d KB", FreeSpace(DRAM_DEVICE));
ShowLCDString(0, 1, Buf, 0);
sprintf(Buf, "FLASH:%7d KB", FreeSpace(FLASH_DEVICE));
ShowLCDString(0, 2, Buf, 0);
sprintf(Buf, "CARD: %7d KB", FreeSpace(CARD_DEVICE));
ShowLCDString(0, 3, Buf, 0);
while (CheckKeyPin(SELECT_KEY)){}
MenuWaitKey();
}
STATIC VOID MenuClearDramAllFile(VOID)
{
if (!SureMenu((CHAR **)LCDMessage[MSG_DEL_ALL_FILE]))
return;
DspClearDisplay();
ErasingFile(DRAM_DEVICE, "*");
}
STATIC VOID MenuClearFlashAllFile(VOID)
{
if (!SureMenu((CHAR **)LCDMessage[MSG_DEL_ALL_FILE]))
return;
DspClearDisplay();
ErasingFile(FLASH_DEVICE, "*");
}
STATIC VOID MenuClearCardAllFile(VOID)
{
if (!SureMenu((CHAR **)LCDMessage[MSG_DEL_ALL_FILE]))
return;
DspClearDisplay();
ErasingFile(CARD_DEVICE, "*");
}
STATIC VOID MenuClearAllFile(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_DRAM], MenuClearDramAllFile},
{(CHAR **)LCDMessage[MSG_FLASH], MenuClearFlashAllFile},
{(CHAR **)LCDMessage[MSG_CARD], MenuClearCardAllFile},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_DELETE]);
}
STATIC VOID MenuFileManager(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_FILE_LIST], MenuFileList},
{(CHAR **)LCDMessage[MSG_AVAIL_MEM], MenuAvailMemory},
{(CHAR **)LCDMessage[MSG_DEL_ALL_FILE], MenuClearAllFile},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_FILE_MANAGER]);
}
STATIC VOID MenuDiagPrinterConfig(VOID)
{
REPORT *Report;
LeaveMenuFunc(TRUE);
SetDisplayStatus(DIS_SELFTEST);
Report = SelfTestReport(NULL, FALSE, OUTPUT_LABEL);
#if defined(NUTNET)
if (GetThreadByName("ethernet"))
Report = IpConfigReport(Report, FALSE, OUTPUT_LABEL);
#endif
FileReport(Report, TRUE, OUTPUT_LABEL);
ClrDisplayStatus(DIS_SELFTEST);
EntryMenuFunc();
}
STATIC VOID MenuDiagDataDump(VOID)
{
LeaveMenuFunc(TRUE);
HexDumpMode();
EntryMenuFunc();
}
STATIC VOID MenuDiagRotateCutter(VOID)
{
LeaveMenuFunc(TRUE);
while (CutterClear() == CUTTER_CUTTING){}
EntryMenuFunc();
}
//STATIC VOID MenuDiagPrintHead(VOID)
//{
// CHAR Buf[20];
// INT Temp;
//
// DspClearDisplay();
// ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_PRINT_HEAD][pMenuCfg->Language], 0);
//
// StartADConvert(TPH_TEMP_AD);
// Temp = ReadAD(TPH_TEMP_AD);
// Temp = CalculateTPHTemp(Temp);
//
// sprintf(Buf, "%-12s%4d",(CHAR *)LCDMessage[MSG_TEMPERATURE][pMenuCfg->Language], Temp);
// ShowLCDString(0, 1, Buf, 0);
//
// sprintf(Buf, "%-12s%4d",(CHAR *)LCDMessage[MSG_RESISTANCE][pMenuCfg->Language], 0);
// ShowLCDString(0, 2, Buf, 0);
//
// sprintf(Buf, "%-12s%4d",(CHAR *)LCDMessage[MSG_BAD_DOTS][pMenuCfg->Language], 0);
// ShowLCDString(0, 3, Buf, 0);
//
// while (CheckKeyPin(SELECT_KEY)){}
// MenuWaitKey();
//}
STATIC VOID MenuDiagnostics(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)NULL, _NULL},
{(CHAR **)LCDMessage[MSG_PRINTER_CFG], MenuDiagPrinterConfig},
{(CHAR **)LCDMessage[MSG_DUMPMODE], MenuDiagDataDump},
{(CHAR **)LCDMessage[MSG_ROTATE_CUTTER], MenuDiagRotateCutter},
// {(CHAR **)LCDMessage[MSG_PRINT_HEAD], MenuDiagPrintHead},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_DIAGNOSTICS]);
}
STATIC VOID MenuLanguage(VOID)
{
CONST STATIC _SetItem SetItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_ENGLISH], LCD_LANG_ENG},
{(CHAR **)LCDMessage[MSG_TC], LCD_LANG_TC},
{(CHAR **)LCDMessage[MSG_SC], LCD_LANG_SC},
{(CHAR **)LCDMessage[MSG_JP], LCD_LANG_JP},
{(CHAR **)LCDMessage[MSG_KOREAN], LCD_LANG_KOREAN},
{(CHAR **)LCDMessage[MSG_GERMAN], LCD_LANG_GERMAN},
{(CHAR **)LCDMessage[MSG_ITALIC], LCD_LANG_ITA},
{(CHAR **)LCDMessage[MSG_FRENCH], LCD_LANG_FRECH},
{(CHAR **)LCDMessage[MSG_RUSSAIN], LCD_LANG_RUSSAIN},
{(CHAR **)LCDMessage[MSG_POLISH], LCD_LANG_POLISH},
{(CHAR **)LCDMessage[MSG_SPANISH], LCD_LANG_SPANISH},
{(CHAR **)LCDMessage[MSG_LITHUANIAN], LCD_LANG_LITHUANIAN},
{(CHAR **)LCDMessage[MSG_CZECH], LCD_LANG_CZECH},
{(CHAR **)LCDMessage[MSG_EXIT], SET_ITEM_EXIT},
{(CHAR **)_NULL, _NULL}
};
pMenuCfg->Language =
SetMenu((_SetItem *)SetItem, pMenuCfg->Language, (CHAR **)LCDMessage[MSG_LANGUAGE]);
}
STATIC VOID MenuInitialization(VOID)
{
if (!SureMenu((CHAR **)LCDMessage[MSG_INITIALIZATION]))
return;
DspClearDisplay();
SetDisplayStatus(DIS_INITIAL);
InitialDefaultVar();
delay_msec(1000);
ClrDisplayStatus(DIS_INITIAL);
}
STATIC VOID MenuMileageInfo(VOID)
{
CHAR Buf[20];
DspClearDisplay();
ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_MILEAGE][pMenuCfg->Language], 0);
sprintf(Buf, "%16d", pMenuRec->DotMilage / (INT)(MM_DOT * 1000));
ShowLCDString(0, 1, Buf, 0);
ShowLCDString(0, 2, (CHAR *)LCDMessage[MSG_LABEL][pMenuCfg->Language], 0);
sprintf(Buf, "%16d", pMenuRec->LabelMilage);
ShowLCDString(0, 3, Buf, 0);
while (CheckKeyPin(SELECT_KEY)){}
MenuWaitKey();
}
STATIC VOID MenuSerialNumber(VOID)
{
CHAR Buf[32];
DspClearDisplay();
ShowLCDString(0, 0, (CHAR *)LCDMessage[MSG_SERIAL][pMenuCfg->Language], 0);
sprintf(Buf, "%16s", pMenuRec->SerialNumberName);
ShowLCDString(0, 1, Buf, 0);
if (strlen(Buf) > 16)
ShowLCDString(0, 2, Buf + 16, 0);
while (CheckKeyPin(SELECT_KEY)){}
MenuWaitKey();
}
STATIC VOID MenuService(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_INITIALIZATION], MenuInitialization},
{(CHAR **)LCDMessage[MSG_MILEAGE_INFO], MenuMileageInfo},
{(CHAR **)LCDMessage[MSG_SERIAL_INFO], MenuSerialNumber},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_SERVICE]);
}
VOID MainMenu(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_SETUP], MenuSetup},
{(CHAR **)LCDMessage[MSG_FILE_MANAGER], MenuFileManager},
{(CHAR **)LCDMessage[MSG_DIAGNOSTICS], MenuDiagnostics},
{(CHAR **)LCDMessage[MSG_LANGUAGE], MenuLanguage},
#if defined(GRAPHIC_PRODUCT)
{(CHAR **)LCDMessage[MSG_INITIALIZATION], MenuInitialization},
#else
{(CHAR **)LCDMessage[MSG_SERVICE], MenuService},
#endif
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
ClrDisplayStatus(DIS_READY);
EntryMenuFunc();
InitialMenu();
sysprintf("InitialMenu MENUVER2\r\n");
EnableBuzzer(26, 100);
while (CheckBuzzerStatus()){}
DspClearDisplay();
while (CheckKeyPin(MENU_KEY)){}
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_MAIN_MENU]);
LeaveMenuFunc(TRUE);
SetDisplayStatus(DIS_READY);
}
STATIC VOID MenuJobCancel(VOID)
{
CancelActiveJob();
ExitMenu = TRUE;
}
STATIC VOID MenuJobReset(VOID)
{
PrinterReboot();
}
VOID JobMenu(VOID)
{
CONST STATIC _MenuItem MenuItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_CANCEL], MenuJobCancel},
{(CHAR **)LCDMessage[MSG_RESET], MenuJobReset},
{(CHAR **)LCDMessage[MSG_EXIT], _NULL},
{(CHAR **)_NULL, _NULL}
};
BOOL KeyFunc = StopKeyFunc();
ClrDisplayStatus(DIS_READY);
#if defined(CARRIAGE_OPEN_MODEL)
StopCheckCarriageOpen();
#endif
InitialMenu();
sysprintf("InitialMenu MENUVER3\r\n");
EnableBuzzer(26, 100);
while (CheckBuzzerStatus()){}
DspClearDisplay();
while (CheckKeyPin(MENU_KEY)){}
RunMenu((_MenuItem *)MenuItem, 0, (CHAR **)LCDMessage[MSG_JOB_MANAGER]);
SetDisplayStatus(DIS_READY);
LeaveMenuFunc(KeyFunc);
}
INT ErrorMenu(VOID)
{
CONST STATIC _SetItem SetItem[] =
{
{(CHAR **)_NULL, _NULL},
{(CHAR **)LCDMessage[MSG_CANCEL], 1},
{(CHAR **)LCDMessage[MSG_RESET], 2},
{(CHAR **)LCDMessage[MSG_EXIT], SET_ITEM_EXIT},
{(CHAR **)_NULL, _NULL}
};
BOOL KeyFunc = StopKeyFunc();
INT Select = -1;
#ifdef DEBUG_PRNT
sysprintf("Enter ErrorMenu()...\n"); // ch_20211210
#endif
ClrDisplayStatus(DIS_READY);
#if defined(CARRIAGE_OPEN_MODEL)
StopCheckCarriageOpen();
#endif
InitialMenu();
sysprintf("ErrorMenu3\r\n");
EnableBuzzer(26, 100);
while (CheckBuzzerStatus()){}
DspClearDisplay();
while (CheckKeyPin(MENU_KEY)){}
Select = SetMenu((_SetItem *)SetItem, Select, (CHAR **)LCDMessage[MSG_JOB_MANAGER]);
SetDisplayStatus(DIS_READY);
LeaveMenuFunc(KeyFunc);
return Select;
}
VOID SensorMenu(_eSensorMode Mode)
{
BOOL KeyFunc = EntryMenuFunc();
INT Inten, Ref;
ClrDisplayStatus(DIS_READY);
InitialMenu();
sysprintf("SensorMenu3\r\n");
EnableBuzzer(26, 100);
if (MenuSensorManual(Mode, &Inten, &Ref))
{
if (Mode == GAP_MODE)
{
pMenuCfg->AutoSensorRef = FALSE;
pMenuCfg->GapInten = Inten;
pMenuCfg->GapRef = Ref;
}
else if (Mode == BLINE_MODE)
{
pMenuCfg->AutoSensorRef = FALSE;
pMenuCfg->BlineInten = Inten;
pMenuCfg->BlineRef = Ref;
}
else
{
pMenuCfg->ContinuousInten = Inten;
pMenuCfg->ContinuousRef = Ref;
}
pMenuCfg->SensorMode = Mode;
InitialCalibration();
}
LeaveMenuFunc(KeyFunc);
SetDisplayStatus(DIS_READY);
}
#endif
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
