T168_Backup\T168_111\appl\Parser\Bsc文件：3个独立.c

最新推荐文章于 2024-07-20 19:39:28 发布

qq_33772147

最新推荐文章于 2024-07-20 19:39:28 发布

阅读量753

点赞数 26

文章标签： c语言数据库 sql

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

版权

BscFuncDiag.c //

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

#define BSCDIAG_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 <stdarg.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 "XComm.h"
#include "XADC.h"
#include "XRTC.h"
#include "XTimer.h"
#include "XProFile.h"
#include "XPrtEng.h"
#include "XCodePage.h"
#include "XFunction.h"
#include "XAppVer.h"
#include "..\Parser.h"
#include "..\ParserUtil.h"
#include "BscUtil.h"
#include "BscFunc.h"

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

#define DIAG_EDITION 001

#define START_CHAR           '('
#define SEPARATE_CHAR       ':'
#define END_CHAR           ')'

#define DIAG_TYPE_COM       0
#define DIAG_TYPE_USB       1
#define DIAG_TYPE_NET       2
#define DIAG_TYPE_BT         3
#define DIAG_TYPE_WIFI         4

#define DIAG_TYPE_TOTAL (sizeof(DiagTypeTable) / sizeof(CHAR *))

#define DIAG_WAIT_TIME 3000

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

CONST CHAR *DiagTypeTable[] =
{
   "COM",
   "USB",
   "NET",
   "BT",
   "WIFI",
};

CONST STATIC _CmdEntry DiagReportEntry[] =
{
   {"DIGEDITION",           FN_DIAG_REP_Edition},
   {"REPASSWORD",       FN_DIAG_REP_Password},
   {"REPDPI",               FN_DIAG_REP_DPI},

   // Printer Information
   {"REPVER",           FN_DIAG_REP_Version},
   {"REPSERIAL",           FN_DIAG_REP_Serial},
   {"REPCHECKSUM",       FN_DIAG_REP_CheckSum},
   {"REPMILAGE",           FN_DIAG_REP_Milage},
   {"REPCUTTERCOUNTER",       FN_DIAG_REP_CutCounter},

   // Printer Configuration - Common
   {"REPSPEED",           FN_DIAG_REP_Speed},
   {"REPDENSITY",           FN_DIAG_REP_Density},
   {"REPDENSITYBASE",       FN_DIAG_REP_DensityBase},
   {"REPPAPERWIDTH",       FN_DIAG_REP_PaperWidth},
   {"REPPAPERHEIGHT",       FN_DIAG_REP_PaperHeight},
   {"REPSENSORMODE",       FN_DIAG_REP_SensorMode},
   {"REPGAPSIZE",           FN_DIAG_REP_GapSize},
   {"REPGAPOFFSET",       FN_DIAG_REP_GapOffset},
   {"REPPRINTOUT",       FN_DIAG_REP_PrintOut},
   {"REPCUTTERPIECE",       FN_DIAG_REP_CutterPiece},
   {"REPREFERENCEX",       FN_DIAG_REP_ReferenceX},
   {"REPREFERENCEY",       FN_DIAG_REP_ReferenceY},
   {"REPDIRCTION",       FN_DIAG_REP_Direction},
   {"REPMIRROR",           FN_DIAG_REP_Mirror},
   {"REPOFFSET",           FN_DIAG_REP_Offset},
   {"REPOFFSETBASE",       FN_DIAG_REP_OffsetBase},
   {"REPSHIFT",           FN_DIAG_REP_Shift},
   {"REPSHIFTBASE",       FN_DIAG_REP_ShiftBase},
   {"REPSHIFTX",           FN_DIAG_REP_ShiftX},
   {"REPSHIFTXBASE",       FN_DIAG_REP_ShiftXBase},
   {"REPRIBBON",           FN_DIAG_REP_Ribbon},
   {"REPCODEPAGE",       FN_DIAG_REP_CodePage},
   {"REPCOUNTRY",           FN_DIAG_REP_Country},
   {"REPHEAD",           FN_DIAG_REP_Head},
   {"REPREPRINT",           FN_DIAG_REP_Reprint},
   {"REPMAXLENGTH",       FN_DIAG_REP_MaxLength},
   {"REPGAPINTEN",       FN_DIAG_REP_GapInten},
   {"REPBLINEINTEN",       FN_DIAG_REP_BlineInten},
   {"REPCONINTEN",       FN_DIAG_REP_ConInten},
   {"REPBAUDRATE",       FN_DIAG_REP_BaudRate},
   {"REPDATABIT",           FN_DIAG_REP_DataBit},
   {"REPPARITY",           FN_DIAG_REP_Parity},
   {"REPSTOPBIT",           FN_DIAG_REP_StopBit},

   // Printer Configuration - ZPL
   {"REPZDARKNESS",       FN_DIAG_REP_ZDarkness},
   {"REPZSPEED",           FN_DIAG_REP_ZSpeed},
   {"REPZPOSITION",       FN_DIAG_REP_ZPosition},
   {"REPZPRINTMODE",       FN_DIAG_REP_ZPrintMode},
   {"REPZLABELWIDTH",       FN_DIAG_REP_ZLabelWidth},
   {"REPZCONTROL",       FN_DIAG_REP_ZControl},
   {"REPZFORMAT",           FN_DIAG_REP_ZFormat},
   {"REPZDELIMITER",       FN_DIAG_REP_ZDelimiter},
   {"REPZFEEDPOWERUP",   FN_DIAG_REP_ZFeedPowerUp},
   {"REPZFEEDHEADCLOSE",   FN_DIAG_REP_ZFeedHeadClose},
   {"REPZLABELTOP",       FN_DIAG_REP_ZLabelTop},
   {"REPZLABELSHIFT",       FN_DIAG_REP_ZLabelShift},

   // Printer Configuration - DPL
   {"REPDHEAT",           FN_DIAG_REP_DHeat},
   {"REPDSPEED",           FN_DIAG_REP_DPrintSpeed},
   {"REPDLABELWIDTH",       FN_DIAG_REP_DLabelWidth},
   {"REPDPRESENTSENSOR",   FN_DIAG_REP_DPresentSensor},
   {"REPDCUTTEREQUIPPED",   FN_DIAG_REP_DCutterEquipped},
   {"REPDCONTROLCODES",   FN_DIAG_REP_DControlCodes},
   {"REPDCOLUMNOFFSET",   FN_DIAG_REP_DColumnOffset},
   {"REPDROWOFFSET",       FN_DIAG_REP_DRowOffset},

   // File Information
   {"REPDFILELIST",       FN_DIAG_REP_DramFileList},
   {"REPFFILELIST",       FN_DIAG_REP_FlashFileList},
   {"REPCFILELIST",       FN_DIAG_REP_CardFileList},
   {"REPDPHYSPACE",       FN_DIAG_REP_DramPhySpace},
   {"REPFPHYSPACE",       FN_DIAG_REP_FlashPhySpace},
   {"REPCPHYSPACE",       FN_DIAG_REP_CardPhySpace},
   {"REPDFREESPACE",       FN_DIAG_REP_DramFreeSpace},
   {"REPFFREESPACE",       FN_DIAG_REP_FlashFreeSpace},
   {"REPCFREESPACE",       FN_DIAG_REP_CardFreeSpace},

   // Printer Function - Ethernet Setup
   {"REPNETNAME",           FN_DIAG_REP_NetName},
   {"REPMACADDR",           FN_DIAG_REP_MACAddr},
   {"REPCONFIGIP",       FN_DIAG_REP_ConfigIP},
   {"REPGATEWAY",           FN_DIAG_REP_Gateway},
   {"REPIPMASK",           FN_DIAG_REP_IPMask},
   {"REPLASTUSEDIP",       FN_DIAG_REP_LastUsedIP},

   // Printer Function - Bluetooth Setup
   {"REPBT",           FN_DIAG_REP_Bt},
   {"REPBTNAME",           FN_DIAG_REP_BtName},
   {"REPBTPIN",           FN_DIAG_REP_BtPin},
   {"REPBTADDR",           FN_DIAG_REP_BtAddr},
   {"REPBTVER",       FN_DIAG_REP_BtVer},

   // Printer Function - RTC Setup
   {"REPYEAR",           FN_DIAG_REP_Year},
   {"REPMONTH",           FN_DIAG_REP_Month},
   {"REPDATE",           FN_DIAG_REP_Date},
   {"REPHOUR",           FN_DIAG_REP_Hour},
   {"REPMINUTE",           FN_DIAG_REP_Minute},
   {"REPSECOND",           FN_DIAG_REP_Second},

   // Printer Function - Calibrate Sensor
   {"REPGAPSENSOR",       FN_DIAG_REP_GapSensor},
   {"REPBLINESENSOR",       FN_DIAG_REP_BlineSensor},

{(CHAR *)_NULL, _NULL}
};

INT CommInerface = UART_PORT;

/******************************************************************************
* *
* 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 DiagWrite(CONST VOID *buf, INT size)
{
CHAR token[STRING_LEN];
INT length;

length = sprintf(token, "%c%d%c", START_CHAR, size, SEPARATE_CHAR);

memcpy(token + length, buf, size);
length += size;

token[length++] = END_CHAR;

CommWrite(CommInerface, token, length, DIAG_WAIT_TIME);
}

STATIC VOID DiagPrintf(CONST CHAR *fmt, ...)
{
va_list args;
CHAR printbuf[STRING_LEN];

   va_start(args, fmt);
   vsprintf(printbuf, fmt, args);
   va_end(args);

DiagWrite(printbuf, strlen(printbuf));
}

INT FN_DIAG_REP_Edition(VOID)
{
DiagPrintf("%d", DIAG_EDITION);
return _SUCCESS;
}

INT FN_DIAG_REP_Password(VOID)
{
DiagPrintf("%s", pPrintCfg->DiagPassword);
return _SUCCESS;
}

INT FN_DIAG_REP_DPI(VOID)
{
DiagPrintf("%.1f", (FLOAT)TPH_DPI);
return _SUCCESS;
}

INT FN_DIAG_REP_Version(VOID)
{
DiagPrintf("%s Version: %s %s", ModelName, VerName, ExtModelName);
return _SUCCESS;
}

INT FN_DIAG_REP_Serial(VOID)
{
DiagPrintf("%s", pPrintRec->SerialNumberName);
return _SUCCESS;
}

INT FN_DIAG_REP_CheckSum(VOID)
{
DiagPrintf("%08X", CalculateCheckSum());
return _SUCCESS;
}

INT FN_DIAG_REP_Milage(VOID)
{
DiagPrintf("%.4f", (FLOAT)pPrintRec->DotMilage / (MM_DOT * 1000000));
return _SUCCESS;
}

INT FN_DIAG_REP_CutCounter(VOID)
{
DiagPrintf("%d", pPrintRec->CutCounter);
return _SUCCESS;
}

INT FN_DIAG_REP_Speed(VOID)
{
DiagPrintf("%s", ToSpeedString(pPrintCfg->Speed));
return _SUCCESS;
}

INT FN_DIAG_REP_Density(VOID)
{
DiagPrintf("%.1f", pPrintCfg->fDensity);
return _SUCCESS;
}

INT FN_DIAG_REP_DensityBase(VOID)
{
FLOAT data;

   if (!GetProfileInt("BASE DENSITY", &data))
       data = 0;
   DiagPrintf("%.1f", data);
   return _SUCCESS;
}

INT FN_DIAG_REP_PaperWidth(VOID)
{
DiagPrintf("%d", pPrintCfg->PaperWidth);
return _SUCCESS;
}

INT FN_DIAG_REP_PaperHeight(VOID)
{
DiagPrintf("%d", (WORD)pPrintCfg->fPaperSize);
return _SUCCESS;
}

INT FN_DIAG_REP_SensorMode(VOID)
{
DiagPrintf("%d", pPrintCfg->SensorMode);
return _SUCCESS;
}

INT FN_DIAG_REP_GapSize(VOID)
{
   if (pPrintCfg->SensorMode == GAP_MODE)
       DiagPrintf("%d", (WORD)pPrintCfg->fGapSize);
   else if (pPrintCfg->SensorMode == BLINE_MODE)
       DiagPrintf("%d", (WORD)pPrintCfg->fBlineSize);
   else
       DiagPrintf("0");

return _SUCCESS;
}

INT FN_DIAG_REP_GapOffset(VOID)
{
   if (pPrintCfg->SensorMode == GAP_MODE)
       DiagPrintf("%d", (WORD)pPrintCfg->fGapOffset);
   else if (pPrintCfg->SensorMode == BLINE_MODE)
       DiagPrintf("%d", (WORD)pPrintCfg->fBlineOffset);
   else
       DiagPrintf("0");

return _SUCCESS;
}

INT FN_DIAG_REP_PrintOut(VOID)
{
DiagPrintf("%d", pPrintCfg->PrintOutMode);
return _SUCCESS;
}

INT FN_DIAG_REP_CutterPiece(VOID)
{
DiagPrintf("%d", pPrintCfg->CutterPieces);
return _SUCCESS;
}

INT FN_DIAG_REP_ReferenceX(VOID)
{
DiagPrintf("%d", pPrintCfg->ReferenceX);
return _SUCCESS;
}

INT FN_DIAG_REP_ReferenceY(VOID)
{
DiagPrintf("%d", pPrintCfg->ReferenceY);
return _SUCCESS;
}

INT FN_DIAG_REP_Direction(VOID)
{
DiagPrintf("%d", pPrintCfg->Direction);
return _SUCCESS;
}

INT FN_DIAG_REP_Mirror(VOID)
{
DiagPrintf("%d", pPrintCfg->Mirror);
return _SUCCESS;
}

INT FN_DIAG_REP_Offset(VOID)
{
DiagPrintf("%d", pPrintCfg->OffsetDis);
return _SUCCESS;
}

INT FN_DIAG_REP_OffsetBase(VOID)
{
FLOAT data;

   if (!GetProfileInt("BASE OFFSET", &data))
       data = 0;
   DiagPrintf("%d", (SHORT)data);
   return _SUCCESS;
}

INT FN_DIAG_REP_Shift(VOID)
{
DiagPrintf("%d", pPrintCfg->ShiftDisY);
return _SUCCESS;
}

INT FN_DIAG_REP_ShiftBase(VOID)
{
FLOAT data;

   if (!GetProfileInt("SHIFT YBASE", &data))
       data = 0;
   DiagPrintf("%d", (SHORT)data);
   return _SUCCESS;
}

INT FN_DIAG_REP_ShiftX(VOID)
{
DiagPrintf("%d", pPrintCfg->ShiftDisX);
return _SUCCESS;
}

INT FN_DIAG_REP_ShiftXBase(VOID)
{
FLOAT data;

   if (!GetProfileInt("SHIFT XBASE", &data))
       data = 0;
   DiagPrintf("%d", (SHORT)data);
   return _SUCCESS;
}

INT FN_DIAG_REP_Ribbon(VOID)
{
DiagPrintf("%d", pPrintCfg->RibbonFlag);
return _SUCCESS;
}

INT FN_DIAG_REP_CodePage(VOID)
{
DiagPrintf("%s", CodePageNameTable[pPrintCfg->CodePage]);
return _SUCCESS;
}

INT FN_DIAG_REP_Country(VOID)
{
DiagPrintf("%s", CountryNameTable[pPrintCfg->Country]);
return _SUCCESS;
}

INT FN_DIAG_REP_Head(VOID)
{
DiagPrintf("%d", pPrintCfg->CarriageOpen);
return _SUCCESS;
}

INT FN_DIAG_REP_Reprint(VOID)
{
DiagPrintf("%d", pPrintCfg->Reprint);
return _SUCCESS;
}

INT FN_DIAG_REP_MaxLength(VOID)
{
DiagPrintf("%d", pPrintCfg->LimitFeed);
return _SUCCESS;
}

INT FN_DIAG_REP_GapInten(VOID)
{
DiagPrintf("%d", pPrintCfg->GapInten);
return _SUCCESS;
}

INT FN_DIAG_REP_BlineInten(VOID)
{
DiagPrintf("%d", pPrintCfg->BlineInten);
return _SUCCESS;
}

INT FN_DIAG_REP_ConInten(VOID)
{
DiagPrintf("%d", pPrintCfg->ContinuousInten);
return _SUCCESS;
}

INT FN_DIAG_REP_BaudRate(VOID)
{
   CONST STATIC CHAR *Baud[] = { "0","1200","2400","4800","9600","19200","38400","57600","115200" };
   DiagPrintf("%s", Baud[pPrintCfg->UartSetting.Baud]);
   return _SUCCESS;
}

INT FN_DIAG_REP_DataBit(VOID)
{
   CONST STATIC CHAR *DataBits[] = { "7","8" };
   DiagPrintf("%s", DataBits[pPrintCfg->UartSetting.DataBits]);
   return _SUCCESS;
}

INT FN_DIAG_REP_Parity(VOID)
{
   CONST STATIC CHAR *Parity[] = { "None","Odd","Even" };
   DiagPrintf("%s", Parity[pPrintCfg->UartSetting.Parity]);
   return _SUCCESS;
}

INT FN_DIAG_REP_StopBit(VOID)
{
   CONST STATIC CHAR *Stop[] = { "1","2" };
   DiagPrintf("%s", Stop[pPrintCfg->UartSetting.Stop]);
   return _SUCCESS;
}

INT FN_DIAG_REP_ZDarkness(VOID)
{
#if defined(ZPL2)
   _ZebraCfg *pZebraCfg = GrabZebraConfig();
   DiagPrintf("%d", pZebraCfg->PrintDarkness);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_ZSpeed(VOID)
{
#if defined(ZPL2)
   _ZebraCfg *pZebraCfg = GrabZebraConfig();
   if (isupper(pZebraCfg->PrintSpeed))
       DiagPrintf("%c", pZebraCfg->PrintSpeed);
   else
       DiagPrintf("%d", pZebraCfg->PrintSpeed);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_ZPosition(VOID)
{
#if defined(ZPL2)
   _ZebraCfg *pZebraCfg = GrabZebraConfig();
   DiagPrintf("%d", pZebraCfg->AdjustPosition);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_ZPrintMode(VOID)
{
#if defined(ZPL2)
   _ZebraCfg *pZebraCfg = GrabZebraConfig();
   DiagPrintf("%c", pZebraCfg->PrintMode);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_ZLabelWidth(VOID)
{
#if defined(ZPL2)
   _ZebraCfg *pZebraCfg = GrabZebraConfig();
   DiagPrintf("%d", pZebraCfg->LabelWidth);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_ZControl(VOID)
{
#if defined(ZPL2)
   _ZebraCfg *pZebraCfg = GrabZebraConfig();
   DiagPrintf("%c", pZebraCfg->TildeChar);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_ZFormat(VOID)
{
#if defined(ZPL2)
   _ZebraCfg *pZebraCfg = GrabZebraConfig();
   DiagPrintf("%c", pZebraCfg->CaretChar);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_ZDelimiter(VOID)
{
#if defined(ZPL2)
   _ZebraCfg *pZebraCfg = GrabZebraConfig();
   DiagPrintf("%c", pZebraCfg->DelimiterChar);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_ZFeedPowerUp(VOID)
{
#if defined(ZPL2)
   _ZebraCfg *pZebraCfg = GrabZebraConfig();
   DiagPrintf("%c", pZebraCfg->FeedPowerUp);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_ZFeedHeadClose(VOID)
{
#if defined(ZPL2)
   _ZebraCfg *pZebraCfg = GrabZebraConfig();
   DiagPrintf("%c", pZebraCfg->FeedCloseHead);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_ZLabelTop(VOID)
{
#if defined(ZPL2)
   _ZebraCfg *pZebraCfg = GrabZebraConfig();
   DiagPrintf("%d", pZebraCfg->LabelTop);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_ZLabelShift(VOID)
{
#if defined(ZPL2)
   _ZebraCfg *pZebraCfg = GrabZebraConfig();
   DiagPrintf("%d", pZebraCfg->LabelShift);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_DHeat(VOID)
{
#if defined(DPL)
   _DmxCfg *pDmxCfg = GrabDatamaxConfig();
   DiagPrintf("%d", pDmxCfg->Heat);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_DPrintSpeed(VOID)
{
#if defined(DPL)
   _DmxCfg *pDmxCfg = GrabDatamaxConfig();
   DiagPrintf("%c", pDmxCfg->PrintSpeed);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_DLabelWidth(VOID)
{
#if defined(DPL)
   _DmxCfg *pDmxCfg = GrabDatamaxConfig();
   DiagPrintf("%d", pDmxCfg->LabelWidth);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_DPresentSensor(VOID)
{
#if defined(DPL)
   _DmxCfg *pDmxCfg = GrabDatamaxConfig();
   DiagPrintf("%c", pDmxCfg->PresentSensorEquipped);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_DCutterEquipped(VOID)
{
#if defined(DPL)
   _DmxCfg *pDmxCfg = GrabDatamaxConfig();
   DiagPrintf("%c", pDmxCfg->CutterEquipped);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_DControlCodes(VOID)
{
#if defined(DPL)
   _DmxCfg *pDmxCfg = GrabDatamaxConfig();
   DiagPrintf("%c", pDmxCfg->ControlCodes);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_DColumnOffset(VOID)
{
#if defined(DPL)
   _DmxCfg *pDmxCfg = GrabDatamaxConfig();
   DiagPrintf("%d", pDmxCfg->ColumnOffset);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_DRowOffset(VOID)
{
#if defined(DPL)
   _DmxCfg *pDmxCfg = GrabDatamaxConfig();
   DiagPrintf("%d", pDmxCfg->RowOffset);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_DramFileList(VOID)
{
_FileList List;

   OpenList(&List, DRAM_DEVICE);
   while (NextFile(&List, "*.*"))
       DiagPrintf("%s", List.FileName);

DiagPrintf("");
return _SUCCESS;
}

INT FN_DIAG_REP_FlashFileList(VOID)
{
_FileList List;

   OpenList(&List, FLASH_DEVICE);
   while (NextFile(&List, "*.*"))
       DiagPrintf("%s", List.FileName);

DiagPrintf("");
return _SUCCESS;
}

INT FN_DIAG_REP_CardFileList(VOID)
{
_FileList List;

   OpenList(&List, CARD_DEVICE);
   while (NextFile(&List, "*.*"))
       DiagPrintf("%s", List.FileName);

DiagPrintf("");
return _SUCCESS;
}

INT FN_DIAG_REP_DramPhySpace(VOID)
{
DiagPrintf("%d", PhysicalSpace(DRAM_DEVICE));
return _SUCCESS;
}

INT FN_DIAG_REP_FlashPhySpace(VOID)
{
DiagPrintf("%d", PhysicalSpace(FLASH_DEVICE));
return _SUCCESS;
}

INT FN_DIAG_REP_CardPhySpace(VOID)
{
DiagPrintf("%d", PhysicalSpace(CARD_DEVICE));
return _SUCCESS;
}

INT FN_DIAG_REP_DramFreeSpace(VOID)
{
DiagPrintf("%d", FreeSpace(DRAM_DEVICE));
return _SUCCESS;
}

INT FN_DIAG_REP_FlashFreeSpace(VOID)
{
DiagPrintf("%d", FreeSpace(FLASH_DEVICE));
return _SUCCESS;
}

INT FN_DIAG_REP_CardFreeSpace(VOID)
{
DiagPrintf("%d", FreeSpace(CARD_DEVICE));
return _SUCCESS;
}

INT FN_DIAG_REP_NetName(VOID)
{
#if defined(NUTNET)
   DiagPrintf("%s", pPrintCfg->confos.hostname);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_MACAddr(VOID)
{
#if defined(NUTNET)
   DiagPrintf("%02X-%02X-%02X-%02X-%02X-%02X",
       pPrintCfg->confnet.cdn_mac[0],
       pPrintCfg->confnet.cdn_mac[1],
       pPrintCfg->confnet.cdn_mac[2],
       pPrintCfg->confnet.cdn_mac[3],
       pPrintCfg->confnet.cdn_mac[4],
       pPrintCfg->confnet.cdn_mac[5]);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_ConfigIP(VOID)
{
#if defined(NUTNET)
   DiagPrintf("%s", inet_ntoa(pPrintCfg->confnet.cdn_cip_addr));
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_Gateway(VOID)
{
#if defined(NUTNET)
   DiagPrintf("%s", inet_ntoa(pPrintCfg->confnet.cdn_gateway));
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_IPMask(VOID)
{
#if defined(NUTNET)
   DiagPrintf("%s", inet_ntoa(pPrintCfg->confnet.cdn_ip_mask));
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_LastUsedIP(VOID)
{
#if defined(NUTNET)
   DiagPrintf("%s", inet_ntoa(pPrintCfg->confnet.cdn_ip_addr));
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_Bt(VOID)
{
#if defined(UART2_BT)
   DiagPrintf("%d", pPrintCfg->BtSetting.enble);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;
}

INT FN_DIAG_REP_BtName(VOID)
{
#if defined(UART2_BT)
   DiagPrintf("%s", pPrintCfg->BtSetting.name);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;}

INT FN_DIAG_REP_BtPin(VOID)
{
#if defined(UART2_BT)
   DiagPrintf("%s", pPrintCfg->BtSetting.pin);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;}

INT FN_DIAG_REP_BtAddr(VOID)
{
#if defined(UART2_BT)
   DiagPrintf("%s", pPrintCfg->BtSetting.mac);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;}

INT FN_DIAG_REP_BtVer(VOID)
{
#if defined(UART2_BT)
   DiagPrintf("%s", pPrintCfg->BtSetting.ver);
#else
   DiagPrintf("");
#endif
   return _SUCCESS;}

INT FN_DIAG_REP_Year(VOID)
{
DiagPrintf("%d", GetRTC(RTC_YEAR));
return _SUCCESS;
}

INT FN_DIAG_REP_Month(VOID)
{
DiagPrintf("%d", GetRTC(RTC_MONTH));
return _SUCCESS;
}

INT FN_DIAG_REP_Date(VOID)
{
DiagPrintf("%d", GetRTC(RTC_DATE));
return _SUCCESS;
}

INT FN_DIAG_REP_Hour(VOID)
{
DiagPrintf("%d", GetRTC(RTC_HOUR));
return _SUCCESS;
}

INT FN_DIAG_REP_Minute(VOID)
{
DiagPrintf("%d", GetRTC(RTC_MIN));
return _SUCCESS;
}

INT FN_DIAG_REP_Second(VOID)
{
DiagPrintf("%d", GetRTC(RTC_SEC));
return _SUCCESS;
}

INT FN_DIAG_REP_GapSensor(VOID)
{
WORD Value;
INT Inten;

   for (Inten = 0; Inten < GAP_SENSOR_SCALE; Inten++)
   {
       EnableSensor(GAP_SENSOR, Inten, pPrintCfg->RibbonFlag, 0);
       DelayTime(0x800000 / GAP_SENSOR_SCALE);

#if defined(ANALOG_MEDIA) && defined(GAP_SENSOR_AD)
       StartADConvert(GAP_SENSOR_AD);
       Value = ReadAD(GAP_SENSOR_AD);
       DiagPrintf("%d", Value);
#else
       DiagPrintf("%d", GetSensorSignal(GAP_SENSOR));
#endif
   }
   DisableSensor(GAP_SENSOR);

DiagPrintf("");
return _SUCCESS;
}

INT FN_DIAG_REP_BlineSensor(VOID)
{
WORD Value;
INT Inten;

   for (Inten = 0; Inten < BLINE_SENSOR_SCALE; Inten++)
   {
       EnableSensor(BLINE_SENSOR, Inten, pPrintCfg->RibbonFlag, 0);
       DelayTime(0x800000 / BLINE_SENSOR_SCALE);

#if defined(ANALOG_MEDIA) && defined(BLINE_SENSOR_AD)
       StartADConvert(BLINE_SENSOR_AD);
       Value = ReadAD(BLINE_SENSOR_AD);
       debug_printf("9");
       DiagPrintf("%d", Value);
#else
       DiagPrintf("%d", GetSensorSignal(BLINE_SENSOR));
#endif
   }
   DisableSensor(BLINE_SENSOR);

DiagPrintf("");
return _SUCCESS;
}

INT FN_DIAG_PASSWORD(VOID)
{
CHAR String[STRING_LEN];

   if (!BscGetString(LINE_END, String, sizeof(String)))
       return _ERROR;
   if (strlen(String) >= sizeof(pPrintCfg->DiagPassword))
       return _ERROR;

   strcpy((CHAR *)pPrintCfg->DiagPassword, String);
   DiagPrintf("");
   return _SUCCESS;
}

INT FN_DIAG_INTERFACE(VOID)
{
CHAR Token[STRING_LEN];
INT Type;

if (!BscGetToken(LINE_END, Token, sizeof(Token)))
return _ERROR;

   for (Type = 0; Type < DIAG_TYPE_TOTAL; Type++)
   {
       if (strcmp(Token, DiagTypeTable[Type]) == 0)
           break;
   }
   if (Type == DIAG_TYPE_TOTAL)
       return _ERROR;

   switch (Type)
   {
       case DIAG_TYPE_COM:
           CommInerface = UART_PORT;
           break;
       case DIAG_TYPE_USB:
           CommInerface = USB_PORT;
           break;
#if defined(NUTNET)
       case DIAG_TYPE_NET:
           if (GetCommPort() == UART_PORT)
               CommInerface = UART_PORT;
           else
               CommInerface = ETHERNET_PORT;
           break;
#endif
case DIAG_TYPE_BT:
CommInerface = BT_PORT;
break;
       case DIAG_TYPE_WIFI:
       CommInerface = WIFI_PORT;
       break;
   }
   DiagPrintf("");
   return _SUCCESS;
}

INT FN_DIAG_REPORT(VOID)
{
CHAR Token[STRING_LEN];
_CmdEntry *CmdEntry;

if (!BscGetToken(LINE_END, Token, sizeof(Token)))
return _ERROR;

if (CmdEntry = CheckStringCommand(Token, DiagReportEntry))
return CmdEntry->func();

return _ERROR;
}

INT FN_DIAG_FILE(VOID)
{
   _eFileDevice Device;
   _FileHandle *Handle;
   CHAR FileName[FILENAME_LENGTH];
   CHAR Token[STRING_LEN];
   INT Length;
   INT c;

   // Load file from DRAM & FLASH on borad or card
   if (!BscGetFileDevice(&Device))
       return _ERROR;

if (!BscGetString(LINE_END, FileName, sizeof(FileName)))
return _ERROR;

if ((Handle = Fopen(Device, FileName, "r")) == _NULL)
return _ERROR;

   Length = sprintf(Token, "%c%d%c", START_CHAR, FileLength(FileNo(Handle)), SEPARATE_CHAR);
   while ((c = Fgetc(Handle)) != END_OF_FILE)
   {
       Token[Length++] = (BYTE)c;
       if (Length >= sizeof(Token))
       {
           CommWrite(CommInerface, Token, sizeof(Token), DIAG_WAIT_TIME);
           Length -= sizeof(Token);
       }
   }
   Token[Length++] = END_CHAR;
   CommWrite(CommInerface, Token, Length, DIAG_WAIT_TIME);

Fclose(Handle);
return _SUCCESS;
}

BscFuncFac.c /

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

#define BSCFUNCFAC_C

#include <string.h>

#include "Common.h"
#include "XCore.h"
#include "XNutOS.h"
#include "XADC.h"
#include "XLED.h"
#include "XPS2.h"
#include "XLCD.h"
#include "XComm.h"
#include "XTimer.h"
#include "XPrtEng.h"
#include "XFunction.h"
#include "BscUtil.h"
#include "BscFunc.h"
#include "XProFile.h"

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

#define FAC_TYPE_TOTAL (sizeof(FacTypeTable) / sizeof(CHAR *))

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

enum {
FAC_TYPE_ON,
FAC_TYPE_OFF,
};

STATIC CONST CHAR *FacTypeTable[] =
{
"ON",
"OFF",
};

INT FN_FAC_LABEL(VOID)
{
INT Number;

if (!BscGetNumber(LINE_END, &Number))
return _ERROR;

pPrintRec->LabelMilage = Number;
return _SUCCESS;
}

INT FN_FAC_MILAGE(VOID)
{
INT Number;

if (!BscGetNumber(LINE_END, &Number))
return _ERROR;

pPrintRec->DotMilage = Number;
return _SUCCESS;
}

INT FN_FAC_CUTCOUNTER(VOID)
{
INT Number;

if (!BscGetNumber(LINE_END, &Number))
return _ERROR;

pPrintRec->CutCounter = Number;
return _SUCCESS;
}

INT FN_FAC_CONTRAST(VOID)
{
INT Number;

if (!BscGetNumber(LINE_END, &Number))
return _ERROR;

SetFactorySetting(FACTORY_DISPLAY_CONTRAST, & Number, sizeof(Number));

#if defined(LCD_MODEL)
LcdSetContrast(Number);
#endif

return _SUCCESS;
}

INT FN_FAC_SERIAL(VOID)
{
CHAR String[STRING_LEN];
FLOAT fData = 0;

   if (!BscGetString(LINE_END, String, sizeof(String)))
       return _ERROR;
   if (strlen(String) >= sizeof(pPrintRec->SerialNumberName))
       return _ERROR;
   GetProfileInt("SERIALKEY",&fData);
   if(strlen(pPrintRec->SerialNumberName)&&(fData>2.1753724||fData<2.1753723))
   return _ERROR;

   memset(pPrintRec->SerialNumberName, 0, sizeof(pPrintRec->SerialNumberName));
   strcpy(pPrintRec->SerialNumberName, String);
   pPrintRec->UsbSerial = 0;

   PrinterReboot();
   return _SUCCESS;
}
INT FN_FAC_TPH_SERIAL(VOID)
{
   CHAR String[STRING_LEN];
   FLOAT fData = 0;

   if (!BscGetString(LINE_END, String, sizeof(String)))
       return _ERROR;
   if (strlen(String) >= sizeof(pPrintRec->TPHSerialNumberName))
       return _ERROR;
   GetProfileInt("SERIALKEY",&fData);
   if(strlen(pPrintRec->TPHSerialNumberName)&&(fData>2.1753724||fData<2.1753723))
   return _ERROR;

   memset(pPrintRec->TPHSerialNumberName, 0, sizeof(pPrintRec->TPHSerialNumberName));
   strcpy(pPrintRec->TPHSerialNumberName, String);
   pPrintRec->UsbSerial = 0;

PrinterReboot();
return _SUCCESS;
}

INT FN_FAC_RES_MOTORTEMP(VOID)
{
StartPeriodFunc(ResponseMotorTemp);
return _SUCCESS;
}

INT FN_FAC_RESPONSE(VOID)
{
_CmdEntry *CmdEntry;
CHAR Token[STRING_LEN];

   STATIC CONST _CmdEntry Entry[] =
   {
       {"MOTORTEMP",   FN_FAC_RES_MOTORTEMP},
       {(CHAR *)_NULL,   _NULL}
   };

if (!BscGetToken(LINE_END, Token, sizeof(Token)))
return _ERROR;

if (CmdEntry = CheckStringCommand(Token, Entry))
return CmdEntry->func();

return _ERROR;
}

INT FN_FAC_SET_CLEAR(VOID)
{
   SendString("FACTORY SETTING CLEAR\r\n");
   ClrFactorySetting();
   return _SUCCESS;
}

INT FN_FAC_SET_LIST(VOID)
{
   SendString("FACTORY SETTING LIST\r\n");
   ListFactorySetting();
   return _SUCCESS;
}

INT FN_FAC_SETTING(VOID)
{
_CmdEntry *CmdEntry;
CHAR Token[STRING_LEN];

   STATIC CONST _CmdEntry Entry[] =
   {
       {"CLEAR",   FN_FAC_SET_CLEAR},
       {"LIST",   FN_FAC_SET_LIST},
       {(CHAR *)_NULL,   _NULL}
   };

if (!BscGetToken(LINE_END, Token, sizeof(Token)))
return _ERROR;

if (CmdEntry = CheckStringCommand(Token, Entry))
return CmdEntry->func();

return _ERROR;
}

INT FN_FAC_TEST_TPHPOWER(VOID)
{
   CHAR token[STRING_LEN];
   INT setup, hold, rule;
   INT imask, value = 0;
   INT type;

if (!BscGetToken(SPACE_END, token, sizeof(token)))
return _ERROR;

if (!BscGetNumber(COMMA_END, &setup))
return _ERROR;

if (!BscGetNumber(COMMA_END, &hold))
return _ERROR;

if (!BscGetNumber(LINE_END, &rule))
return _ERROR;

   for (type = 0; type < FAC_TYPE_TOTAL; type++)
   {
       if (strcmp(token, FacTypeTable[type]) == 0)
           break;
   }
   if (type != FAC_TYPE_ON && type != FAC_TYPE_OFF)
       return _ERROR;

WaitWorkJobEnd();

SetTPHPower((type == FAC_TYPE_ON) ? FALSE : TRUE);

   // setup time (ms)
   while (setup--)
   {
#if defined(AT91SAM9260)
       DelayTime(35000);
#elif defined(N3290)
       DelayTime(7100);
#elif defined(SH7040)
       DelayTime(7100);
#endif
   }

imask = DisableInterrupt(INTERRUPT_MASK);

SetTPHPower((type == FAC_TYPE_ON) ? TRUE : FALSE);

   // hold time (ms)
   while (hold--)
   {
#if defined(AT91SAM9260)
       DelayTime(35000);
#elif defined(N3290)
       DelayTime(7100);
#elif defined(SH7040)
       DelayTime(7100);
#endif
   }

#if defined(TPH_VOLT_AD)
StartADConvert(TPH_VOLT_AD);
value = ReadAD(TPH_VOLT_AD);
#endif

SetTPHPower(FALSE);

EnableInterrupt(imask);

SendPrintf("\r\n TPH %s Volt AD:%d", token, value);

   if ((type == FAC_TYPE_ON && value < rule) ||
       (type == FAC_TYPE_OFF && value > rule))
   {
       SendPrintf(" Error !!!");

#if defined(MONO_LED)
       while (1) ShowLED(HID_LED_OFF, HID_LED_OFF, HID_LED_ON);
#elif defined(POLY_LED)
       while (1) ShowLED(HID_LED_RED);
#endif
   }

return _SUCCESS;
}

INT FN_FAC_TEST(VOID)
{
_CmdEntry *CmdEntry;
CHAR Token[STRING_LEN];

   STATIC CONST _CmdEntry Entry[] =
   {
       {"TPHPOWER",   FN_FAC_TEST_TPHPOWER},
       {(CHAR *)_NULL,   _NULL}
   };

if (!BscGetToken(BACK_WITH_SPACE, Token, sizeof(Token)))
return _ERROR;

if (CmdEntry = CheckStringCommand(Token, Entry))
return CmdEntry->func();

return _ERROR;
}

INT FN_FAC_PS2TEST(VOID)
{
BYTE Data;

RemoveLine();

SendString("\r\n PS2 KeyBoard Test\r\n");

InitialPS2Drv();

   while (1)
   {
       if (PS2RxDataOut(&Data))
           SendChar(Data);
   //   USHORT data = KeyboardOut();
   //   if (data)
   //       SendPrintf("\r\n %04X-[%c]", data, (CHAR)(data & 0xFF));
   }
   //return _SUCCESS;
}

BscFuncNet.c //

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

#define BSCFUNCNET_C

#include <string.h>
#include <ctype.h>

#include "Common.h"
#include "XCore.h"
#include "XTimer.h"
#include "XDisplay.h"
#include "XFunction.h"
#include "..\Parser.h"
#include "..\ParserUtil.h"
#include "BscUtil.h"
#include "BscFunc.h"

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

/* None */

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

/* None */

/******************************************************************************
*
* TSPL Commands
*       NET DHCP
*
* Description:
*       This command defines the unique Ethernet MAC address.
*
* Syntax:
*       NET MAC "address"
*
* Parameters:
*       address = Unique Ethernet address
*
******************************************************************************/
INT FN_NET_MAC(VOID)
{
   CHAR String[STRING_LEN], name[STRING_LEN];
   CHAR *str;
   UCHAR mac[6];
   INT parts;

   // Get MAC Address
   if (!BscGetString(LINE_END, String, sizeof(String)))
       return _ERROR;

   str = String;
   for (parts = 0; parts < sizeof(mac); )
   {
       if (!isdigit(*str) && (toupper(*str) < 'A' || toupper(*str) > 'F'))
           break;
       mac[parts] = (mac[parts] << 4) | (isdigit(*str) ? *str - '0' : toupper(*str) - 'A' + 10);
       str++;

       if (!isdigit(*str) && (toupper(*str) < 'A' || toupper(*str) > 'F'))
           break;
       mac[parts] = (mac[parts] << 4) | (isdigit(*str) ? *str - '0' : toupper(*str) - 'A' + 10);
       str++;

if (++parts == sizeof(mac))
break;

if (*str != '-')
           break;
       str++;
}
   if (parts != sizeof(mac) || *str != '\0')
       return _ERROR;
   sprintf(name, "XP-%02X%02X%02X", mac[3], mac[4], mac[5]);

   memcpy(pPrintRec->UniqueMAC, mac, sizeof(pPrintRec->UniqueMAC));
   memset(pPrintRec->PrintServerName, 0, sizeof(pPrintRec->PrintServerName));
   strcpy(pPrintRec->PrintServerName, name);

#if defined(LCD_MODEL)
   DspClearDisplay();
   sprintf(String, "%02X%02X%02X%02X%02X%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
   ShowLCDString((DSP_LINE_CHARS - strlen(String)) / 2, (DSP_LINES - 1) / 2, String, 0);
   delay_msec(1000);
#endif

#if defined(NUTNET)
memcpy(pPrintCfg->confnet.cdn_mac, mac, sizeof(pPrintCfg->confnet.cdn_mac));
strcpy(pPrintCfg->confos.hostname, name);

PrinterReboot();
#endif

return _SUCCESS;
}

/******************************************************************************
*
* TSPL Commands
*       NET DHCP
*
* Description:
*       This command set IP address to obtain one from the DHCP server.
*
* Syntax:
*       NET DHCP
*
* Parameters:
*
******************************************************************************/
INT FN_NET_DHCP(VOID)
{
   RemoveLine();

#if defined(NUTNET)
   // If this address is set to 0.0.0.0, will try
   // to obtain one from the DHCP server.
   pPrintCfg->confnet.cdn_cip_addr = 0;

PrinterReboot();
#endif

return _SUCCESS;
}

/******************************************************************************
*
* TSPL Commands
*       NET IP
*
* Description:
*       This command defines the Ethernet IP address.
*
* Syntax:
*       NET IP "ip","mask","gateway"
*
* Parameters:
*       ip = Configured IP address
*       mask = IP Subnet Mask
*       gateway = Default Gateway
*
******************************************************************************/
INT FN_NET_IP(VOID)
{
   CHAR String[STRING_LEN];
   ULONG ip, mask, geteway;

   // Get IP Address
   if (!BscGetString(COMMA_END, String, sizeof(String)))
       return _ERROR;

#if defined(NUTNET)
if ((ip = inet_addr(String)) == (ULONG)-1)
return _ERROR;
#endif

   // Get Subnet Mask
   if (!BscGetString(COMMA_END, String, sizeof(String)))
       return _ERROR;

#if defined(NUTNET)
if ((mask = inet_addr(String)) == (ULONG)-1)
return _ERROR;
#endif

   // Get Default Gateway
   if (!BscGetString(LINE_END, String, sizeof(String)))
       return _ERROR;

#if defined(NUTNET)
if ((geteway = inet_addr(String)) == (ULONG)-1)
return _ERROR;

   // Configure IP address
   pPrintCfg->confnet.cdn_cip_addr = ip;
   pPrintCfg->confnet.cdn_ip_mask = mask;
   pPrintCfg->confnet.cdn_gateway = geteway;

PrinterReboot();
#endif

return _SUCCESS;
}

/******************************************************************************
*
* TSPL Commands
*       NET PORT
*
* Description:
*       This command defines the port number that the printer should use for
*       it's RAW data.
*
* Syntax:
*       NET PORT number
*
* Parameters:
*       number = Base raw port number
*
******************************************************************************/
INT FN_NET_PORT(VOID)
{
   INT PortNumber;

   // Get Port Number
   if (!BscGetNumber(LINE_END, &PortNumber))
       return _ERROR;

   // Accepted Values: 0 to 65535
   if (PortNumber < 0 || PortNumber > 65535)
       return _ERROR;

pPrintCfg->NetRawPort = (WORD)PortNumber;

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

return _SUCCESS;
}

/******************************************************************************
*
* TSPL Commands
*       NET NAME
*
* Description:
*       This command defines the print server name.
*
* Syntax:
*       NET NAME "name"
*
* Parameters:
*       name = print server name
*
******************************************************************************/
INT FN_NET_NAME(VOID)
{
   CHAR String[STRING_LEN];

   // Get Print Server Name
   if (!BscGetString(LINE_END, String, sizeof(String)))
       return _ERROR;
   if (strlen(String) >= sizeof(pPrintRec->PrintServerName))
       return _ERROR;

memset(pPrintRec->PrintServerName, 0, sizeof(pPrintRec->PrintServerName));
strcpy(pPrintRec->PrintServerName, String);

#if defined(NUTOS)
strcpy(pPrintCfg->confos.hostname, String);

PrinterReboot();
#endif

return _SUCCESS;
}