Tspl.c
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define TSPL_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 <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/******************************************************************************
* *
* U S E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/
#include "Common.h"
#include "XCore.h"
#include "XProFile.h"
#include "..\Parser.h"
#include "..\ParserUtil.h"
#include "VarMgr.h"
#include "expr.h"
#include "TsplCnt.h"
#include "TsplFunc.h"
#include "TsplUtil.h"
#include "Tspl.h"
/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/
#if defined(TSPL)
#define REPLACE_NUMBER_MAX 10
/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
/******************************************************************************
* *
* 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 CHAR ReplaceCmdBuf[REPLACE_NUMBER_MAX][TOKEN_LEN];
/******************************************************************************
*
* Function:
* CheckEquation
*
* Description:
*
*
* Input:
* None
*
* Output:
* None.
*
******************************************************************************/
STATIC BOOL CheckEquation(CHAR *pToken)
{
BYTE data;
BYTE buff[STRING_LEN];
INT s = 0;
RemoveSpace();
data = NextByte();
if (data != '=')
{
BackByte(data);
return FALSE;
}
data = NextByte();
// get a line
while (data != 0 && !CheckChar(data, "\r\n\x1a"))
{
buff[s++] = data;
if (s >= sizeof(buff))
return FALSE;
data = NextByte();
}
BackByte(data);
buff[s] = 0;
if (SetEquation(EQU_EXPRESSION, (BYTE *)pToken, buff))
return TRUE;
return FALSE;
}
/******************************************************************************
*
* Function:
* InitialTsplFunc
*
* Description:
*
*
* Input:
* None
*
* Output:
* None.
*
******************************************************************************/
BOOL InitialTspl(VOID)
{
CHAR key[128];
FLOAT data;
INT i, replace;
InitialExp();
InitialGlobalVar(); /* initial variable */
BasClearHandle();
ClearCounter();
for (i = 0; i < 256; i++)
TsplRemapChar[i] = (BYTE)i;
SetCodePageCross(LANG_TSPL, &pPrintCfg->CodePage, TsplRemapChar);
memset(&sBasicData, 0, sizeof(sBasicData));
// file command file handle
UseHandle_0 = _NULL;
UseHandle_1 = _NULL;
// maxi code mode default
MaxiCodeMode = 2;
// driver copy
DriverCopy = 0;
// for key print
PrintSets = 1;
PrintCopies = 1;
replace = 0;
//sysprintf("TsplEntry--\n");
// replace command
for (i = 0; TsplEntry[i].keyword != _NULL; i++)
{
if (replace >= REPLACE_NUMBER_MAX)
break;
sprintf(key, "REPLACE %s \n", TsplEntry[i].keyword);
if (GetProfileString(key, ReplaceCmdBuf[replace]))
TsplEntry[i].keyword = ReplaceCmdBuf[replace++];
}
// replace SET command
for (i = 0; SetEntry[i].keyword != _NULL; i++)
{
if (replace >= REPLACE_NUMBER_MAX)
break;
sprintf(key, "REPLACE SET %s", SetEntry[i].keyword);
if (GetProfileString(key, ReplaceCmdBuf[replace]))
SetEntry[i].keyword = ReplaceCmdBuf[replace++];
}
InputFilter = FALSE;
if (GetProfileInt("MIDDLEAMERICA", &data))
InputFilter = (BOOL)data;
else if (GetProfileInt("INPUTFILTER", &data))
InputFilter = (BOOL)data;
#if defined(TSPL_VER_1)
CRLF_IsInputData = FALSE;
#else
CRLF_IsInputData = TRUE;
#endif
if (GetProfileInt("IS CRLF INPUT DATA", &data))
CRLF_IsInputData = (BOOL)data;
BasFileKey = 0;
if (GetProfileInt("BASIC PROTECT", &data))
BasFileKey = (INT)data;
return TRUE;
}
/******************************************************************************
*
* Function:
* TscSyntaxParsing
*
* Description:
*
*
* Input:
* None
*
* Output:
* None.
*
******************************************************************************/ //pc下发打印开始会进来执行
/*这段代码实现了一个TSPL（TSC Printer Command Language）语法解析函数。函数的返回类型是BOOL
函数首先定义了一个指针CmdEntry和两个字符数组abString和Data。然后调用ClearParserPool函数清空解析池。
这段代码实现了一个TSPL语法解析函数，它通过逐个解析输入的字节和标记字符串，并根据不同的情况执行相应的命令函数或运行Basic文件。
函数的返回值表示解析是否成功
*/
BOOL TscSyntaxParsing(VOID) //<--VOID Parser(VOID)
{
_CmdEntry *CmdEntry = FALSE;
CHAR abString[TOKEN_LEN];
CHAR Data;
ClearParserPool();
while (1)
{
Data = NextByte(); //读取下一个字节给Data
// check TSPL single command
if (CmdEntry = CheckSingleCommand(Data, DriverEntry)) //检查是否是TSPL的单个命令，并将CmdEntry指向对应的命令入口结构体
{
if (CmdEntry->func() == _SUCCESS) //如果找到了单个命令并且成功执行了该命令的函数，则返回TRUE；否则跳出循环。
return TRUE;
break;
}
BackByte(Data); //将Data字节退回。
if (iscntrl(Data)) //如果Data是控制字符，则跳出循环
break;
// get command token
if (GetToken(abString, &Data, "\r\n\t =", sizeof(abString)) >= (sizeof(abString) - 1)) //获取命令的标记字符串（token），存储在abString中
break;
BackByte(Data); //并将Data字节退回
//sysprintf("TsplEntry--22\n"); //pc打印进来循环几次（14）
// check TSPL normal command
if (CmdEntry = CheckStringCommand(abString, TsplEntry)) // 检查abString是否是TSPL的普通命令，并将CmdEntry指向对应的命令入口结构体
{
if (CmdEntry->func() == _SUCCESS) //8.如果找到了普通命令并且成功执行了该命令的函数，则返回TRUE；否则跳出循环。
return TRUE;
break;
}
// check TSPL basic Command
if (CmdEntry = CheckStringCommand(abString, BasicEntry)) //9. 检查abString是否是TSPL的基本命令，并将CmdEntry指向对应的命令入口结构体。
{
if (CmdEntry->func() == _SUCCESS) //10.如果找到了基本命令并且成功执行了该命令的函数，则返回TRUE；否则跳出循环。
return TRUE;
break;
}
// check basic label
if (CheckBasLable(abString)) //11.检查abString是否是基本标签命令，如果是则返回TRUE。
return TRUE;
// check equation
if (CheckEquation(abString)) //12.检查abString是否是等式，如果是则返回TRUE。
return TRUE;
if (sBasicData.UseHandle == _NULL) //13.如果sBasicData.UseHandle为_NULL，则尝试运行一个Basic文件。
{
_FileList List;
BOOL Find = FALSE;
// Run Basic File
if (strcmp(strchr(abString, '.'), ".BAS") != 0) //14.首先将abString的扩展名改为".BAS"
strcat(abString, ".BAS");
// Find a file by name //15.依次在DRAM_DEVICE、FLASH_DEVICE和CARD_DEVICE中查找文件，如果找到了文件，则设置sBasicData.UseHandle为对应的文件句柄，并执行RunFile函数运行Basic文件。
OpenList(&List, DRAM_DEVICE);
if (NextFile(&List, abString))
Find = TRUE;
OpenList(&List, FLASH_DEVICE);
if (NextFile(&List, abString))
Find = TRUE;
OpenList(&List, CARD_DEVICE);
if (NextFile(&List, abString))
Find = TRUE;
while (Find == TRUE)
{
// for INPUT command
RemoveLine();
RemoveLF();
if ((sBasicData.UseHandle = RunFile(DRAM_DEVICE, abString, BasFileKey, BasClearHandle)) == _NULL)
if ((sBasicData.UseHandle = RunFile(FLASH_DEVICE, abString, BasFileKey, BasClearHandle)) == _NULL)
if ((sBasicData.UseHandle = RunFile(CARD_DEVICE, abString, BasFileKey, BasClearHandle)) == _NULL)
break;
BasInitialBASIC(); //16.在运行Basic文件之后，调用BasInitialBASIC函数进行初始化，并返回TRUE
return TRUE;
}
}
break; //17.跳出循环。
}
if (!BackParsePool()) //18.如果无法退回解析池，则返回TRUE。
return TRUE;
return FALSE;
}
/******************************************************************************
*
* Function:
* RunBasicFile
*
* Description:
*
*
* Input:
* None
*
* Output:
* None.
*
******************************************************************************/
BOOL RunBasicFile(_eFileDevice device, CHAR *filename)
{
if (sBasicData.UseHandle)
return FALSE;
UserDataIn(NUL_CHAR);
sBasicData.UseHandle = RunFile(device, filename, BasFileKey, BasClearHandle);
if (sBasicData.UseHandle != _NULL)
BasInitialBASIC();
return TRUE;
}
/******************************************************************************
*
* Function:
* CheckAutoBas
*
* Description:
*
*
* Input:
* None
*
* Output:
* None.
*
******************************************************************************/
VOID CheckAutoBas(VOID)
{
if ((sBasicData.UseHandle = RunFile(DRAM_DEVICE, (CHAR *)pPrintCfg->AutoRun, BasFileKey, BasClearHandle)) == _NULL)
if ((sBasicData.UseHandle = RunFile(CARD_DEVICE, (CHAR *)pPrintCfg->AutoRun, BasFileKey, BasClearHandle)) == _NULL)
if ((sBasicData.UseHandle = RunFile(FLASH_DEVICE, (CHAR *)pPrintCfg->AutoRun, BasFileKey, BasClearHandle)) == _NULL)
return;
BasInitialBASIC();
}
/******************************************************************************
*
* Function:
* TsplPrintFunc
*
* Description:
*
*
* Input:
* None
*
* Output:
* None.
*
******************************************************************************/
VOID TsplPrintFunc(INT Quantity)
{
if (Quantity)
PrintImageLabel(Quantity, 1);
else
PrintImageLabel(PrintSets, PrintCopies);
// sysprintf("PIL_2\n");
}
#endif
Tspl.h //
#ifndef TSPL_H
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define TSPL_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 "XFileSys.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 *
* *
******************************************************************************/
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
#ifdef TSPL_C
#define EXTERN
#else
#define EXTERN extern
#endif
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
/******************************************************************************
* *
* F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/
BOOL InitialTspl(VOID);
BOOL TscSyntaxParsing(VOID);
BOOL RunBasicFile(_eFileDevice, CHAR *);
VOID CheckAutoBas(VOID);
VOID TsplPrintFunc(INT);
#undef EXTERN
#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */
#endif
TsplBtFunc.c
#include "Common.h"
#if defined(UART2_BT)
#if !defined(UART2_BUFFER)
#error "Please open the UART2_BUFFER macros"
#endif
#include "XBt.h"
#include "XCore.h"
#include "XComm.h"
#include "XUart.h"
#include "string.h"
#include "XVarBank.h"
#include "XTask.h"
#include "XTimer.h"
#include "..\ParserUtil.h"
#include "TsplUtil.h"
#define BT_COMMAND_START1 '\n'
#define BT_COMMAND_START2 '\r'
#define BT_COMMAND_END1 '\r'
#define BT_COMMAND_END2 '\n'
#define BT_COMMAND_RESET "AT+REBOOT\r\n"
#define BT_RETURN_RESET "OK"
#define BT_COMMAND_NAME "AT+NAME\r\n"
#define BT_RETURN_NAME "+NAME="
#define BT_COMMAND_PIN "AT+PIN\r\n"
#define BT_RETURN_PIN "+PIN="
#define BT_COMMAND_MAC "AT+ADDR\r\n"
#define BT_RETURN_MAC "+ADDR="
#define BT_COMMAND_VERSIONS "AT+VER\r\n"
#define BT_RETURN_VERSIONS "+VER="
#define BT_COMMAND_MODE_1 "AT+SFM=1\r\n"
#define BT_COMMAND_MODE_0 "AT+SFM=0\r\n"
#define BT_RETURN_MODE "OK"
#define BT_COMMAND_SET_NAME "AT+NAME="
#define BT_COMMAND_SET_PIN "AT+PIN="
STATIC VOID BtComSend(BYTE *msg, INT len);
STATIC VOID BtInterCommandMode(VOID);
STATIC VOID BtExitCommandMode(VOID);
STATIC INT BtComReceive(BYTE *msg);
STATIC BOOL _BtGetMsg(BYTE * buffer,BYTE * com,BYTE * callback);
_BtSetting *BtSetting;
Uart2CallbackFunctionType CallbackFunction = {Uart2ButterReceiveISR,Uart2ButterTransmitISR};
Uart2CallbackFunctionType CallbackFunCom = {Uart2RxDataIn,NULL};
STATIC VOID BtInterCommandMode(VOID)
{
#if defined(AT91SAM9260)
AT91F_PIO_CfgOutput(AT91C_BASE_PIOB, AT91C_PIO_PB15);
AT91F_PIO_SetOutput(AT91C_BASE_PIOB, AT91C_PIO_PB15);
#elif defined(N3290)
gpio_setportdir(GPIO_PORTB,BIT6,BIT6);
gpio_setportval(GPIO_PORTB,BIT6,BIT6);
#endif
}
STATIC VOID BtExitCommandMode(VOID)
{
#if defined(AT91SAM9260)
AT91F_PIO_CfgOutput(AT91C_BASE_PIOB, AT91C_PIO_PB15);
AT91F_PIO_ClearOutput(AT91C_BASE_PIOB, AT91C_PIO_PB15);
#elif defined(N3290)
gpio_setportdir(GPIO_PORTB,BIT6,BIT6);
gpio_setportval(GPIO_PORTB,BIT6,0);
#endif
}
STATIC INT BtGetValue(BYTE * id,BYTE *msg,INT len)
{
INT i,j = 0;
INT start = 0,end = 0;
for ( i = 0 ; i < len; i++ )
{
if(msg[i] == '\r'||msg[i] == '\n')
{
if(start&&(end == 0))
end = i;
}
else if ( id[j] == 0 )
{
if(start == 0)
start = i;
}
else if(msg[i] == id[j])
j++;
}
if(end > start)
{
for ( i = start,j=0 ; i <end ; i++,j++ )
msg[j] = msg[i] ;
msg[j] = 0;
len = end-start;
}
else
len = 0;
return len;
}
STATIC BOOL CheckBtMacValue(BYTE *msg,INT len)
{
INT i;
if(len == 12)
{
if(memcmp(BtSetting->mac,msg,12) == 0)
return TRUE;
for ( i = 0 ; i <12 ; i++ )
{
if((msg[i]>='0'&&msg[i]<='9')||(msg[i]>='A'&&msg[i]<='F'))
;
else
break;
}
if(i ==12)
{
memcpy(BtSetting->mac, msg, 12);
return TRUE;
}
}
return FALSE;
}
BOOL BtGetMsg(INT id,BYTE * buffer)
{
BOOL reg = FALSE;
switch ( id )
{
case 0 :
reg = _BtGetMsg(buffer,BT_COMMAND_NAME,BT_RETURN_NAME);
break;
case 1 :
reg = _BtGetMsg(buffer,BT_COMMAND_PIN,BT_RETURN_PIN);
break;
case 2 :
reg = _BtGetMsg(buffer,BT_COMMAND_MAC,BT_RETURN_MAC);
break;
case 3 :
reg = _BtGetMsg(buffer,BT_COMMAND_VERSIONS,BT_RETURN_VERSIONS);
break;
case 4 :
reg = _BtGetMsg(buffer,BT_COMMAND_RESET,BT_RETURN_RESET);
break;
case 5 :
reg = _BtGetMsg(buffer,BT_COMMAND_MODE_0,BT_RETURN_MODE);
break;
case 6 :
reg = _BtGetMsg(buffer,BT_COMMAND_MODE_1,BT_RETURN_MODE);
break;
case 30 :
buffer[1] = '\0';
buffer[0] = '0';
if(BtSetting->enble)
buffer[0] = '1';
reg = TRUE;
break;
case 31 :
strncpy((CHAR *)buffer,(CHAR *)BtSetting->name, BT_NAME_MAX_LEN);
reg = TRUE;
break;
case 32 :
strncpy((CHAR *)buffer, (CHAR *)BtSetting->pin, BT_PIN_MAX_LEN);
reg = TRUE;
break;
case 33 :
strncpy((CHAR *)buffer, BtSetting->mac, 12);
reg = TRUE;
break;
case 34 :
strncpy((CHAR *)buffer, BtSetting->ver, BT_VER_MAX_LEN);
reg = TRUE;
break;
default:
break;
}
return reg;
}
STATIC BOOL _BtGetMsg(BYTE * buffer,BYTE * com,BYTE * callback)
{
BYTE msg[32];
INT len = 0;
BOOL reg = FALSE;
BtInterCommandMode();
delay_msec(10);
Uart2SetCallbackFun(CallbackFunCom);
BtComSend(com,strlen((CHAR *)com));
len = BtComReceive(msg);
if(len)
{
if(BtGetValue(callback,msg,len))
{
strncpy((CHAR *)buffer,(CHAR *)msg,len);
reg = TRUE;
}
}
Uart2SetCallbackFun(CallbackFunction);
BtExitCommandMode();
return reg;
}
VOID BtComMode(BOOL mode,BOOL pin)
{
if(mode)
Uart2SetCallbackFun(CallbackFunCom);
else
Uart2SetCallbackFun(CallbackFunction);
if(pin)
BtInterCommandMode();
else
BtExitCommandMode();
}
BOOL BtSetName(BYTE * name)
{
BYTE msg[32];
INT len = 0;
BOOL reg = FALSE;
BtInterCommandMode();
delay_msec(10);
Uart2SetCallbackFun(CallbackFunCom);
BtComSend(BT_COMMAND_SET_NAME,strlen(BT_COMMAND_SET_NAME));
BtComSend(name,strlen((CHAR *)name));
BtComSend("\r\n",2);
len = BtComReceive(msg);
if(len)
{
reg = TRUE;
strncpy((CHAR *)BtSetting->name, (CHAR *)name,BT_NAME_MAX_LEN);
}
Uart2SetCallbackFun(CallbackFunction);
BtExitCommandMode();
return reg;
}
BOOL BtSetPin(BYTE * pin)
{
BYTE msg[32];
INT len = 0;
BOOL reg = FALSE;
BtInterCommandMode();
delay_msec(10);
Uart2SetCallbackFun(CallbackFunCom);
BtComSend(BT_COMMAND_SET_PIN,strlen(BT_COMMAND_SET_PIN));
BtComSend(pin,strlen((CHAR *)pin));
BtComSend("\r\n",2);
len = BtComReceive(msg);
if(len)
{
reg = TRUE;
strncpy((CHAR *)BtSetting->pin, (CHAR *)pin,BT_PIN_MAX_LEN);
}
Uart2SetCallbackFun(CallbackFunction);
BtExitCommandMode();
return reg;
}
STATIC TASK(CheckBtModule, arg)
{
BYTE msg[32];
INT len = 0;
INT i = 0;
INT count = 0;
#ifdef DEBUG_PRNT
sysprintf("Exec TASK(CheckBtModule, arg)()...\n"); // ch_20211209
#endif
BtInterCommandMode();
delay_msec(200);
while(count < 2)
{
BtComSend(BT_COMMAND_MAC,strlen(BT_COMMAND_MAC));
len = BtComReceive(msg);
if(len==0)
{
count++;
delay_msec(100);
}
else
{
if(CheckBtMacValue(msg,BtGetValue(BT_RETURN_MAC,msg,len)))
{
//if(strlen((CHAR *)BtSetting->ver) == 0)
{
while( BtComReceive(msg));
delay_msec(100);
BtComSend(BT_COMMAND_VERSIONS,strlen(BT_COMMAND_VERSIONS));
len = BtComReceive(msg);
if(len != 0)
{
for(i=0;i<len;i++)
{
if(msg[i]=='=')
{
memcpy(BtSetting->ver,&msg[i+1],len-i-1);
break;
}
}
if(i!=len)
break;
}
}
}
count++;
delay_msec(100);
}
}
if(count < 2)
{
while( BtComReceive(msg));
BtComSend(BT_COMMAND_SET_NAME,strlen(BT_COMMAND_SET_NAME));
BtComSend(BtSetting->name,strlen((CHAR *)BtSetting->name));
BtComSend("\r\n",2);
len = BtComReceive(msg);
while( BtComReceive(msg));
BtComSend(BT_COMMAND_SET_PIN,strlen(BT_COMMAND_SET_PIN));
BtComSend(BtSetting->pin,strlen((CHAR *)BtSetting->pin));
BtComSend("\r\n",2);
len = BtComReceive(msg);
Uart2SetCallbackFun(CallbackFunction);
SetBufferUart2Butter();
BtSetting->enble = TRUE;
}
else
{
BtSetting->enble = FALSE ;
}
BtExitCommandMode();
TaskExit();
}
VOID InitailBt(VOID)
{
_PrintCfg *PrintCfg = GrabPrintConfig();
#ifdef DEBUG_PRNT
sysprintf("Enter InitailBt()...\n"); // ch_20211209
#endif
BtSetting = &PrintCfg->BtSetting;
InitialUart2ButterDrv();
TaskCreate(CheckBtModule, 0, TASK_BT_STACK);
}
STATIC INT FN_SetName(VOID)
{
BYTE BtName[BT_NAME_MAX_LEN];
if (!GetExpString(LINE_END, (CHAR *)&BtName, sizeof(BtName))){
sysprintf("FN GetExpString error \r\n");
return _ERROR;
}
if(!BtSetName(BtName)){
sysprintf("FN BtSetName error \r\n");
return _ERROR;
}
return _SUCCESS;
}
STATIC INT FN_SetPin(VOID)
{
BYTE BtPin[BT_PIN_MAX_LEN];
if (!GetExpString(LINE_END, (CHAR *)&BtPin, sizeof(BtPin)))
return _ERROR;
if(!BtSetPin(BtPin))
return _ERROR;
return _SUCCESS;
}
INT FN_BT(VOID)
{
CHAR bTemp;
_CmdEntry *CmdEntry;
CONST STATIC _CmdEntry BTEntry[] =
{
{"NAME", FN_SetName},
{"PIN", FN_SetPin},
{(CHAR *)_NULL, _NULL}
};
CHAR Token[ STRING_LEN ];
INT CmdID;
RemoveSpace();
if (GetToken(Token, &bTemp, "\r\n\t ", sizeof(Token)) >= (sizeof(Token) - 1)){
sysprintf("bt gettoken error\r\n");
return _ERROR;
}
//BackByte(bTemp);
// check TSPL normal command
sysprintf("--->%s\r\n",Token);
sysprintf("FN_BT BtSetting->enble %d\r\n",BtSetting->enble);
if ((CmdEntry = CheckStringCommand(Token, BTEntry)) && BtSetting->enble)
{
if (CmdEntry->func() == _SUCCESS)
{
delay_msec(100);
return _SUCCESS;
}
return _ERROR;
}
return _ERROR;
}
STATIC VOID BtComSend(BYTE *msg, INT len)
{
Uart2Buffer(msg,len);
}
STATIC INT BtComReceive(BYTE *msg)
{
BYTE *target = msg;
INT delayNum,len = 0;
BYTE data = 0,flag_states = 0;
BYTE i;
delayNum = SetDelayTime(200);
while(!len)
{
// get start character
while (!Uart2GetByte(&data))
{
if (!CheckDelayTimer(delayNum))
{
ClrDelayTime(delayNum);
return 0;
}
continue;
}
if ((data != BT_COMMAND_START1)&&(data != BT_COMMAND_START2))
{
if(flag_states!=1)
continue;
}
else
{
flag_states = 1;
continue;
}
*target++ = data;
len ++;
while(data != BT_COMMAND_END1&&data != BT_COMMAND_END2)
{
while (!Uart2GetByte(&data))
{
if (!CheckDelayTimer(delayNum))
{
ClrDelayTime(delayNum);
return 0;
}
}
*target++ = data;
len ++;
}
}
ClrDelayTime(delayNum);
return (len);
}
#endif
TsplBtFunc.h //
/******************************************************************************
版权所有 (C), 2005-2015, 芯呈科技有限公司
******************************************************************************
文 件 名 : TsplBtFunc.h
版 本 号 : 初稿
作 者 : XINC_PRINTER
生成日期 : 2016年1月13日
最近修改 :
功能描述 : TsplBtFunc.c 的头文件
函数列表 :
修改历史 :
1.日 期 : 2016年1月13日
作 者 : XINC_PRINTER
修改内容 : 创建文件
******************************************************************************/
#ifndef __TSPLBTFUNC_H__
#define __TSPLBTFUNC_H__
/*----------------------------------------------*
* 包含头文件 *
*----------------------------------------------*/
/*----------------------------------------------*
* 常量定义 *
*----------------------------------------------*/
/*----------------------------------------------*
* 宏定义 *
*----------------------------------------------*/
#define BT_NAME_MAX_LEN 20
#define BT_PIN_MAX_LEN 10
#define BT_VER_MAX_LEN 10
/*----------------------------------------------*
* 外部变量说明 *
*----------------------------------------------*/
typedef struct
{
BYTE enble;
BYTE name[BT_NAME_MAX_LEN+1];
BYTE pin[BT_PIN_MAX_LEN+1];
CHAR mac[12+1];
CHAR ver[BT_VER_MAX_LEN+1];
}_BtSetting;
/*----------------------------------------------*
* 外部函数原型说明 *
*----------------------------------------------*/
/*----------------------------------------------*
* 内部函数原型说明 *
*----------------------------------------------*/
/*----------------------------------------------*
* 全局变量 *
*----------------------------------------------*/
/*----------------------------------------------*
* 模块级变量 *
*----------------------------------------------*/
#ifdef __cplusplus
#if __cplusplus
extern "C"{
#endif
#endif /* __cplusplus */
INT FN_BT(VOID);
VOID InitailBt(VOID);
BOOL BtSetName(BYTE * );
BOOL BtSetPin(BYTE * );
BOOL BtGetMsg(INT ,BYTE * );
VOID BtComMode(BOOL ,BOOL );
#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif /* __cplusplus */
#endif /* __TSPLBTFUNC_H__ */
TsplCnt.c /
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define TSPLCNT_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 <ctype.h>
#include <string.h>
/******************************************************************************
* *
* U S E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/
#include "Common.h"
#include "XText.h"
#include "XBarcode.h"
#include "XGraphic.h"
#include "XFunction.h"
#include "Expr.h"
#include "Error.h"
#include "VarMgr.h"
#include "TsplCnt.h"
extern UCHAR IsOnceCalDone(VOID); // ch_20220416
extern VOID RstOnceCaldoneFlg(VOID); // ch_20220416
/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/
#if defined(TSPL)
#define NARROW_LEVEL 6
/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
/******************************************************************************
* *
* 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 VOID EraseCntBox(_CounterLinkTable *pCntlink, _ImgBuf *pImgBuf)
{
_BarAttr sBarAttr;
sBarAttr.iType = DRAW_ERASE;
sBarAttr.psImageBuffer = pImgBuf;
sBarAttr.sCoord.iX = pCntlink->sEraseBox.iX;
sBarAttr.sCoord.iY = pCntlink->sEraseBox.iY;
sBarAttr.iWidth = pCntlink->sEraseBox.iWidth;
sBarAttr.iHeight = pCntlink->sEraseBox.iHeight;
DrawBar(&sBarAttr);
}
STATIC VOID StoreTextBox(_CounterLinkTable *pLink, _TextAttr *pTextAttr)
{
switch (pTextAttr->iDirection)
{
case 0:
pLink->sEraseBox.iX = pTextAttr->sCoord.iX;
pLink->sEraseBox.iY = pTextAttr->sCoord.iY;
pLink->sEraseBox.iWidth = pTextAttr->iRealWidth;
pLink->sEraseBox.iHeight = pTextAttr->iRealHeight;
break;
case 90:
pLink->sEraseBox.iX = pTextAttr->sCoord.iX - pTextAttr->iRealHeight;
pLink->sEraseBox.iY = pTextAttr->sCoord.iY;
pLink->sEraseBox.iWidth = pTextAttr->iRealHeight;
pLink->sEraseBox.iHeight = pTextAttr->iRealWidth;
break;
case 180:
pLink->sEraseBox.iX = pTextAttr->sCoord.iX - pTextAttr->iRealWidth;
pLink->sEraseBox.iY = pTextAttr->sCoord.iY - pTextAttr->iRealHeight;
pLink->sEraseBox.iWidth = pTextAttr->iRealWidth;
pLink->sEraseBox.iHeight = pTextAttr->iRealHeight;
break;
case 270:
pLink->sEraseBox.iX = pTextAttr->sCoord.iX ;
pLink->sEraseBox.iY = pTextAttr->sCoord.iY - pTextAttr->iRealWidth;
pLink->sEraseBox.iWidth = pTextAttr->iRealHeight;
pLink->sEraseBox.iHeight = pTextAttr->iRealWidth;
break;
}
if (pLink->sEraseBox.iX < 0)
pLink->sEraseBox.iX = 0;
if (pLink->sEraseBox.iY < 0)
pLink->sEraseBox.iY = 0;
}
STATIC VOID StoreBarcodeBox(_CounterLinkTable *pLink, _BarCodeAttr *pBarcodeAttr, _BarcodeTable *pBarcodeTable)
{
INT Height, Width = 0, Shift;
INT Data;
// normal barcode
if (pBarcodeTable->pEraseWidth == _NULL)
{
switch (pBarcodeAttr->iRotation)
{
case 0:
pLink->sEraseBox.iX = pBarcodeAttr->sCoord.iX;
pLink->sEraseBox.iY = pBarcodeAttr->sCoord.iY;
pLink->sEraseBox.iWidth = pBarcodeAttr->TotalWidth;
pLink->sEraseBox.iHeight = pBarcodeAttr->TotalHeight;
break;
case 90:
pLink->sEraseBox.iX = pBarcodeAttr->sCoord.iX - pBarcodeAttr->TotalHeight;
pLink->sEraseBox.iY = pBarcodeAttr->sCoord.iY;
pLink->sEraseBox.iWidth = pBarcodeAttr->TotalHeight;
pLink->sEraseBox.iHeight = pBarcodeAttr->TotalWidth;
break;
case 180:
pLink->sEraseBox.iX = pBarcodeAttr->sCoord.iX - pBarcodeAttr->TotalWidth;
pLink->sEraseBox.iY = pBarcodeAttr->sCoord.iY - pBarcodeAttr->TotalHeight;
pLink->sEraseBox.iWidth = pBarcodeAttr->TotalWidth;
pLink->sEraseBox.iHeight = pBarcodeAttr->TotalHeight;
break;
case 270:
pLink->sEraseBox.iX = pBarcodeAttr->sCoord.iX ;
pLink->sEraseBox.iY = pBarcodeAttr->sCoord.iY - pBarcodeAttr->TotalWidth;
pLink->sEraseBox.iWidth = pBarcodeAttr->TotalHeight;
pLink->sEraseBox.iHeight = pBarcodeAttr->TotalWidth;
break;
}
}
else
{
if (pBarcodeAttr->iHuman == 0)
{
Height = pBarcodeAttr->iHeight;
Shift = 0;
}
else
{
Height = pBarcodeAttr->iHeight + ((pBarcodeAttr->iNarrow + 1) << 3);
Shift = (pBarcodeAttr->iNarrow << 3);
}
Data = 0;
if (pBarcodeAttr->iHuman)
Data = 1;
Width = pBarcodeTable->pEraseWidth[Data * NARROW_LEVEL + (pBarcodeAttr->iNarrow - 1)];
#if defined(TSPL_VER_1)
Width += 16;
#endif
if (pBarcodeTable->Shift)
{
switch (pBarcodeAttr->iRotation)
{
case 0:
pLink->sEraseBox.iX = pBarcodeAttr->sCoord.iX - Shift;
pLink->sEraseBox.iY = pBarcodeAttr->sCoord.iY;
pLink->sEraseBox.iWidth = Width;
pLink->sEraseBox.iHeight = Height;
break;
case 90:
pLink->sEraseBox.iX = pBarcodeAttr->sCoord.iX - Height;
pLink->sEraseBox.iY = pBarcodeAttr->sCoord.iY - Shift;
pLink->sEraseBox.iWidth = Height;
pLink->sEraseBox.iHeight = Width;
break;
case 180:
pLink->sEraseBox.iX = pBarcodeAttr->sCoord.iX - Width + Shift;
pLink->sEraseBox.iY = pBarcodeAttr->sCoord.iY - Height;
pLink->sEraseBox.iWidth = Width;
pLink->sEraseBox.iHeight = Height;
break;
case 270:
pLink->sEraseBox.iX = pBarcodeAttr->sCoord.iX;
pLink->sEraseBox.iY = pBarcodeAttr->sCoord.iY - Width + Shift;
pLink->sEraseBox.iWidth = Height;
pLink->sEraseBox.iHeight = Width;
break;
}
}
else
{
switch (pBarcodeAttr->iRotation)
{
case 0:
pLink->sEraseBox.iX = pBarcodeAttr->sCoord.iX;
pLink->sEraseBox.iY = pBarcodeAttr->sCoord.iY;
pLink->sEraseBox.iWidth = Width;
pLink->sEraseBox.iHeight = Height;
break;
case 90:
pLink->sEraseBox.iX = pBarcodeAttr->sCoord.iX - Height;
pLink->sEraseBox.iY = pBarcodeAttr->sCoord.iY;
pLink->sEraseBox.iWidth = Height;
pLink->sEraseBox.iHeight = Width;
break;
case 180:
pLink->sEraseBox.iX = pBarcodeAttr->sCoord.iX - Width;
pLink->sEraseBox.iY = pBarcodeAttr->sCoord.iY - Height;
pLink->sEraseBox.iWidth = Width;
pLink->sEraseBox.iHeight = Height;
break;
case 270:
pLink->sEraseBox.iX = pBarcodeAttr->sCoord.iX;
pLink->sEraseBox.iY = pBarcodeAttr->sCoord.iY - Width;
pLink->sEraseBox.iWidth = Height;
pLink->sEraseBox.iHeight = Width;
break;
}
}
}
if (pLink->sEraseBox.iX < 0)
pLink->sEraseBox.iX = 0;
if (pLink->sEraseBox.iY < 0)
pLink->sEraseBox.iY = 0;
}
STATIC VOID Store2DBarcodeBox(_CounterLinkTable *pLink)
{
_AztecAttr *pAztecAttr = &(pLink->Data.sAztecAttr);
_DMatrixAttr *pDMatrixAttr = &(pLink->Data.sDMatrixAttr);
_MaxiAttr *pMaxiAttr = &(pLink->Data.sMaxiAttr);
_PDFAttr *pPDFAttr = &(pLink->Data.sPDFAttr);
_QRCodeAttr *pQRCodeAttr = &(pLink->Data.sQRCodeAttr);
_RSSAttr *pRSSAttr = &(pLink->Data.sRSSAttr);
_MPDFAttr *pMPDFAttr = &(pLink->Data.sMPdfAttr);
INT Rotate;
switch (pLink->CountType)
{
case AZTEC_COUNT:
pLink->sEraseBox.iX = pAztecAttr->sCoord.iX;
pLink->sEraseBox.iY = pAztecAttr->sCoord.iY;
pLink->sEraseBox.iWidth = pAztecAttr->TotalWidth;
pLink->sEraseBox.iHeight = pAztecAttr->TotalHeight;
Rotate = pAztecAttr->Rotate;
break;
case DMATRIX_COUNT:
pLink->sEraseBox.iX = pDMatrixAttr->sCoord.iX;
pLink->sEraseBox.iY = pDMatrixAttr->sCoord.iY;
pLink->sEraseBox.iWidth = pDMatrixAttr->TotalWidth;
pLink->sEraseBox.iHeight = pDMatrixAttr->TotalHeight;
Rotate = pDMatrixAttr->Rotate;
break;
case MAXI_COUNT:
pLink->sEraseBox.iX = pMaxiAttr->sCoord.iX;
pLink->sEraseBox.iY = pMaxiAttr->sCoord.iY;
pLink->sEraseBox.iWidth = pMaxiAttr->TotalWidth;
pLink->sEraseBox.iHeight = pMaxiAttr->TotalHeight;
Rotate = 0;
break;
case PDF_COUNT:
pLink->sEraseBox.iX = pPDFAttr->sCoord.iX;
pLink->sEraseBox.iY = pPDFAttr->sCoord.iY;
pLink->sEraseBox.iWidth = pPDFAttr->iWLimit;
pLink->sEraseBox.iHeight = pPDFAttr->iHLimit;
Rotate = pPDFAttr->Rotate;
break;
case MPDF_COUNT:
pLink->sEraseBox.iX = pMPDFAttr->sCoord.iX;
pLink->sEraseBox.iY = pMPDFAttr->sCoord.iY;
pLink->sEraseBox.iWidth = pMPDFAttr->TotalWidth;
pLink->sEraseBox.iHeight = pMPDFAttr->TotalHeight;
Rotate = pMPDFAttr->Rotate;
break;
case QRCODE_COUNT:
pLink->sEraseBox.iX = pQRCodeAttr->sCoord.iX;
pLink->sEraseBox.iY = pQRCodeAttr->sCoord.iY;
pLink->sEraseBox.iWidth = pQRCodeAttr->TotalWidth;
pLink->sEraseBox.iHeight = pQRCodeAttr->TotalHeight;
Rotate = pQRCodeAttr->Rotate;
break;
case RSS_COUNT:
pLink->sEraseBox.iX = pRSSAttr->sCoord.iX;
pLink->sEraseBox.iY = pRSSAttr->sCoord.iY;
pLink->sEraseBox.iWidth = pRSSAttr->TotalWidth;
pLink->sEraseBox.iHeight = pRSSAttr->TotalHeight;
Rotate = pRSSAttr->Rotate;
break;
}
if (Rotate == 90)
pLink->sEraseBox.iX -= pLink->sEraseBox.iWidth;
else if (Rotate == 180)
{
pLink->sEraseBox.iX -= pLink->sEraseBox.iWidth;
pLink->sEraseBox.iY -= pLink->sEraseBox.iHeight;
}
else if (Rotate == 270)
pLink->sEraseBox.iY -= pLink->sEraseBox.iHeight;
if (pLink->sEraseBox.iX < 0)
pLink->sEraseBox.iX = 0;
if (pLink->sEraseBox.iY < 0)
pLink->sEraseBox.iY = 0;
}
STATIC VOID DrawTextCnt(_CounterLinkTable *pCntlink)
{
_TextAttr sTextAttr = pCntlink->Data.sTextAttr;
BYTE *pToken = pCntlink->ExpData;
expMain(&pToken);
if (wErrorword != NO_ERROR || bExpKind != STRING_TYPE)
return;
sTextAttr.ExpLength = strlen((CHAR *)szRetStr);
sTextAttr.pExp = szRetStr;
sTextAttr.pFont = pCntlink->FontName;
if (pCntlink->Justification == 2 || pCntlink->Justification == 3)
{
SHORT Adjust = 0;
PreviewText(&sTextAttr);
if (pCntlink->Justification == 2) // align center
Adjust = sTextAttr.iRealWidth >> 1;
if (pCntlink->Justification == 3) // align right
Adjust = sTextAttr.iRealWidth;
if (sTextAttr.iRotation == 0)
sTextAttr.sCoord.iX -= Adjust;
if (sTextAttr.iRotation == 90)
sTextAttr.sCoord.iY -= Adjust;
if (sTextAttr.iRotation == 180)
sTextAttr.sCoord.iX += Adjust;
if (sTextAttr.iRotation == 270)
sTextAttr.sCoord.iY += Adjust;
}
OutText(&sTextAttr);
StoreTextBox(pCntlink, &sTextAttr);
}
STATIC VOID DrawBarcodeCnt(_CounterLinkTable *pCntlink)
{
_BarCodeAttr sBarcodeAttr = pCntlink->Data.sBarcodeAttr;
BYTE *pToken = pCntlink->ExpData;
expMain(&pToken);
if (wErrorword != NO_ERROR || bExpKind != STRING_TYPE)
return;
sBarcodeAttr.pFont = pCntlink->FontName;
sBarcodeAttr.pExp = (BYTE *)szRetStr;
if (pCntlink->Justification == 2 || pCntlink->Justification == 3)
{
SHORT Adjust = 0;
pCntlink->psBarcodeTab->PreviewBarcode(&sBarcodeAttr);
if (pCntlink->Justification == 2) // align center
Adjust = sBarcodeAttr.TotalWidth >> 1;
if (pCntlink->Justification == 3) // align right
Adjust = sBarcodeAttr.TotalWidth;
if (sBarcodeAttr.iRotation == 0)
sBarcodeAttr.sCoord.iX -= Adjust;
if (sBarcodeAttr.iRotation == 90)
sBarcodeAttr.sCoord.iY -= Adjust;
if (sBarcodeAttr.iRotation == 180)
sBarcodeAttr.sCoord.iX += Adjust;
if (sBarcodeAttr.iRotation == 270)
sBarcodeAttr.sCoord.iY += Adjust;
}
//#if defined(TSPL_VER_1)
if (strlen((CHAR *)sBarcodeAttr.pExp))
//#endif
pCntlink->psBarcodeTab->OutBarcode(&sBarcodeAttr);
StoreBarcodeBox(pCntlink, &sBarcodeAttr, pCntlink->psBarcodeTab);
}
STATIC VOID Draw2DBarcodeCnt(_CounterLinkTable *pCntlink)
{
_AztecAttr *pAztecAttr = &(pCntlink->Data.sAztecAttr);
_DMatrixAttr *pDMatrixAttr = &(pCntlink->Data.sDMatrixAttr);
_MaxiAttr *pMaxiAttr = &(pCntlink->Data.sMaxiAttr);
_PDFAttr *pPDFAttr = &(pCntlink->Data.sPDFAttr);
_QRCodeAttr *pQRCodeAttr = &(pCntlink->Data.sQRCodeAttr);
_RSSAttr *pRSSAttr = &(pCntlink->Data.sRSSAttr);
_MPDFAttr *pMPDFAttr = &(pCntlink->Data.sMPdfAttr);
BYTE *pToken = pCntlink->ExpData;;
// get Data
expMain(&pToken);
if (wErrorword != NO_ERROR || bExpKind != STRING_TYPE)
return;
switch (pCntlink->CountType)
{
case AZTEC_COUNT:
pAztecAttr->ExpLen = strlen((CHAR *)szRetStr);
pAztecAttr->pExp = (BYTE *)szRetStr;
ImpAztec(pAztecAttr, TRUE);
break;
case DMATRIX_COUNT:
pDMatrixAttr->ExpLen = strlen((CHAR *)szRetStr);
pDMatrixAttr->pExp = (BYTE *)szRetStr;
Dmatrix(pDMatrixAttr);
break;
case MAXI_COUNT:
pMaxiAttr->ExpLen = strlen((CHAR *)szRetStr);
pMaxiAttr->pExp = (BYTE *)szRetStr;
Maxi(pMaxiAttr);
break;
case PDF_COUNT:
pPDFAttr->ExpLen = strlen((CHAR *)szRetStr);
pPDFAttr->pExp = (BYTE *)szRetStr;
PDF(pPDFAttr);
break;
case MPDF_COUNT:
pMPDFAttr->pExp = (BYTE *)szRetStr;
pMPDFAttr->ExpLen = strlen((CHAR *)szRetStr);
MPDF(pMPDFAttr,FALSE);
break;
case QRCODE_COUNT:
pQRCodeAttr->ExpLen = strlen((CHAR *)szRetStr);
pQRCodeAttr->pExp = (BYTE *)szRetStr;
QRCode(pQRCodeAttr);
break;
case RSS_COUNT:
pRSSAttr->ExpLen = strlen((CHAR *)szRetStr);
pRSSAttr->pExp = (BYTE *)szRetStr;
RSS(pRSSAttr);
break;
default:
return;
}
Store2DBarcodeBox(pCntlink);
}
STATIC VOID CounterAdd(BYTE *pData, INT Step)
{
BYTE *pString;
INT Length;
INT i;
if (Step == 0)
return;
Length = strlen((CHAR *)pData);
pString = pData + Length - 1;
for (i = 0; i < Length; i++)
{
if (isdigit(*pString))
{
*pString += Step % 10;
if (*pString > '9')
{
*pString -= 10;
Step = Step / 10 + 1;
}
else if (*pString < '0')
{
*pString += 10;
Step = Step / 10 - 1;
}
else
Step /= 10;
}
else if (isupper(*pString))
{
*pString += Step % 26;
if (*pString > 'Z')
{
*pString -= 26;
Step = (Step - Step % 26) / 26 + 1;
}
else if (*pString < 'A')
{
*pString += 26;
Step = Step / 26 - 1;
}
else
Step /= 26;
}
else if (islower(*pString))
{
*pString += Step % 26;
if (*pString > 'z')
{
*pString -= 26;
Step = (Step - Step % 26) / 26 + 1;
}
else if (*pString < 'a')
{
*pString += 26;
Step = Step / 26 - 1;
}
else
Step /= 26;
}
else
break;
pString -= 1;
}
}
STATIC VOID CounterStep(VOID)
{
BYTE String[STRING_LEN];
INT Num;
for (Num = 0; GetCounterVariable(Num, String); Num++)
{
CounterAdd(String, GetCounterStep(Num));
SetCounterVariable(Num, String);
}
}
STATIC VOID RunCounter(VOID)
{
INT CntNumber;
CntNumber = 0;
while (sCntLinkTbl[CntNumber].CountType != NO_COUNT)
{
ReloadWaitTime();
EraseCntBox(&sCntLinkTbl[CntNumber], &sImageBuffer);
switch (sCntLinkTbl[CntNumber].CountType)
{
case TEXT_COUNT:
sCntLinkTbl[CntNumber].Data.sTextAttr.psImageBuffer = &sImageBuffer;
DrawTextCnt(&sCntLinkTbl[CntNumber]);
break;
case BARCODE_COUNT:
sCntLinkTbl[CntNumber].Data.sBarcodeAttr.psImageBuffer = &sImageBuffer;
DrawBarcodeCnt(&sCntLinkTbl[CntNumber]);
break;
case AZTEC_COUNT:
sCntLinkTbl[CntNumber].Data.sAztecAttr.psImageBuffer = &sImageBuffer;
Draw2DBarcodeCnt(&sCntLinkTbl[CntNumber]);
break;
case DMATRIX_COUNT:
sCntLinkTbl[CntNumber].Data.sDMatrixAttr.psImageBuffer = &sImageBuffer;
Draw2DBarcodeCnt(&sCntLinkTbl[CntNumber]);
break;
case MAXI_COUNT:
sCntLinkTbl[CntNumber].Data.sMaxiAttr.psImageBuffer = &sImageBuffer;
Draw2DBarcodeCnt(&sCntLinkTbl[CntNumber]);
break;
case PDF_COUNT:
sCntLinkTbl[CntNumber].Data.sPDFAttr.psImageBuffer = &sImageBuffer;
Draw2DBarcodeCnt(&sCntLinkTbl[CntNumber]);
break;
case MPDF_COUNT:
sCntLinkTbl[CntNumber].Data.sMPdfAttr.psImageBuffer = &sImageBuffer;
Draw2DBarcodeCnt(&sCntLinkTbl[CntNumber]);
break;
case QRCODE_COUNT:
sCntLinkTbl[CntNumber].Data.sQRCodeAttr.psImageBuffer = &sImageBuffer;
Draw2DBarcodeCnt(&sCntLinkTbl[CntNumber]);
break;
case RSS_COUNT:
sCntLinkTbl[CntNumber].Data.sRSSAttr.psImageBuffer = &sImageBuffer;
Draw2DBarcodeCnt(&sCntLinkTbl[CntNumber]);
break;
}
CntNumber += 1;
}
CounterStep();
}
VOID ClearCounter(VOID)
{
INT i;
// clear counter link table
for (i = 0; i < COUNTER_TABLE_MAX; i++)
sCntLinkTbl[i].CountType = NO_COUNT;
}
/
INT SearchFreeCntTbl(VOID)
{
INT i;
/* */
// search counter link table 搜索计数器链接表
for (i = 0; i < COUNTER_TABLE_MAX; i++)
{
if (sCntLinkTbl[i].CountType == NO_COUNT)
return i;
}
return COUNTER_TABLE_MAX;
}
//
/*这是一个名为PrintImageLabel的函数，它用于打印标签图片。
1 该函数接受两个参数：Count和Copy，均为LONG类型。其中，Count表示需要打印的标签数量，Copy表示需要打印的每个标签的份数。
2 首先定义了几个变量，包括_PrintCfg类型的TempCfg、_ImgBuf类型的TempImg、ULONG类型的BatchNo、LONG类型的DspTotal和DspBase，以及TotalCnt。
3 判断是否需要执行切刀分批打印操作。如果没有可用的计数器，则将Copy乘以Count，并将Count设置为1。然后，分别赋值给DspTotal和TotalCnt。
4 在循环中，首先根据当前的打印配置信息，决定是否需要启用切刀分批打印模式或者显示打印信息。如果存在可用的计数器，则调用RunCounter函数执行计数操作。
接下来，计算DspBase的值，并调用PrintBatch函数打印标签。如果打印成功，则更新标签里程数，并将sImageBuffer的内容存储到TempImg中。
最后，继续循环打印标签，直到打印的数量达到Count为止。如果打印失败，则退出循环。 */
// // pc下发打印进来执行1次
VOID PrintImageLabel(LONG Count, LONG Copy) //<--FN_PRINT(VOID)
{
_PrintCfg TempCfg;
_ImgBuf TempImg;
ULONG BatchNo = 0;
LONG DspTotal, DspBase;
LONG TotalCnt;
//sysprintf("C%d\n", Count); // ch_20220323
// cutter batch
TempCfg = *pPrintCfg;
// if don't have counter
if (SearchFreeCntTbl() == 0) //3 判断是否需要执行切刀分批打印操作
{
Copy *= Count;
Count = 1;
}
DspTotal = Count * Copy;
TotalCnt = Count;
while (Count) //Count表示需要打印的标签数量
{
// cutter batch //切刀分批
if (pPrintCfg->PrintOutMode == CUTTER_MODE && pPrintCfg->CutterPieces == 0)
{
if (Count == 1) // last batch
{
TempCfg.PrintOutMode = CUTTER_MODE;
TempCfg.CutterPieces = Copy;
}
else
TempCfg.PrintOutMode = OFF_MODE;
}
if (pPrintCfg->PrintKey && pPrintCfg->PrintKeyCnt == 0)
{
if (Count == TotalCnt) // first batch
{
TempCfg.PrintKey = TRUE;
TempCfg.PrintKeyCnt = Copy;
}
else
TempCfg.PrintKey = FALSE;
}
if (SearchFreeCntTbl() != 0) //如果存在可用的计数器，则调用RunCounter函数执行计数操作
RunCounter();
//sysprintf("PB_6\n");
DspBase = Copy * (Count - 1);
//打印标签。如果打印成功，则更新标签里程数，并将sImageBuffer的内容存储到TempImg中
BatchNo = PrintBatch(BatchNo, Copy, &TempCfg, &sImageBuffer, TRUE, 0, DspTotal, DspBase, _NULL);
if (BatchNo == 0)
break;
Count--;
pPrintRec->LabelMilage += Copy; //更新标签里程数
TempImg = sImageBuffer;
while (!AllocImageBuffer(&sImageBuffer))
NutSleep(10);
//sysprintf("ByteW = %d\tByteH = %d\n", sImageBuffer.iByteWidth, sImageBuffer.iHeight); // ch_20220308
memcpy(sImageBuffer.pBuffer, TempImg.pBuffer, sImageBuffer.iByteWidth * sImageBuffer.iHeight);
}
}
///
// ch_20220416
VOID PrintImageLabel4Special(LONG Count, LONG Copy)
{
_PrintCfg TempCfg;
_ImgBuf TempImg;
ULONG BatchNo = 0;
LONG DspTotal, DspBase;
LONG TotalCnt;
_WorkJob *WorkJob; // ch_20220416
//sysprintf("C%d\n", Count); // ch_20220323
//sysprintf("PIL_3\n");
// cutter batch
TempCfg = *pPrintCfg;
// if don't have counter
if (SearchFreeCntTbl() == 0)
{
Copy *= Count;
Count = 1;
}
DspTotal = Count * Copy;
TotalCnt = Count;
while (Count)
{
// cutter batch
if (pPrintCfg->PrintOutMode == CUTTER_MODE && pPrintCfg->CutterPieces == 0)
{
if (Count == 1) // last batch
{
TempCfg.PrintOutMode = CUTTER_MODE;
TempCfg.CutterPieces = Copy;
}
else
TempCfg.PrintOutMode = OFF_MODE;
}
if (pPrintCfg->PrintKey && pPrintCfg->PrintKeyCnt == 0)
{
if (Count == TotalCnt) // first batch
{
TempCfg.PrintKey = TRUE;
TempCfg.PrintKeyCnt = Copy;
}
else
TempCfg.PrintKey = FALSE;
}
if (SearchFreeCntTbl() != 0)
RunCounter();
// sysprintf("PB_5\n");
DspBase = Copy * (Count - 1);
BatchNo = PrintBatch(BatchNo, Copy, &TempCfg, NULL/*&sImageBuffer*/, TRUE, 0, DspTotal, DspBase, _NULL);
if (BatchNo == 0)
break;
Count--;
pPrintRec->LabelMilage += Copy;
TempImg = sImageBuffer;
while (!AllocImageBuffer(&sImageBuffer))
NutSleep(10);
//sysprintf("ByteW = %d\tByteH = %d\n", sImageBuffer.iByteWidth, sImageBuffer.iHeight); // ch_20220308
memcpy(sImageBuffer.pBuffer, TempImg.pBuffer, sImageBuffer.iByteWidth * sImageBuffer.iHeight);
}
}
#endif
TsplCnt.h //
#ifndef TSPLCNT_H
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define TSPLCNT_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 *
* *
******************************************************************************/
#ifdef __cplusplus
extern "C" { /* Assume C declarations for C++ */
#endif /* __cplusplus */
/******************************************************************************
* *
* G L O B A L D E F I N E S *
* *
******************************************************************************/
#define COUNTER_TABLE_MAX 100
/******************************************************************************
* *
* S T R U C T U R E D E F I N I T I O N S *
* *
******************************************************************************/
typedef enum
{
NO_COUNT,
TEXT_COUNT,
BARCODE_COUNT,
AZTEC_COUNT,
DMATRIX_COUNT,
MAXI_COUNT,
PDF_COUNT,
QRCODE_COUNT,
MPDF_COUNT,
RSS_COUNT,
RFID_COUNT,
}_eCounterType;
typedef struct
{
_eCounterType CountType;
_EraseBox sEraseBox;
_BarcodeTable *psBarcodeTab;
BYTE FontName[FONT_NAME_MAX];
BYTE ExpData[EXPRESS_LEN];
SHORT Justification;
union
{
_TextAttr sTextAttr;
_BarCodeAttr sBarcodeAttr;
_AztecAttr sAztecAttr;
_DMatrixAttr sDMatrixAttr;
_MaxiAttr sMaxiAttr;
_PDFAttr sPDFAttr;
_QRCodeAttr sQRCodeAttr;
_MPDFAttr sMPdfAttr;
_RSSAttr sRSSAttr;
}Data;
}_CounterLinkTable;
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
#ifdef TSPLCNT_C
#define EXTERN
#else
#define EXTERN extern
#endif
//Counter Table
EXTERN _CounterLinkTable sCntLinkTbl[COUNTER_TABLE_MAX];
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
/******************************************************************************
* *
* F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/
VOID ClearCounter(VOID);
INT SearchFreeCntTbl(VOID);
VOID PrintImageLabel(LONG, LONG);
VOID PrintImageLabel4Special(LONG Count, LONG Copy); // ch_20220416
#undef EXTERN
#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */
#endif
TsplFunc.c //
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define TSPLFUNC_C
/******************************************************************************
* *
* C O M P I L E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#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 "XLCD.h"
#include "XLED.h"
#include "XKey.h"
#include "XBuzzer.h"
#include "XPrtEng.h"
#include "XFlash.h"
#include "XRTC.h"
#include "XTimer.h"
#include "XFuseFlash.h"
#include "XText.h"
#include "XDisplay.h"
#include "XCodePage.h"
#include "XProfile.h"
#include "XFunction.h"
#include "XAppVer.h"
#include "..\Parser.h"
#include "..\ParserUtil.h"
#include "Expr.h"
#include "Error.h"
#include "VarMgr.h"
#include "TsplCnt.h"
#include "TsplUtil.h"
#include "TsplFunc.h"
/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/
#if defined(TSPL)
/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
// <--TscSyntaxParsing(VOID)
_CmdEntry TsplEntry[] =
{
// image command
{"CLS", FN_CLS},
{"BAR", FN_BAR},
{"CIRCLE", FN_CIRCLE},
{"DIAGONAL", FN_DIAGONAL},
{"ERASE", FN_ERASE},
{"REVERSE", FN_REVERSE},
{"BOX", FN_BOX},
{"BARCODE", FN_BARCODE},
{"TEXT", FN_TEXT},
{"BITMAP", FN_BITMAP},
{"PUTBMP", FN_PUTBMP},
{"PUTPCX", FN_PUTPCX},
{"AZTEC", FN_AZTEC},
{"DMATRIX", FN_DMATRIX},
{"MAXICODE", FN_MAXI},
{"PDF417", FN_PDF},
{"MPDF417", FN_MPDF},
{"QRCODE", FN_QRCODE},
{"RSS", FN_RSS},
// normal command
{"SIZE", FN_SIZE},
{"GAP", FN_GAP},
{"BLINE", FN_BLINE},
{"SHIFT", FN_SHIFT},
{"SPEED", FN_SPEED},
{"FEED", FN_FEED},
{"BACKUP", FN_BACKFEED},
{"BACKFEED", FN_BACKFEED},
{"FORMFEED", FN_FORMFEED},
{"HOME", FN_HOME},
{"DENSITY", FN_DENSITY}, //~{4rS!C\6HIhVC~}
{"DIRECTION", FN_DIRECTION},
{"OFFSET", FN_OFFSET},
{"REFERENCE", FN_REFERENCE},
{"PRINT", FN_PRINT}, //打印
{"CUT", FN_CUT},
{"REM", FN_REM},
{"SET", FN_SET},
{"REDRAW", FN_REDRAW},
{"DOWNLOAD", FN_DOWNLOAD},
{"EOP", FN_EOP},
{"LOAD", FN_LOAD},
{"RUN", FN_RUN},
{"KILL", FN_KILL},
{"COUNTRY", FN_COUNTRY},
{"CODEPAGE", FN_CODEPAGE},
{"INPUT", FN_INPUT},
{"OUT", FN_OUT},
{"OUTR", FN_OUTR},
{"MOVE", FN_MOVE},
{"COPY", FN_COPY},
{"BEEP", FN_BEEP},
{"SOUND", FN_SOUND},
{"DISPLAY", FN_DISPLAY},
{"DELAY", FN_DELAY},
{"EOJ", FN_EOJ},
{"PREINPUT", FN_INPUTPREFIX},
{"POSTINPUT", FN_INPUTSUFFIX},
// proprietary command
{"ST", FN_ST},
{"INPUTPREFIX", FN_INPUTPREFIX},
{"INPUTSUFFIX", FN_INPUTSUFFIX},
// file command
{"OPEN", FN_OPEN},
{"CLOSE", FN_CLOSE},
{"SEEK", FN_SEEK},
{"READ", FN_READ},
{"WRITE", FN_WRITE},
#if defined(DURALABEL)
{"RFSET", FN_RFSET},
{"RFID", FN_RFID},
#endif
#if defined(UART2_BT)
{"BT", FN_BT},
#endif
{(CHAR *)_NULL, _NULL}
};
/******************************************************************************
* *
* L O C A L U N I T I A L I Z E D D A T A D E F I N I T I O N S *
* *
******************************************************************************/
/******************************************************************************
*
* Function:
* FN_REM
*
* Description:
*
*
* Input:
* None
*
* Output:
* None.
*
******************************************************************************/
INT FN_REM(VOID)
{
#ifdef DEBUG_PRNT
sysprintf("FN_REM()...\n"); // ch_20220409
#endif
RemoveLine();
return _SUCCESS;
}
/******************************************************************************
*
* Function:
* FN_SIZE
*
* Description:
*
*
* Input:
* None
*
* Output:
* None.
*
******************************************************************************/
INT FN_SIZE(VOID)
{
DOUBLE dData;
INT iWidth;
FLOAT fHeight;
WORD LabelSize;
#ifdef DEBUG_PRNT
sysprintf("FN_SIZE()...\n"); // ch_20220409
#endif
if (!GetExpSize(COMMA_END, &dData))
return _ERROR;
iWidth = dData;
if (!GetExpSize(LINE_END, &dData))
return _ERROR;
fHeight = dData;
iWidth = abs(iWidth);
//iWidth %= TPH_WIDTH_DOT;
// if (iWidth == 0 || iWidth > TPH_WIDTH_DOT) // ch_20220519
if (iWidth == 0) // ch_20220519
iWidth = TPH_WIDTH_DOT;
// if (iWidth > TPH_WIDTH_DOT || iWidth <= 0)
// return _ERROR;
if ((WORD)fHeight > MAX_IMAGE_LENGTH || fHeight <= 0)
return _ERROR;
if (pPrintCfg->PaperWidth == iWidth && pPrintCfg->fPaperSize == fHeight)
return _SUCCESS;
pPrintCfg->PaperWidth = iWidth;
pPrintCfg->fPaperSize = fHeight;
LabelSize = (WORD)CalculateLabelSize(pPrintCfg);
ReallocImageBuffer(&sImageBuffer, LabelSize);
InitialCalibration();
return _SUCCESS;
}
INT FN_GAP(VOID)
{
DOUBLE dData;
FLOAT fGapOffset;
FLOAT fGapSize;
WORD LabelSize;
#ifdef DEBUG_PRNT
sysprintf("FN_GAP()...\n"); // ch_20220409
#endif
if (!GetExpSize(COMMA_END, &dData))
return _ERROR;
fGapSize = dData;
if (!GetExpSize(LINE_END, &dData))
return _ERROR;
fGapOffset = dData;
if ((WORD)fGapSize > (WORD)(TPH_DPI * 5))
return _ERROR;
if ((WORD)fGapSize == 0)
{
#if defined(DLP200) || defined(DLP300)
if (pPrintCfg->SensorMode != CONTINUE_MODE_R)
DetectContinuousIntenBm(pPrintCfg);
pPrintCfg->SensorMode = CONTINUE_MODE_R;
#else
if (pPrintCfg->SensorMode != CONTINUE_MODE_T)
DetectContinuousInten(pPrintCfg);
pPrintCfg->SensorMode = CONTINUE_MODE_T;
#endif
}
else
{
// pPrintCfg->SensorMode = GAP_MODE; // ch_20220409
pPrintCfg->fGapSize = fGapSize;
pPrintCfg->fGapOffset = fGapOffset;
}
LabelSize = (WORD)CalculateLabelSize(pPrintCfg);
ReallocImageBuffer(&sImageBuffer, LabelSize);
InitialCalibration();
#ifdef DEBUG_PRNT
sysprintf("FN_GAP()...\n"); // ch_20220409
#endif
return _SUCCESS;
}
INT FN_BLINE(VOID)
{
DOUBLE dData;
FLOAT fBlineOffset;
FLOAT fBlineSize;
WORD LabelSize;
#ifdef DEBUG_PRNT
sysprintf("FN_BLINE()...\n"); // ch_20220409
#endif
if(ProfileLimit("NO BLINE MODE")==1)
return _ERROR;
if (!GetExpSize(COMMA_END, &dData))
return _ERROR;
fBlineSize = dData;
if (!GetExpSize(LINE_END, &dData))
return _ERROR;
fBlineOffset = dData;
if ((WORD)fBlineSize > (WORD)(TPH_DPI * 5))
return _ERROR;
if ((WORD)fBlineSize == 0)
{
#if defined(ANALOG_MEDIA)
if (pPrintCfg->SensorMode != CONTINUE_MODE_R)
DetectContinuousIntenBm(pPrintCfg);
pPrintCfg->SensorMode = CONTINUE_MODE_R;
#else
if (pPrintCfg->SensorMode != CONTINUE_MODE_T)
DetectContinuousInten(pPrintCfg);
pPrintCfg->SensorMode = CONTINUE_MODE_T;
#endif
}
else
{
// pPrintCfg->SensorMode = BLINE_MODE; // ch_20220409
pPrintCfg->fBlineSize = fBlineSize;
pPrintCfg->fBlineOffset = fBlineOffset;
}
LabelSize = (WORD)CalculateLabelSize(pPrintCfg);
ReallocImageBuffer(&sImageBuffer, LabelSize);
InitialCalibration();
return _SUCCESS;
}
/******************************************************************************
*
* TSPL Commands
* SHIFT
*
* Description:
*
* Syntax:
* SHIFT [x,]y
*
* Parameters:
* x = Horizontal coordinate, with "dot" as the unit.
* y = Vertical coordinate, with "dot" as the unit.
*
******************************************************************************/
INT FN_SHIFT(VOID)
{
SHORT Arg1, Arg2;
DOUBLE dData;
CHAR Data;
#ifdef DEBUG_PRNT
sysprintf("FN_SHIFT()...\n"); // ch_20220409
#endif
sysprintf("FN_SHIFT()...\n");
if (!GetExpNumber(BACK_WITHOUT_SPACE , &dData))
return _ERROR;
Arg1 = (SHORT)dData;
Data = NextByte();
if (CheckChar(Data, ",;"))
{
if (!GetExpNumber(LINE_END , &dData))
return _ERROR;
Arg2 = (SHORT)dData;
pPrintCfg->ShiftDisX = Arg1;
pPrintCfg->ShiftDisY = Arg2;
return _SUCCESS;
}
else if (!CheckTokenEnd(LINE_END, Data))
return _ERROR;
pPrintCfg->ShiftDisY = Arg1;
return _SUCCESS;
}
INT FN_SPEED(VOID)
{
DOUBLE dData;
CHAR Data;
// BYTE Speed = 0; // ch_20220526
#ifdef DEBUG_PRNT
sysprintf("FN_SPEED()...\n"); // ch_20220315
#endif
RemoveSpace();
Data = NextByte();
BackByte(Data);
#if defined(B443) || defined(B443_300)
if (!isdigit(Data) && (Data == 'H' || Data == 'L'))
{
CHAR Token[STRING_LEN];
if (!GetExpToken(LINE_END, Token, sizeof(Token)))
return _ERROR;
if (strcmp(Token, "LOW") == 0 || strcmp(Token, "L") == 0)
pPrintCfg->Speed = 1;
else if (strcmp(Token, "HIGH") == 0 || strcmp(Token, "H") == 0)
pPrintCfg->Speed = 2;
else
return _ERROR;
}
else
#endif
{
if (!GetExpNumber(LINE_END, &dData))
return _ERROR;
// ch_20220601 : restore
// ch_20220526 : add
pPrintCfg->Speed = (BYTE)SpeedRange((FLOAT)dData);
// Speed = (BYTE)SpeedRange((FLOAT)dData);
// if (Speed != pPrintCfg->Speed) {
// pPrintCfg->Speed = Speed;
//
// CalculateHeatTable();
// }
//sysprintf("S_%d\n", pPrintCfg->Speed); // ch_20220525
}
#ifdef DEBUG_PRNT
sysprintf("Leave FN_SPEED() with spd%d.\n", pPrintCfg->Speed); // ch_20220315
#endif
return _SUCCESS;
}
INT FN_FEED(VOID)
{
DOUBLE data;
#ifdef DEBUG_PRNT
sysprintf("FN_FEED()...\n"); // ch_20220409
#endif
if (!GetExpNumber(LINE_END, &data))
return _ERROR;
if (data < 0)
return _ERROR;
ResetHeadPosition();
MotorMove((WORD)data, pPrintCfg, MOTOR_FORWARD, _NULL);
return _SUCCESS;
}
INT FN_BACKFEED(VOID)
{
DOUBLE data;
#ifdef DEBUG_PRNT
sysprintf("FN_BACKFEED()...\n"); // ch_20220409
#endif
if (!GetExpNumber(LINE_END, &data))
return _ERROR;
if (data < 0)
return _ERROR;
ResetHeadPosition();
MotorMove((WORD)data, pPrintCfg, MOTOR_BACKWARD, _NULL);
return _SUCCESS;
}
INT FN_FORMFEED(VOID)
{
#ifdef DEBUG_PRNT
sysprintf("FN_FORMFEED()...\n"); // ch_20220409
#endif
FeedBatch(1, pPrintCfg, TRUE, _NULL);
return _SUCCESS;
}
INT FN_HOME(VOID)
{
#ifdef DEBUG_PRNT
sysprintf("FN_HOME()...\n"); // ch_20220409
#endif
#if defined(TSPL_VER_2)
FeedBatch(1, pPrintCfg, TRUE, _NULL);
#else
PaperHome(pPrintCfg);
#endif
return _SUCCESS;
}
INT FN_DENSITY(VOID)
{
DOUBLE dData;
FLOAT Density;
#ifdef DEBUG_PRNT
sysprintf("FN_DENSITY()...\n"); // ch_20220409
#endif
if (!GetExpNumber(LINE_END, &dData))
return _ERROR;
Density = (FLOAT)dData;
if (Density < DensityMin || Density > DensityMax)
return _ERROR;
pPrintCfg->fDensity = Density;
return _SUCCESS;
}
INT FN_DIRECTION(VOID)
{
DOUBLE dData;
BYTE bTemp;
INT Direction;
INT Mirror;
#ifdef DEBUG_PRNT
sysprintf("FN_DIRECTION()...\n"); // ch_20220409
#endif
if (!GetExpNumber(BACK_WITHOUT_SPACE, &dData))
return _ERROR;
Direction = (INT)dData;
bTemp = NextByte();
if (CheckChar(bTemp, ",;"))
{
if (!GetExpNumber(LINE_END, &dData))
return _ERROR;
Mirror = (INT)dData;
}
else
{
if (!CheckTokenEnd(LINE_END, bTemp))
return _ERROR;
Mirror = pPrintCfg->Mirror;
}
if (Direction < 0 || Direction > 1)
return _ERROR;
if (Mirror < 0 || Mirror > 1)
return _ERROR;
pPrintCfg->Direction = Direction;
pPrintCfg->Mirror = Mirror;
return _SUCCESS;
}
INT FN_OFFSET(VOID)
{
DOUBLE dData;
SHORT Offset;
#ifdef DEBUG_PRNT
sysprintf("FN_OFFSET()...\n"); // ch_20220409
#endif
if (!GetExpSize(LINE_END, &dData))
return _ERROR;
Offset = (SHORT)dData;
if (abs(Offset) > (INT)TPH_DPI)
return _ERROR;
pPrintCfg->OffsetDis = Offset;
return _SUCCESS;
}
INT FN_REFERENCE(VOID)
{
DOUBLE dData;
INT RefX, RefY;
#ifdef DEBUG_PRNT
sysprintf("FN_REFERENCE()...\n"); // ch_20220409
#endif
if (!GetExpNumber(COMMA_END, &dData))
return _ERROR;
RefX = dData;
if (!GetExpNumber(LINE_END, &dData))
return _ERROR;
RefY = dData;
if (RefX < 0 || RefY < 0)
return _ERROR;
pPrintCfg->ReferenceX = RefX;
pPrintCfg->ReferenceY = RefY;
return _SUCCESS;
}
/* 1 函数首先声明了一些局部变量，包括Sets、Copies用于存储设置和拷贝数量，dData用于存储从输入中获取的数值，Data用于存储读取的字符。
2 通过GetExpNumber函数获取一个数值并赋值给dData，将其转换为整型并赋值给Sets。
3 读取下一个字符并将其赋值给Data。如果Data是逗号或分号，则说明有指定拷贝数量，通过GetExpNumber函数获取一个数值并赋值给dData，将其转换为整型并赋值给Copies。
否则，如果Data是行结束符，则将Copies设置为1。
4 在某些条件下，将Sets和Copies取绝对值。
5 如果DriverCopy大于0，则将Copies设置为DriverCopy的值，并将DriverCopy重置为0。
6 将Sets和Copies分别赋值给全局变量PrintSets和PrintCopies。
7 如果执行过一次计算（通过IsOnceCalDone函数判断），则重置一次计算完成标志并调用PrintImageLabel4Special函数打印特殊图像标签。
8 最后，调用PrintImageLabel函数执行打印任务，传入Sets和Copies作为参数。
函数最后返回_SUCCESS表示成功执行打印任务。
*/
/// //pc下发打印时开始时进来执行1次
INT FN_PRINT(VOID) //<--TsplEntry[]
{
LONG Sets, Copies;
DOUBLE dData;
CHAR Data;
#ifdef DEBUG_PRNT
sysprintf("FN_PRINT()...\n"); // ch_20220323
#endif
if (!GetExpNumber(BACK_WITHOUT_SPACE, &dData))
return _ERROR;
Sets = dData;
Data = NextByte();
if (CheckChar(Data, ",;")) //如果Data是逗号或分号，则说明有指定拷贝数量，
{
if (!GetExpNumber(LINE_END, &dData))
return _ERROR;
Copies = dData;
}
else
{
if (!CheckTokenEnd(LINE_END, Data)) //否则，如果Data是行结束符，则将Copies设置为1。
return _ERROR;
Copies = 1;
}
#if defined(TSPL_VER_1)
Sets = abs(Sets);
Copies = abs(Copies);
#endif
if (Sets < 1 || Copies < 1)
return _ERROR;
if (DriverCopy > 0) //如果DriverCopy大于0，则将Copies设置为DriverCopy的值，并将DriverCopy重置为0。
{
Copies = DriverCopy;
DriverCopy = 0;
}
// for print function // 将Sets和Copies分别赋值给全局变量PrintSets和PrintCopies
PrintSets = Sets;
PrintCopies = Copies;
//
if (IsOnceCalDone()) {
RstOnceCaldoneFlg();
//sysprintf("PIL_6\n"); //pc打印不进来
PrintImageLabel4Special(1, 1);
}
//
//sysprintf("\nPQ%d,%d\n", PrintSets, PrintCopies); // ch_20220323
sysprintf("PIL_5\n");
PrintImageLabel(Sets, Copies); //调用PrintImageLabel函数执行打印任务，传入Sets:打印标签数量和Copies：每个标签打印的份数作为参数
#ifdef DEBUG_PRNT
sysprintf("FN_PRINT().\n"); // ch_20220323
#endif
return _SUCCESS;
}
INT FN_CUT(VOID)
{
CutPaper();
return _SUCCESS;
}
INT FN_SET(VOID)
{
CHAR Token[STRING_LEN];
INT CmdID;
#ifdef DEBUG_PRNT
sysprintf("FN_SET()...\n"); // ch_20211211
#endif
RemoveSpace();
if (!GetExpToken(SPACE_END, Token, sizeof(Token)))
return _ERROR;
for (CmdID = 0; SetEntry[CmdID].keyword != _NULL; CmdID++)
{
if (strcmp(SetEntry[CmdID].keyword, Token) == 0)
break;
}
if (SetEntry[CmdID].func == _NULL)
return _ERROR;
#ifdef DEBUG_PRNT
sysprintf("SetEntry[%d].keyword = %s\n", CmdID, SetEntry[CmdID].keyword); // ch_20211211
#endif
return (*SetEntry[CmdID].func)();
}
INT FN_REDRAW(VOID)
{
#if defined(DEFAULT_MCARD_MODEL)
DOUBLE dData;
USHORT FlashNo;
ULONG FileLength;
_FlashInfo *info;
UCHAR FlashArea[2];
ULONG addr;
ULONG i;
#ifdef DEBUG_PRNT
sysprintf("FN_REDRAW()...\n"); // ch_20211211
#endif
// Get Flash NO.
if (!GetExpNumber(COMMA_END, &dData))
return _ERROR;
FlashNo = dData;
// Get File Length
if (!GetExpNumber(COMMA_END, &dData))
return _ERROR;
FileLength = dData;
if (FlashNo < 1 || FlashNo > 4)
return _ERROR;
if (FileLength < 1 || FileLength > 0x100000) // 1MB
return _ERROR;
addr = MEMORY_CARD_ADDR + (FlashNo - 1) * 0x100000;
if ((info = GetFlashInfo(addr)) == _NULL)
return _ERROR;
// Erase memory card
for (i = 0; i < info->Sector; i++)
{
SectorErase(info->Start[i], TRUE);
#if defined(MONO_LED)
if (i & 0x1)
ShowLED(HID_LED_IDLE, HID_LED_ON, HID_LED_IDLE);
else
ShowLED(HID_LED_IDLE, HID_LED_OFF, HID_LED_IDLE);
#elif defined(POLY_LED)
if (i & 0x1)
ShowLED(HID_LED_GREEN);
else
ShowLED(HID_LED_DARK);
#endif
}
// Write data to card
for (i = 0; i < FileLength; i++)
{
FlashArea[i & 0x1] = NextByte();
if (i & 0x1)
WriteFlash(addr + i - 1, *(WORD *)FlashArea, TRUE);
#if defined(MONO_LED)
if (i & 0x2000)
ShowLED(HID_LED_IDLE, HID_LED_OFF, HID_LED_IDLE);
else
ShowLED(HID_LED_IDLE, HID_LED_ON, HID_LED_IDLE);
#elif defined(POLY_LED)
if (i & 0x2000)
ShowLED(HID_LED_DARK);
else
ShowLED(HID_LED_GREEN);
#endif
}
if (i & 0x1)
{
FlashArea[i&0x1] = 0xFF;
WriteFlash(addr + i - 1, *(WORD *)FlashArea, TRUE);
}
#if defined(MONO_LED)
ShowLED(HID_LED_IDLE, HID_LED_ON, HID_LED_IDLE);
#elif defined(POLY_LED)
ShowLED(HID_LED_GREEN);
#endif
#endif
return _SUCCESS;
}
INT FN_DOWNLOAD(VOID)
{
CHAR FileName[FILENAME_LENGTH];
_eFileDevice Device;
_FileHandle *Handle;
DOUBLE Number;
BOOL immed;
SHORT len;
BYTE data;
CHAR buf[16];
INT num, key;
INT state;
INT i;
#ifdef DEBUG_PRNT
sysprintf("FN_DOWNLOAD()...\n"); // ch_20211211
#endif
if (!GetFileDevice(&Device))
return _ERROR;
if (!GetExpString(BACK_WITHOUT_SPACE, FileName, sizeof(FileName)))
return _ERROR;
if (strchr(FileName, '*'))
return _ERROR;
num = key = 0;
data = NextByte();
if (CheckChar(data, ",;"))
{
if (!GetExpNumber(COMMA_END, &Number))
return _ERROR;
num = (INT)Number;
}
else if (!CheckTokenEnd(LINE_END, data))
return _ERROR;
// Download Basic File Protection (.BAX)
if (strcmp(strchr(FileName, '.'), ".BAX") == 0)
{
strcpy(strchr(FileName, '.'), ".BAS");
key = BasFileKey;
}
#if defined(LCD_MODEL)
SetDisplayStatus(DIS_DOWNLOADING);
#endif
#if defined(MONO_LED)
StartPeriodFunc(FlashLED2);
#elif defined(POLY_LED)
StartPeriodFunc(FlashGreenLED);
#endif
immed = CtrlImmedCmd(FALSE);
Remove(Device, FileName);
Handle = Fopen(Device, FileName, "w");
state = _NULL;
if (num)
{
for (i = 0; i < num; i++)
{
data = NextByte();
if (state != END_OF_FILE)
state = Fputc((INT)data ^ key, Handle);
}
}
else
{
while (1)
{
if (CompareKeyword(NextByte(), "EOP", buf, &len))
{
strcpy(buf, "EOP");
len = 3;
while (CheckChar((buf[len] = NextByte()), "\t "))
{
if (len < sizeof(buf) - 1)
len += 1;
}
if (CheckChar(buf[len], "\r\n"))
break;
len += 1;
}
for (i = 0; i < len; i++)
{
if (state != END_OF_FILE)
state = Fputc((INT)buf[i] ^ key, Handle);
}
}
}
Fclose(Handle);
CtrlImmedCmd(immed);
if (state == END_OF_FILE)
{
Remove(Device, FileName);
MemoryFailed();
}
#if defined(MONO_LED)
CancelPeriodFunc(FlashLED2);
ShowLED(HID_LED_IDLE, HID_LED_ON, HID_LED_IDLE);
#elif defined(POLY_LED)
CancelPeriodFunc(FlashGreenLED);
ShowLED(HID_LED_GREEN);
#endif
#if defined(LCD_MODEL)
ClrDisplayStatus(DIS_DOWNLOADING);
#endif
return _SUCCESS;
}
INT FN_EOP(VOID)
{
return _SUCCESS;
}
INT FN_LOAD(VOID)
{
_eFileDevice Device;
_FileHandle *Handle;
CHAR FileName[FILENAME_LENGTH];
INT i;
#ifdef DEBUG_PRNT
sysprintf("FN_LOAD()...\n"); // ch_20211211
#endif
// Load file from DRAM & FLASH on borad or card
if (!GetFileDevice(&Device))
return _ERROR;
if (!GetExpString(LINE_END, FileName, sizeof(FileName)))
return _ERROR;
if ((Handle = Fopen(Device, FileName, "r")) == _NULL)
return _ERROR;
while ((i = Fgetc(Handle)) != END_OF_FILE)
SendChar((BYTE)i);
Fclose(Handle);
return _SUCCESS;
}
INT FN_RUN(VOID)
{
CHAR FileName[FILENAME_LENGTH];
CHAR Data;
#ifdef DEBUG_PRNT
sysprintf("FN_RUN()...\n"); // ch_20211211
#endif
if (sBasicData.UseHandle != _NULL)
return _ERROR;
RemoveSpace();
Data = NextByte();
BackByte(Data);
if (Data != '"')
{
if (!GetExpToken(LINE_END, FileName, sizeof(FileName)))
return _ERROR;
}
else if (!GetExpString(LINE_END, FileName, sizeof(FileName)))
return _ERROR;
// Run Basic File
if (strcmp(strchr(FileName, '.'), ".BAS") != 0)
strcat(FileName, ".BAS");
RemoveLF(); // for INPUT command
if ((sBasicData.UseHandle = RunFile(DRAM_DEVICE, FileName, BasFileKey, BasClearHandle)) == _NULL)
if ((sBasicData.UseHandle = RunFile(FLASH_DEVICE, FileName, BasFileKey, BasClearHandle)) == _NULL)
if ((sBasicData.UseHandle = RunFile(CARD_DEVICE, FileName, BasFileKey, BasClearHandle)) == _NULL)
return _ERROR;
BasInitialBASIC();
return _SUCCESS;
}
INT FN_KILL(VOID)
{
_eFileDevice Device;
CHAR FileName[FILENAME_LENGTH];
#ifdef DEBUG_PRNT
sysprintf("FN_KILL()...\n"); // ch_20211211
#endif
// Delete file from DRAM & FLASH on borad or crad
if (!GetFileDevice(&Device))
return _ERROR;
if (!GetExpString(LINE_END, FileName, sizeof(FileName)))
return _ERROR;
ErasingFile(Device, FileName);
return _SUCCESS;
}
INT FN_COUNTRY(VOID)
{
CHAR Token[STRING_LEN];
#ifdef DEBUG_PRNT
sysprintf("FN_COUNTRY()...\n"); // ch_20211211
#endif
if (!GetExpToken(LINE_END, Token, sizeof(Token)))
return _ERROR;
if (!SetCountry(Token))
return _ERROR;
return _SUCCESS;
}
INT FN_CODEPAGE(VOID)
{
CHAR Token[STRING_LEN];
#ifdef DEBUG_PRNT
sysprintf("FN_CODEPAGE()...\n"); // ch_20211211
#endif
if (!GetExpToken(LINE_END, Token, sizeof(Token)))
return _ERROR;
if (!SetCodePage(Token))
return _ERROR;
return _SUCCESS;
}
INT FN_INPUT(VOID)
{
CHAR Data;
DOUBLE Number;
WORD LimitLen = 0;
BOOL PromptFlag = FALSE;
CHAR Prompt[PROMPT_LEN];
CHAR VarName[TOKEN_LEN];
CHAR Filter[16];
CHAR *HugeBuf;
BYTE *pHuge, *pExp;
INT VarType;
INT FilterSet;
INT State;
INT i;
#ifdef DEBUG_PRNT
sysprintf("FN_INPUT()...\n"); // ch_20211211
#endif
RemoveSpace();
Data = NextByte();
BackByte(Data);
// input prompt
if (Data == '\"')
{
if (!GetExpString(COMMA_END, Prompt, sizeof(Prompt)))
return _ERROR;
PromptFlag = TRUE;
}
RemoveSpace();
Data = NextByte();
BackByte(Data);
// get string limit length
if (IsNumber(Data))
{
if (!GetExpNumber(COMMA_END, &Number))
return _ERROR;
LimitLen = (WORD)Number;
}
// get variable
if (!GetExpToken(LINE_END, VarName, sizeof(VarName)))
return _ERROR;
if ((HugeBuf = malloc(HUGE_LEN)) == 0)
return _ERROR;
memset(HugeBuf, 0, HUGE_LEN);
pExp = (BYTE *)VarName;
expMain(&pExp);
if (wErrorword == NO_ERROR)
{
VarType = bExpKind;
strcpy(HugeBuf, (CHAR *)szRetStr);
}
else if (wErrorword == VARIABLE_NOT_DEFINED)
{
VarType = CheckVariableType((BYTE *)VarName);
if (VarType != STRING_TYPE)
strcpy(HugeBuf, "0");
}
else
{
free(HugeBuf);
return _ERROR;
}
if (PromptFlag)
{
SendString("~#"); // KP-200 Command LCD first line
SendString(Prompt); // Prompt string
SendString("~&"); // KP-200 Command LCD second line
if (LimitLen != 0) // Data length limit
{
SendChar(0x1B);
SendChar((BYTE)LimitLen);
}
if (VarType != STRING_TYPE) // Number type return 0x01
SendChar(0x01);
SendString(HugeBuf);
SendString("\r\n");
}
#if defined(PS2_MODEL) || defined(USB_HOST_MODEL)
EntryInputKB(Prompt, HugeBuf, (VarType == STRING_TYPE) ? FALSE : TRUE, (INT)LimitLen);
#endif
pHuge = (BYTE *)HugeBuf;
if (InputFilter)
{
INT idx[4] = { 0,0,0,0 };
INT set;
// Multiple Input Filter
FilterSet = (-1);
while (FilterSet == (-1))
{
Data = DirectNextByte();
for (set = 0; set < 4; set++)
{
if (pPrintCfg->InputSuffix[set][0] != '\0')
{
if (pPrintCfg->InputPrefix[set][idx[set]] == '\0')
FilterSet = set;
if (Data != (CHAR)pPrintCfg->InputPrefix[set][idx[set]++])
idx[set] = 0;
}
}
}
if (Data == '\0') // Replace NULL with space
Data = ' ';
*pHuge++ = Data;
}
else if (!CRLF_IsInputData)
{
// Ignore <CR> <LF>
do Data = DirectNextByte();
while (Data == (CHAR)CR_CHAR || Data == (CHAR)LF_CHAR);
*pHuge++ = Data;
}
i = 0;
while (1)
{
if (InputFilter)
{
if (pPrintCfg->InputSuffix[FilterSet][i] == '\0')
break;
Data = DirectNextByte();
if (Data == '\0') // Replace NULL with space
Data = ' ';
Filter[i] = Data;
if (Filter[i] == pPrintCfg->InputSuffix[FilterSet][i])
i++;
else
{
memcpy(pHuge, Filter, i + 1);
pHuge += i + 1;
i = 0;
}
}
else
{
Data = DirectNextByte();
if (Data == CR_CHAR)
SetDirectIgnoreLF(TRUE);
if (Data == CR_CHAR || Data == LF_CHAR)
break;
*pHuge++ = Data;
}
}
*pHuge = '\0';
#if defined(PS2_MODEL) || defined(USB_HOST_MODEL)
LeaveInputKB();
#endif
// set data
if (VarType == STRING_TYPE)
State = SetEquation(EQU_STRING, (BYTE *)VarName, (BYTE *)HugeBuf);
else
State = SetEquation(EQU_EXPRESSION, (BYTE *)VarName, (BYTE *)HugeBuf);
free(HugeBuf);
return (State ? _SUCCESS : _ERROR);
}
INT FN_OUT(VOID)
{
CHAR Token[STRING_LEN];
CHAR Data;
BYTE *pExp;
INT n;
#ifdef DEBUG_PRNT
sysprintf("FN_OUT()...\n"); // ch_20211211
#endif
memset(Token, 0, sizeof(Token));
while (1)
{
RemoveSpace();
Data = NextByte();
if (CheckTokenEnd(LINE_END, Data))
break;
if (!GetExpToken(BACK_WITH_SPACE, Token, sizeof(Token)))
return _ERROR;
pExp = (BYTE *)Token;
expMain(&pExp);
if (wErrorword != NO_ERROR)
return _ERROR;
RemoveSpace();
Data = NextByte();
if (CheckChar(Data, ",\r\n"))
strcat((CHAR *)szRetStr, "\r\n");
SendString((CHAR *)szRetStr);
if (CheckChar(Data, "\r\n"))
break;
}
return _SUCCESS;
}
INT FN_OUTR(VOID)
{
CHAR Token[STRING_LEN];
CHAR Data;
BYTE *pExp;
INT n;
#ifdef DEBUG_PRNT
sysprintf("FN_OUTR()...\n"); // ch_20211211
#endif
memset(Token, 0, sizeof(Token));
while (1)
{
RemoveSpace();
Data = NextByte();
if (CheckTokenEnd(LINE_END, Data))
break;
if (!GetExpToken(BACK_WITH_SPACE, Token, sizeof(Token)))
return _ERROR;
pExp = (BYTE *)Token;
expMain(&pExp);
if (wErrorword != NO_ERROR)
return _ERROR;
RemoveSpace();
Data = NextByte();
if (CheckChar(Data, ",\r\n"))
strcat((CHAR *)szRetStr, "\r\n");
CommWrite(UART_PORT, szRetStr, strlen((CHAR *)szRetStr), 3000);
if (CheckChar(Data, "\r\n"))
break;
}
return _SUCCESS;
}
INT FN_MOVE(VOID)
{
BOOL state;
#ifdef DEBUG_PRNT
sysprintf("FN_MOVE()...\n"); // ch_20211211
#endif
#if defined(LCD_MODEL)
SetDisplayStatus(DIS_DOWNLOADING);
#endif
#if defined(MONO_LED)
StartPeriodFunc(FlashLED2);
#elif defined(POLY_LED)
StartPeriodFunc(FlashGreenLED);
#endif
state = CopyFile(DRAM_DEVICE, "*.*", FLASH_DEVICE, "*.*");
if (!state)
MemoryFailed();
#if defined(MONO_LED)
CancelPeriodFunc(FlashLED2);
ShowLED(HID_LED_IDLE, HID_LED_ON, HID_LED_IDLE);
#elif defined(POLY_LED)
CancelPeriodFunc(FlashGreenLED);
ShowLED(HID_LED_GREEN);
#endif
#if defined(LCD_MODEL)
ClrDisplayStatus(DIS_DOWNLOADING);
#endif
return _SUCCESS;
}
/******************************************************************************
*
* TSPL Commands
* COPY
*
* Description:
* Copies an existing file to a new file.
*
* Syntax:
* COPY [existdev,]"existname",[newdev,]"newname"
*
* Parameters:
* existdev = device of an existing file.
* existname = name of an existing file.
* newdev = device of the new file.
* newname = name of the new file.
*
******************************************************************************/
INT FN_COPY(VOID)
{
CHAR existname[FILENAME_LENGTH], newname[FILENAME_LENGTH];
_eFileDevice existdev, newdev;
BOOL state;
#ifdef DEBUG_PRNT
sysprintf("FN_COPY()...\n"); // ch_20211211
#endif
if (!GetFileDevice(&existdev))
return _ERROR;
if (!GetExpString(COMMA_END, existname, sizeof(existname)))
return _ERROR;
if (!GetFileDevice(&newdev))
return _ERROR;
if (!GetExpString(LINE_END, newname, sizeof(newname)))
return _ERROR;
if (newdev == CARD_DEVICE && existdev != newdev)
return _ERROR;
#if defined(LCD_MODEL)
SetDisplayStatus(DIS_DOWNLOADING);
#endif
#if defined(MONO_LED)
StartPeriodFunc(FlashLED2);
#elif defined(POLY_LED)
StartPeriodFunc(FlashGreenLED);
#endif
state = CopyFile(existdev, existname, newdev, newname);
if (!state)
MemoryFailed();
#if defined(MONO_LED)
CancelPeriodFunc(FlashLED2);
ShowLED(HID_LED_IDLE, HID_LED_ON, HID_LED_IDLE);
#elif defined(POLY_LED)
CancelPeriodFunc(FlashGreenLED);
ShowLED(HID_LED_GREEN);
#endif
#if defined(LCD_MODEL)
ClrDisplayStatus(DIS_DOWNLOADING);
#endif
return _SUCCESS;
}
INT FN_BEEP(VOID)
{
#ifdef DEBUG_PRNT
sysprintf("FN_BEEP()...\n"); // ch_20211211
#endif
RemoveLine();
// KP200 function
UartChar(0x07);
return _SUCCESS;
}
INT FN_SOUND(VOID)
{
DOUBLE data;
INT freq, time;
#ifdef DEBUG_PRNT
sysprintf("FN_SOUND()...\n"); // ch_20211211
#endif
// get first argument
if (!GetExpNumber(COMMA_END, &data))
return _ERROR;
freq = (INT)data;
if (!GetExpNumber(LINE_END, &data))
return _ERROR;
time = (INT)data;
while (CheckBuzzerStatus()){}
sysprintf("FN_SOUND\r\n");
EnableBuzzer(freq, time);
return _SUCCESS;
}
INT FN_DISPLAY(VOID)
{
CHAR Token[STRING_LEN];
#ifdef DEBUG_PRNT
sysprintf("FN_DISPLAY()...\n"); // ch_20220418
#endif
if (!GetExpToken(LINE_END, Token, sizeof(Token)))
return _ERROR;
#if defined(LCD_MODEL)
if (strcmp(Token, "IMAGE") == 0)
{
#if defined(TDP225_PCB)
UCHAR dspmem[(LCD_WIDTH + 7) / 8 * LCD_HEIGHT];
UCHAR *imgsrc, *imgdst;
INT height, width, widbyte, shift;
height = LCD_HEIGHT;
width = LCD_WIDTH + 7;
widbyte = (LCD_WIDTH + 7) / 8;
shift = (8 - (XCoord(0) % 8)) % 8;
imgsrc = sImageBuffer.pBuffer + sImageBuffer.iWidth / 8 * YCoord(0) + XCoord(0) / 8;
imgdst = shift ? dspmem - 1 : dspmem;
memset(dspmem, 0, sizeof(dspmem));
NorOR(width, height, sImageBuffer.iByteWidth, widbyte, 0, shift, imgsrc, imgdst);
#else
UCHAR imgmem[(LCD_HEIGHT + 7) / 8 * (LCD_WIDTH + 7)];
UCHAR dspmem[(LCD_HEIGHT + 7) / 8 * LCD_WIDTH];
UCHAR *image;
INT height, width, widbyte, shift;
INT pagemax, colmax, page, col;
height = LCD_WIDTH + 7;
width = LCD_HEIGHT;
widbyte = (LCD_HEIGHT + 7) / 8;
image = sImageBuffer.pBuffer + sImageBuffer.iWidth / 8 * YCoord(0) + XCoord(0) / 8;
shift = XCoord(0) % 8;
memset(imgmem, 0, sizeof(imgmem));
RightOR(width, height, sImageBuffer.iByteWidth, widbyte, 0, 0, image, imgmem);
pagemax = (LCD_HEIGHT + 7) / 8;
colmax = LCD_WIDTH;
for (page = 0; page < pagemax; page++)
for (col = 0; col < colmax; col++)
dspmem[page * colmax + col] = imgmem[(col + shift) * pagemax + (pagemax - 1 - page)];
#endif
SetDisplayImage(dspmem);
}
else if (strcmp(Token, "OFF") == 0)
ClrDisplayStatus(DIS_IMAGE);
#endif
#ifdef DEBUG_PRNT
sysprintf("FN_DISPLAY...\n"); // ch_20220418
#endif
return _SUCCESS;
}
INT FN_DELAY(VOID)
{
DOUBLE time;
#ifdef DEBUG_PRNT
sysprintf("FN_DELAY()...\n"); // ch_20211211
#endif
if (!GetExpNumber(LINE_END, &time))
return _ERROR;
delay_msec((INT)time);
return _SUCCESS;
}
INT FN_EOJ(VOID)
{
#ifdef DEBUG_PRNT
sysprintf("FN_EOJ()...\n"); // ch_20211211
#endif
RemoveLine();
WaitWorkJobEnd();
return _SUCCESS;
}
INT FN_ST(VOID)
{
CHAR Prefix[4][16], Suffix[4][16];
#ifdef DEBUG_PRNT
sysprintf("FN_ST()...\n"); // ch_20211211
#endif
memset(Prefix, 0, sizeof(Prefix));
memset(Suffix, 0, sizeof(Suffix));
if (!GetExpString(COMMA_END, Prefix[0], sizeof(Prefix[0])))
return _ERROR;
if (!GetExpString(LINE_END, Suffix[0], sizeof(Suffix[0])))
return _ERROR;
memcpy(pPrintCfg->InputPrefix, Prefix, sizeof(pPrintCfg->InputPrefix));
memcpy(pPrintCfg->InputSuffix, Suffix, sizeof(pPrintCfg->InputSuffix));
return _SUCCESS;
}
INT FN_INPUTPREFIX(VOID)
{
CHAR prefix[4][16];
CHAR data;
INT set;
#ifdef DEBUG_PRNT
sysprintf("FN_INPUTPREFIX()...\n"); // ch_20211211
#endif
memset(prefix, 0, sizeof(prefix));
for (set = 0; set < 4; set++)
{
if (GetExpString(BACK_WITHOUT_SPACE, prefix[set], sizeof(prefix[set])))
{
data = NextByte();
if (CheckTokenEnd(LINE_END, data))
break;
data = NextByte();
if (CheckTokenEnd(COMMA_END, data))
continue;
}
return _ERROR;
}
if (set == 4)
return _ERROR;
memcpy(pPrintCfg->InputPrefix, prefix, sizeof(pPrintCfg->InputPrefix));
return _SUCCESS;
}
INT FN_INPUTSUFFIX(VOID)
{
CHAR suffix[4][16];
CHAR data;
INT set;
#ifdef DEBUG_PRNT
sysprintf("FN_INPUTSUFFIX()...\n"); // ch_20211211
#endif
memset(suffix, 0, sizeof(suffix));
for (set = 0; set < 4; set++)
{
if (GetExpString(BACK_WITHOUT_SPACE, suffix[set], sizeof(suffix[set])))
{
data = NextByte();
if (CheckTokenEnd(LINE_END, data))
break;
data = NextByte();
if (CheckTokenEnd(COMMA_END, data))
continue;
}
return _ERROR;
}
if (set == 4)
return _ERROR;
memcpy(pPrintCfg->InputSuffix, suffix, sizeof(pPrintCfg->InputSuffix));
return _SUCCESS;
}
#endif
TsplFunc.h /
#ifndef TSPLFUNC_H
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define TSPLFUNC_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 *
* *
******************************************************************************/
#include "XVarBank.h"
#include "XImgMgr.h"
#include "XPrtEng.h"
#include "..\Parser.h"
#include "..\ParserUtil.h"
#include "Error.h"
/******************************************************************************
* *
* U S E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/
#ifdef __cplusplus
extern "C" { /* Assume C declarations for C++ */
#endif /* __cplusplus */
/******************************************************************************
* *
* G L O B A L D E F I N E S *
* *
******************************************************************************/
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
#ifdef TSPLFUNC_C
#define EXTERN
#else
#define EXTERN extern
#endif
EXTERN INT MaxiCodeMode;
EXTERN INT DriverCopy;
EXTERN LONG PrintSets;
EXTERN LONG PrintCopies;
EXTERN BOOL InputFilter;
EXTERN BOOL CRLF_IsInputData;
EXTERN INT BasFileKey;
// file command use handle
EXTERN _FileHandle *UseHandle_0;
EXTERN _FileHandle *UseHandle_1;
// Tspl code page remap
EXTERN BYTE TsplRemapChar[256];
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
extern _CmdEntry SetEntry[];
extern _CmdEntry TsplEntry[];
extern CONST _CmdEntry BasicEntry[];
extern CONST _CmdEntry DriverEntry[];
extern CONST _BarcodeTable sBarcodeTab[];
/******************************************************************************
* *
* F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/
// Driver command ( TsplDrvFunc.c )
INT FN_DRIVER_COMMAND(VOID);
INT FN_RS232_COMMAND(VOID);
// Image command ( TsplImgFunc.c )
INT FN_CLS(VOID);
INT FN_BAR(VOID);
INT FN_DIAGONAL(VOID);
INT FN_CIRCLE(VOID);
INT FN_ERASE(VOID);
INT FN_REVERSE(VOID);
INT FN_BOX(VOID);
INT FN_BARCODE(VOID);
INT FN_TEXT(VOID);
INT FN_BITMAP(VOID);
INT FN_PUTBMP(VOID);
INT FN_PUTPCX(VOID);
INT FN_AZTEC(VOID);
INT FN_DMATRIX(VOID);
INT FN_MAXI(VOID);
INT FN_PDF(VOID);
INT FN_MPDF(VOID);
INT FN_QRCODE(VOID);
INT FN_RSS(VOID);
// Normal command ( TsplFunc.c )
INT FN_REM(VOID);
INT FN_SIZE(VOID);
INT FN_GAP(VOID);
INT FN_BLINE(VOID);
INT FN_SHIFT(VOID);
INT FN_SPEED(VOID);
INT FN_FEED(VOID);
INT FN_BACKFEED(VOID);
INT FN_FORMFEED(VOID);
INT FN_HOME(VOID);
INT FN_DENSITY(VOID);
INT FN_DIRECTION(VOID);
INT FN_OFFSET(VOID);
INT FN_REFERENCE(VOID);
INT FN_PRINT(VOID);
INT FN_CUT(VOID);
INT FN_SET(VOID);
INT FN_REDRAW(VOID);
INT FN_DOWNLOAD(VOID);
INT FN_EOP(VOID);
INT FN_LOAD(VOID);
INT FN_RUN(VOID);
INT FN_KILL(VOID);
INT FN_COUNTRY(VOID);
INT FN_CODEPAGE(VOID);
INT FN_INPUT(VOID);
INT FN_OUT(VOID);
INT FN_OUTR(VOID);
INT FN_MOVE(VOID);
INT FN_COPY(VOID);
INT FN_BEEP(VOID);
INT FN_SOUND(VOID);
INT FN_DISPLAY(VOID);
INT FN_DELAY(VOID);
INT FN_EOJ(VOID);
INT FN_ST(VOID);
INT FN_INPUTPREFIX(VOID);
INT FN_INPUTSUFFIX(VOID);
// Basic file function ( TsplFileFunc.c )
INT FN_OPEN(VOID);
INT FN_CLOSE(VOID);
INT FN_SEEK(VOID);
INT FN_READ(VOID);
INT FN_WRITE(VOID);
// Basic function ( TsplBasFunc.c )
VOID BasInitialBASIC(VOID);
VOID BasClearHandle(VOID);
BOOL CheckBasLable(CHAR *);
INT BAS_IF(VOID);
INT BAS_ELSE(VOID);
INT BAS_ELSEIF(VOID);
INT BAS_ENDIF(VOID);
INT BAS_FOR(VOID);
INT BAS_NEXT(VOID);
INT BAS_EXITFOR(VOID);
INT BAS_WHILE(VOID);
INT BAS_WEND(VOID);
INT BAS_DO(VOID);
INT BAS_LOOP(VOID);
INT BAS_EXITDO(VOID);
INT BAS_GOSUB(VOID);
INT BAS_RETURN(VOID);
INT BAS_GOTO(VOID);
INT BAS_OPEN(VOID);
INT BAS_WRITE(VOID);
INT BAS_READ(VOID);
INT BAS_CLOSE(VOID);
INT BAS_SEEK(VOID);
INT BAS_END(VOID);
INT BAS_EOP(VOID);
// Set command ( TsplSetFunc.c )
INT FN_SET_COM1(VOID);
INT FN_SET_LED1(VOID);
INT FN_SET_LED2(VOID);
INT FN_SET_LED3(VOID);
INT FN_SET_KEY1(VOID);
INT FN_SET_KEY2(VOID);
INT FN_SET_KEY3(VOID);
INT FN_SET_KEY4(VOID);
INT FN_SET_KEY5(VOID);
INT FN_SET_KEY6(VOID);
INT FN_SET_GPI1(VOID);
INT FN_SET_GPI2(VOID);
INT FN_SET_GPI3(VOID);
INT FN_SET_GPI4(VOID);
INT FN_SET_GPO1(VOID);
INT FN_SET_GPO2(VOID);
INT FN_SET_GPO3(VOID);
INT FN_SET_GPO4(VOID);
INT FN_SET_GPO5(VOID);
INT FN_SET_GPO6(VOID);
INT FN_SET_GPO7(VOID);
INT FN_SET_CUTTER(VOID);
INT FN_SET_PARTIAL_CUTTER(VOID);
INT FN_SET_BACK(VOID);
INT FN_SET_PEEL(VOID);
INT FN_SET_TEAR(VOID);
INT FN_SET_COUNTER(VOID);
INT FN_SET_DEBUG(VOID);
INT FN_SET_SENSOR_REF(VOID);
INT FN_SET_INVALID_GAP(VOID);
INT FN_SET_DISPLAY_REMAIN(VOID);
INT FN_SET_GAP(VOID);
INT FN_SET_RIBBON_I(VOID);
INT FN_SET_CONTRAST(VOID);
INT FN_SET_COMMAND(VOID);
INT FN_SET_RIBBON(VOID);
INT FN_SET_ENCODER(VOID);
INT FN_SET_HEAD(VOID);
INT FN_SET_NOBACK(VOID);
INT FN_SET_MAXICODE(VOID);
INT FN_SET_EXTFEED(VOID);
INT FN_SET_FEED_TIME(VOID);
INT FN_SET_FEED_LEN(VOID);
INT FN_SET_REPRINT(VOID);
INT FN_SET_PRINTKEY(VOID);
INT FN_SET_REPRINTKEY(VOID);
INT FN_SET_VERIFIER(VOID);
INT FN_SET_AUTORUN(VOID);
INT FN_SET_OVERHEAT(VOID);
INT FN_SET_MOTOR_OVERHEAT(VOID);
INT FN_SET_INPUTFILTER(VOID);
#if defined(DURALABEL)
INT FN_SET_RF_COMMAND(VOID);
INT FN_RFSET(VOID);
INT FN_RFID(VOID);
#endif
// for test
VOID OutBasicStatus(VOID);
#undef EXTERN
#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */
#endif
657
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
