#include "lcddisplay.h"
#include "global.h"
#include "asc16.h"
#include "asc8.h"
#include "hzk16.h"
#include "define.h"

static int lcdpipe = 0;
static char buf[20];
static unsigned char cur_page, cur_col;

void buffer_init() //写显示数据
{
	serial_buff_init();
	cur_page = cur_col = 0;
}

void buffer_flush(unsigned char LineBit)
{
	int ret = 0;

	ret = serial_flush(LineBit);
	if (ret)
	{
		printf("|%s|%s|%d| : call serial_flush( %d ) fail !\n", __FILE__, __func__, __LINE__, LineBit);
	}
}
/************************************************/
/*		Read\write display data\command         */
/************************************************/
void write_databyte(unsigned int databyte) //写显示数据
{
	//int ret = 0;
	serial_write_buff((unsigned int)cur_page, (unsigned int)cur_col, (unsigned int)databyte);

	//if(ret != 0)
	//{
	//    printf("serial_write_buff error,ret=%d\n",ret);
	//}
}
/************************************************/
/*         opration  command 					*/
/************************************************/

/******************************************/
/*		功能：设置显示起始页              */
/*    输入：起始页值	page              */
/*    输出：无                            */
/*    返回：			  */
/******************************************/
void LcdSetPage(unsigned char Page) //数据写起始页
{
	cur_page = Page; // page:0-8
}
/******************************************/
/*		功能：设置显示起始列              */
/*    输入：起始列值column                */
/*    输出：无                            */
/*    返回：正常0，错误非0			      */
/******************************************/
void LcdSetCol(unsigned char Col) //数据写起始列
{
	cur_col = Col;
}
/******************************************/
/*		功能：清屏            	  		  */
/*    输入：无                			  */
/*    输出：无                            */
/*    返回：正常0，错误非0				  */
/******************************************/
void LcdClear() //清屏程序
{
	serial_buff_init();
	buffer_flush(0xFF);
}

void Lcdflush() //清屏程序
{
	serial_buff_black();
	buffer_flush(0x0F);
}

void initLcdSystem(void)
{
	buffer_init();
}
/****************** 在当前位置上显示6*8点阵字符******************************
输入参数:
	Page:	显示起始页
	Col:	显示起始行
	Asc8:	显示内容(*Asc8为字模地址)
	Flag:   显示方式，NORMAL/REVERSE与UPHALF/DOWNHALF的组合
输出参数:
	无
返回值: 无
********************************************************************************/
void PrintASC8(unsigned char Page, unsigned char Col, unsigned char *Asc8, unsigned char Flag)
{
	unsigned char i, j;
	LcdSetPage(Page); /*设置页与栏*/
	for (i = 0; i < 6; i++)
	{
		LcdSetCol(Col++);
		j = Asc8[i];
		switch (Flag)
		{
		case REVERSE:
			j = ~j; /*全字符反色*/
			break;
		case UPHALF:
			j = j << 4; /*上半字符*/
			break;
		case REVERSE | UPHALF:
			j = ~(j << 4) & 0xFE; /*上半字符反色，最上边一条线不反显*/
			break;
		case DOWNHALF:
			j = j >> 4; /*下半字符*/
			break;
		case REVERSE | DOWNHALF:
			j = ~(j >> 4) & 0x7F; /*下半字符反色，最下边一条线不反显*/
			break;
		default:
			break; /*全字符正常显示*/
		}
		write_databyte(j);
	}
}

/************** 在当前显示位置上显示8*16点阵字符***********************************
输入参数:
	Page:	显示起始页
	Col:	显示起始行
	Asc16:	显示内容(*Asc16为字模地址)
	Flag:   显示方式，NORMAL/REVERSE
输出参数:
	无
返回值:	无
********************************************************************************/
void PrintASC16(unsigned char Page, unsigned char Col, unsigned char *Asc16, unsigned char Flag)
{
	unsigned char i, j, k, mode, nowcol;
	i = 0;
	k = 8;
	mode = 0xFE;

	do
	{
		LcdSetPage(Page); /*设置页与栏*/
		nowcol = Col;
		for (; i < k; i++) /*上半部分*/
		{
			LcdSetCol(nowcol++);
			j = Asc16[i];
			if (Flag != NORMAL)
				j = ~j & mode; /*反色，最上边一条线不反,最下边一条线不反*/
			write_databyte(j);
		}
		Page++;
		k = 16;
		mode = 0x7F;
	} while (i < 16);
}

/****************** 在当前位置上显示12*16点阵汉字***********************************
输入参数:
	Page:	显示起始页
	Col:	显示起始行
	HanZi:	显示内容(*HanZi为字模地址)
	Flag:   显示方式，NORMAL/REVERSE
输出参数:
	无
返回值: 无
********************************************************************************/
void PrintHANZI(unsigned char Page, unsigned char Col, unsigned char *HanZi, unsigned char Flag)
{

	unsigned char i, nowcol;
	// lrb add
	unsigned char hz = 0;
	LcdSetPage(Page); /*设置页与栏*/
	nowcol = Col;
	for (i = 0; i < 9; i += 3) /*上半部分*/
	{
		if (Flag == NORMAL)
		{
			LcdSetCol(nowcol++);
			// lrb mixing
			hz = *(HanZi + i) & 0xFC;
			write_databyte(hz);
			//			write_databyte(HanZi[i]&0xFC);
			LcdSetCol(nowcol++);
			write_databyte((HanZi[i] << 6) + ((HanZi[i + 1] & 0xF0) >> 2));
			LcdSetCol(nowcol++);
			write_databyte((HanZi[i + 1] << 4) + ((HanZi[i + 2] & 0xC0) >> 4));
			LcdSetCol(nowcol++);
			write_databyte(HanZi[i + 2] << 2);
		}
		else
		{
			LcdSetCol(nowcol++); /*反色，最上边一条线不反*/
			write_databyte(~(HanZi[i] & 0xFC) & 0xFE);
			LcdSetCol(nowcol++);
			write_databyte(~((HanZi[i] << 6) + ((HanZi[i + 1] & 0xF0) >> 2)) & 0xFE);
			LcdSetCol(nowcol++);
			write_databyte(~((HanZi[i + 1] << 4) + ((HanZi[i + 2] & 0xC0) >> 4)) & 0xFE);
			LcdSetCol(nowcol++);
			write_databyte(~(HanZi[i + 2] << 2) & 0xFE);
		}
	}
	LcdSetCol(nowcol); /* 字间距 */
	write_databyte(Flag == NORMAL ? 0x00 : 0xFE);
	LcdSetPage(Page + 1); /*设置页+1，重置栏*/
	nowcol = Col;
	for (; i < 18; i += 3) /*下半部分*/
	{
		if (Flag == NORMAL)
		{
			LcdSetCol(nowcol++);
			write_databyte(HanZi[i] >> 2);
			LcdSetCol(nowcol++);
			write_databyte(((HanZi[i] & 0x03) << 4) + ((HanZi[i + 1] & 0xF0) >> 4));
			LcdSetCol(nowcol++);
			write_databyte(((HanZi[i + 1] & 0x0F) << 2) + ((HanZi[i + 2] & 0xC0) >> 6));
			LcdSetCol(nowcol++);
			write_databyte(HanZi[i + 2] & 0x3F);
		}
		else
		{
			LcdSetCol(nowcol++); /*反色，最下边一条线不反*/
			write_databyte(~(HanZi[i] >> 2) & 0x7F);
			LcdSetCol(nowcol++);
			write_databyte(~(((HanZi[i] & 0x03) << 4) + ((HanZi[i + 1] & 0xF0) >> 4)) & 0x7F);
			LcdSetCol(nowcol++);
			write_databyte(~(((HanZi[i + 1] & 0x0F) << 2) + ((HanZi[i + 2] & 0xC0) >> 6)) & 0x7F);
			LcdSetCol(nowcol++);
			write_databyte(~(HanZi[i + 2] & 0x3F) & 0x7F);
		}
	}
	LcdSetCol(nowcol);
	write_databyte(Flag == NORMAL ? 0x00 : 0x7F);
}

/****************** 在当前位置上显示6*8点阵字符串******************************
输入参数:
	Page:	 显示起始页
	Col:	 显示起始行
	ValBuf:  显示内容(*ValBuf为字模地址,**ValBuf为字模地址列表)
	Num:	 字符个数
	Flag:    显示方式，NORMAL/REVERSE与CENTER的组合(是否下移半行）
输出参数:
	无
返回值: 无
********************************************************************************/
void PrintString8(unsigned char Page, unsigned char Col, unsigned char **ValBuf, unsigned char Num, unsigned char Flag)
{
	unsigned char i, temp;
	temp = Col;
ShowString:
	for (Col = temp, i = 0; i < Num; i++)
	{
		PrintASC8(Page, Col, ValBuf[i], Flag);
		Col += 6;
	}
	if ((Flag & 0xFE) == UPHALF) //屏蔽NORMAL/REVERSE位,CENTER和UPHALF值相同
	{
		Page++;
		Flag = (Flag & 0x01) | DOWNHALF; //如果是上面半部分，则要继续显示下半部分
		goto ShowString;
	}
}

/****************** 在当前位置上显示12*16汉字和8*16字符混合字符串****************
输入参数:
	Page:	 显示起始页
	Col:	 显示起始行
	ValBuf:  显示内容(*ValBuf为字模地址,**ValBuf为字模地址列表)
	Num:	 字符个数
	Flag:    显示方式，NORMAL: 正常 REVERSE: 反显
输出参数:
	无
返回值: 无
********************************************************************************/
void PrintString16(unsigned char Page, unsigned char Col, unsigned char **ValBuf, unsigned char Num, unsigned char Flag)
{
	unsigned char i;
	unsigned char *Ptr = NULL;
	unsigned char flag = 0;
	int num = 0;
	FILE *stream;
	if (lcdpipe == 0)
	{
		memset(buf, 0, 20);
		stream = popen("uname -r", "r");
		if (stream == NULL)
		{
			printf("LCD pipe error\n");
		}
		num = fread(buf, 20, 1, stream);
		if(num == -1)
			printf("fread error");
		pclose(stream);
		lcdpipe = 1;
	}

	if (&ASC16_End > &ASC16_Begin)
	{
		flag = 1;
	}

	if (strncmp(buf, "2.6.9", 5))
	{
		// printf("begin:%x, end:%x\n",&ASC16_Begin,&ASC16_End);
		for (i = 0; i < Num; i++)
		{

			Ptr = ValBuf[i];
			//     printf("addr:%x\n",Ptr);
#if 1
			if (flag)
			{
				if (Ptr <= &ASC16_End && Ptr >= &ASC16_Begin)
				{
					PrintASC16(Page, Col, Ptr, Flag);
					Col += 8;
				}
				else
				{
					PrintHANZI(Page, Col, Ptr, Flag);
					Col += 13;
				}
			}
			else
			{
				if (Ptr >= &ASC16_End && Ptr <= &ASC16_Begin)
				{
					PrintASC16(Page, Col, Ptr, Flag);
					Col += 8;
				}
				else
				{
					PrintHANZI(Page, Col, Ptr, Flag);
					Col += 13;
				}
			}
#else
			if (sizeof(Ptr) != 18)
			{
				PrintASC16(Page, Col, Ptr, Flag);
				Col += 8;
			}
			else
			{
				PrintHANZI(Page, Col, Ptr, Flag);
				Col += 13;
			}
#endif
		}
	}
	else
	{
		for (i = 0; i < Num; i++)
		{
			Ptr = ValBuf[i];
			if (Ptr < &ASC16_Begin && Ptr > &ASC16_End)
			{
				PrintASC16(Page, Col, Ptr, Flag);
				Col += 8;
			}
			else
			{
				PrintHANZI(Page, Col, Ptr, Flag);
				Col += 13;
			}
		}
	}
}

/**************** 在当前位置上显示12*16汉字和8*16字符预定义混合字符串*************
输入参数:
	Page:	 显示起始页
	Col:	 显示起始行
	CodeStr: 显示内容(字符串的地址列表位置)
	Num:	 字符个数,包含要加入的汉字和符号
	Flag:    显示方式，F5-FF:菜单项(FA时反显)
					   A?: 前面加"请输入"
					   C?: 前面加"请选择"
					   1?/2?/3?: 将第三/四或三/四/五个字更改为导入或导出的密钥数 Flag=2:两位 Flag=3:三位
					   CLAIM/COLON: 最后加上!/:
					   NORMAL/REVERSE: 正常显示/反显
输出参数:
	无
返回值: 无
备注: STR_GG的第二/三个字显示QueryCnt的数值
		ruob.lin 修改64位兼容问题，20180326
********************************************************************************/
void PrintFormatStr(unsigned char Page, unsigned char Col, unsigned char **CodeStr, unsigned char Num, unsigned char Flag)
{
	unsigned char i, j, k, Offset = 0;
	i = Flag & 0xF0; // 0&0xf0=>0x0000 0000 & 0x1111 0000
	if (i == 0xF0)	 //如果高半字节为F,表示是菜单项 0xF5-0xFF
	{
		if (Flag == 0xFA)
			Flag = REVERSE; // MenuItem-X=0,选中反显
		else
			Flag = NORMAL; //未选中，正显
	}
	//	memcpy(Buffer+Offset,CodeStr,Num<<2);		//将CODE段中的格式化字串拷到Buffer中
	memcpy(Buffer + Offset, CodeStr, Num << 4); //将CODE段中的格式化字串拷到Buffer中
	if (i == MY_DATE_NUM_1 || i == MY_DATE_NUM_2 || i == MY_DATE_NUM_3 || i == MY_DATE_NUM_4)
	{ // if(ExData!=0)
		if (i == MY_DATE_NUM_1)
			Buffer[2] = ASC16_Num[1];
		else if (i == MY_DATE_NUM_2)
			Buffer[2] = ASC16_Num[2];
		else if (i == MY_DATE_NUM_3)
			Buffer[2] = ASC16_Num[3];
		else if (i == MY_DATE_NUM_4)
			Buffer[2] = ASC16_Num[4];
	}
	if (i == INPUT_OR_OUTPUT_MY_NUM)
	{
		if (INPUT_OR_OUTPUT_KEY_BIT == 2)
		{
			j = ExData / 10;
			if (j != 0)
				Buffer[2] = ASC16_Num[j];
			j = ExData % 10;
			Buffer[3] = ASC16_Num[j];
			ExData = 0;
		}
		else if (INPUT_OR_OUTPUT_KEY_BIT == 3)
		{
			j = ExData / 100;
			if (j != 0)
				Buffer[2] = ASC16_Num[j];
			k = (ExData % 100) / 10;
			if (j != 0 || k != 0)
				Buffer[3] = ASC16_Num[k];
			j = ExData % 10;
			Buffer[4] = ASC16_Num[j];
			ExData = 0;
		}
	}
	PrintString16(Page, Col, (unsigned char **)Buffer, Num, Flag & 0x01);
}

/*******************************菜单光标移动和定位********************************
输入参数:
	CurItem: 当前选择项
	AllItem: 总共可选项数
	Key: 输入键值
输出参数:
	无
返回值: 无
**********************************************************************************/
void SetItemCursor(unsigned int *CurItem, unsigned int AllItem, unsigned char Key)
{
	unsigned char i;
	i = *CurItem;
	if (Key == KEY_UP && i > 1)
	{
		i--;
	}
	if (Key == KEY_DOWN && i < AllItem)
	{
		i++;
	}

	// if(Key==KEY_0&&AllItem>=10) i=10;
	*CurItem = i;
}
/*******************************菜单光标移动方向键********************************
输入参数:
	CurItem: 当前选择项
	AllItem: 总共可选项数
	Key: 输入键值
输出参数:
	无
返回值: 无
**********************************************************************************/
void SetItemCursor_DownAndUp(unsigned int *CurItem, unsigned int AllItem, unsigned char Key)
{
	unsigned char i;
	i = *CurItem;
	if (Key == KEY_UP && i > 1)
		i--;
	if (Key == KEY_DOWN && i < AllItem)
		i++;
	/*if(Key==KEY_1 || Key==KEY_2 ||(Key==KEY_3&&AllItem>=3)
		||(Key==KEY_4&&AllItem>=4)||(Key==KEY_5&&AllItem>=5)
		||(Key==KEY_6&&AllItem>=6)||(Key==KEY_7&&AllItem>=7)
		||(Key==KEY_8&&AllItem>=8)||(Key==KEY_9&&AllItem>=9))i=Key;
	//if(Key==KEY_0&&AllItem>=10) i=10;*/
	*CurItem = i;
}

/********************* 显示一空白行 **********************************
输入参数:
	Line: 行
	Type: 类型 0: 高度8点  1: 高度16点
输出参数:
	无
返回值:  无
*********************************************************************/
void PrintEmptyLine(unsigned char Line, unsigned char Type)
{
	unsigned char k;
	// unsigned char  asc_space[30];
	// memset(asc_space,'\0',30);
	if (Type == 1) // 16*8
	{
		for (k = 17; k != 0; k--)
			Buffer[k - 1] = ASC16_Space;
		PrintString16(Line, 0, Buffer, 17, NORMAL);
	}
	else // 8*6
	{
		for (k = 22; k != 0; k--)
			Buffer[k - 1] = ASC8_Space;
		PrintString8(Line, 0, Buffer, 22, NORMAL);
	}
}
/****************显示固定菜单的前导数字编号,"多位数+点 不够前补0"***********************
输入参数:
	ItemCnt: 菜单项的数量  first_Item: 第一个菜单项的编号
	start_page: 开始放置菜单的页号，place_len： 总长度，前补0
	start_col： 开始放置菜单的行号
输出参数:
	无
返回值:	无
*****************************************************************************/
void DispPrefix(unsigned char ItemCnt, unsigned int first_Item, unsigned char start_page, unsigned char place_len, unsigned char start_col)
{
	unsigned char i, m = 0;
	unsigned int Item[4];
	memset(Item, 0x00, sizeof(int) * 4);
	if (place_len == 2)
	{
		if (ItemCnt >= 1)
			Item[0] = first_Item;
		if (ItemCnt >= 2)
			Item[1] = first_Item + 1;
		if (ItemCnt >= 3)
			Item[2] = first_Item + 2;
		if (ItemCnt == 4)
			Item[3] = first_Item + 3;
		for (i = start_page; i < 8; i += 2, m++)
		{
			if (Item[m] != 0)
			{
				PrintASC16(i, 16 + start_col, ASC16_Dot, NORMAL);
				PrintASC16(i, start_col, ASC16_Num[Item[m] / 10], NORMAL);
				PrintASC16(i, 8 + start_col, ASC16_Num[Item[m] % 10], NORMAL);
			}
		}
	}
	else if (place_len == 3)
	{
		if (ItemCnt >= 1)
			Item[0] = first_Item;
		if (ItemCnt >= 2)
			Item[1] = first_Item + 1;
		if (ItemCnt >= 3)
			Item[2] = first_Item + 2;
		if (ItemCnt == 4)
			Item[3] = first_Item + 3;
		for (i = start_page; i < 8; i += 2, m++)
		{
			if (Item[m] != 0)
			{

				PrintASC16(i, start_col, ASC16_Num[Item[m] / 100], NORMAL);
				PrintASC16(i, 8 + start_col, ASC16_Num[(Item[m] % 100) / 10], NORMAL);
				PrintASC16(i, 16 + start_col, ASC16_Num[Item[m] % 10], NORMAL);
				PrintASC16(i, 24 + start_col, ASC16_Dot, NORMAL);
			}
		}
	}
}
/****************显示固定菜单的前导数字编号,"多位数  不够前补0" ***********************
输入参数:
	ItemCnt: 菜单项的数量  first_Item: 第一个菜单项的编号
	start_page: 开始放置菜单的页号，place_len： 总长度，前补0
	start_col： 开始放置菜单的行号
输出参数:
	无
返回值:	无
*****************************************************************************/
void DispPrefix_NoDot(unsigned char ItemCnt, unsigned int first_Item, unsigned char start_page, unsigned char place_len, unsigned char start_col)
{
	unsigned char i, m = 0;
	unsigned int Item[4];
	memset(Item, 0x00, sizeof(int) * 4);
	if (place_len == 3)
	{
		if (ItemCnt >= 1)
			Item[0] = first_Item;
		if (ItemCnt >= 2)
			Item[1] = first_Item + 1;
		if (ItemCnt >= 3)
			Item[2] = first_Item + 2;
		if (ItemCnt == 4)
			Item[3] = first_Item + 3;
		for (i = start_page; i < 8; i += 2, m++)
		{
			if (Item[m] != 0)
			{

				PrintASC16(i, start_col, ASC16_Num[Item[m] / 100], NORMAL);
				PrintASC16(i, 8 + start_col, ASC16_Num[(Item[m] % 100) / 10], NORMAL);
				PrintASC16(i, 16 + start_col, ASC16_Num[Item[m] % 10], NORMAL);
			}
		}
	}
}
/****************显示固定菜单的前导数字编号,"一或多位数+点"***********************
输入参数:
	ItemCnt: 菜单项的数量  first_Item: 第一个菜单项的编号
	start_page: 开始放置菜单的页号 start_col： 开始放置菜单的行号
输出参数:
	无
返回值:	无
**********************************************************************************/
void DispPrefix_oneormore_col(unsigned int ItemCnt, unsigned int first_Item, unsigned char start_page, unsigned char start_col)
{
	unsigned char Item[4], i, j, k = 0;
	memset(Item, 0x00, 4);
	if ((ItemCnt - 1 + first_Item) <= 9)
	{
		if (ItemCnt >= 1)
			Item[0] = first_Item;
		if (ItemCnt >= 2)
			Item[1] = first_Item + 1;
		if (ItemCnt >= 3)
			Item[2] = first_Item + 2;
		if (ItemCnt == 4)
			Item[3] = first_Item + 3;
		for (i = start_page, k = 0; i < 8; i += 2, k++)
		{
			if (Item[k] != 0)
			{
				PrintASC16(i, 6 + start_col, ASC16_Dot, NORMAL);
				PrintASC16(i, start_col, ASC16_Num[Item[k]], NORMAL);
			}
		}
	}
	else if (first_Item <= 9 && first_Item + ItemCnt - 1 > 9)
	{
		k = 0;
		if (ItemCnt >= 1)
			Item[0] = first_Item;
		if (ItemCnt >= 2)
			Item[1] = first_Item + 1;
		if (ItemCnt >= 3)
			Item[2] = first_Item + 2;
		if (ItemCnt == 4)
			Item[3] = first_Item + 3;
		for (j = start_page; j < start_page + (10 - first_Item) * 2; j += 2)
		{
			if (Item[k] != 0)
			{
				PrintASC16(j, 6 + start_col, ASC16_Dot, NORMAL);
				PrintASC16(j, start_col, ASC16_Num[Item[k++]], NORMAL);
			}
		}
		// m=0;
		for (j = start_page + (10 - first_Item) * 2; j < 8; j += 2)
		{
			if (Item[k] != 0)
			{
				PrintASC16(j, 12 + start_col, ASC16_Dot, NORMAL);
				PrintASC16(j, start_col, ASC16_Num[1], NORMAL);
				PrintASC16(j, 6 + start_col, ASC16_Num[Item[k++] - 10], NORMAL);
			}
		}
	}
}
void DispPrefix_oneormore_col_1(unsigned int ItemCnt, unsigned int first_Item, unsigned char start_page, unsigned char start_col)
{
	unsigned char Item[4], i, j, k = 0;
	memset(Item, 0x00, 4);
	if ((ItemCnt - 1 + first_Item) <= 9)
	{
		if (ItemCnt >= 1)
			Item[0] = first_Item;
		if (ItemCnt >= 2)
			Item[1] = first_Item + 1;
		if (ItemCnt >= 3)
			Item[2] = first_Item + 2;
		if (ItemCnt == 4)
			Item[3] = first_Item + 3;
		for (i = start_page, k = 0; i < 8; i += 2, k++)
		{

			PrintASC16(i, 6 + start_col, ASC16_Dot, NORMAL);
			PrintASC16(i, start_col, ASC16_Num[Item[k]], NORMAL);
		}
	}
	else if (first_Item <= 9 && first_Item + ItemCnt - 1 > 9)
	{
		k = 0;
		if (ItemCnt >= 1)
			Item[0] = first_Item;
		if (ItemCnt >= 2)
			Item[1] = first_Item + 1;
		if (ItemCnt >= 3)
			Item[2] = first_Item + 2;
		if (ItemCnt == 4)
			Item[3] = first_Item + 3;
		for (j = start_page; j < start_page + (10 - first_Item) * 2; j += 2)
		{

			{
				PrintASC16(j, 6 + start_col, ASC16_Dot, NORMAL);
				PrintASC16(j, start_col, ASC16_Num[Item[k++]], NORMAL);
			}
		}
		// m=0;
		for (j = start_page + (10 - first_Item) * 2; j < 8; j += 2)
		{

			{
				PrintASC16(j, 12 + start_col, ASC16_Dot, NORMAL);
				PrintASC16(j, start_col, ASC16_Num[1], NORMAL);
				PrintASC16(j, 6 + start_col, ASC16_Num[Item[k++] - 10], NORMAL);
			}
		}
	}
}
/*else if(first_Item>9 && first_Item+ItemCnt-1<100)
{
			 if(ItemCnt>=1) Item[0]=first_Item;
		  if(ItemCnt>=2) Item[1]=first_Item+1;
		  if(ItemCnt>=3) Item[2]=first_Item+2;
		  if(ItemCnt==4) Item[3]=first_Item+3;
		  for(j=start_page,k=0;j<8;j+=2,k++)
		  {
				  if(Item[k]!=0)
		   {
			 PrintASC16(j,12+start_col,ASC16_Dot,NORMAL);
			 PrintASC16(j,start_col,ASC16_Num[Item[k]/10],NORMAL);
			 PrintASC16(j,6+start_col,ASC16_Num[Item[k]%10],NORMAL);
		   }
	   }
}
else if(first_Item>9 &&  first_Item<100 &&  first_Item+ItemCnt-1>=100)
{
   k=0;
	  if(ItemCnt>=1) Item[0]=first_Item;
   if(ItemCnt>=2) Item[1]=first_Item+1;
   if(ItemCnt>=3) Item[2]=first_Item+2;
   if(ItemCnt==4) Item[3]=first_Item+3;
   for(j=start_page;j<start_page+(100-first_Item)*2;j+=2)
   {
	  if(Item[k]!=0)
	  {
			 PrintASC16(j,12+start_col,ASC16_Dot,NORMAL);
			 PrintASC16(j,start_col,ASC16_Num[Item[k]/10],NORMAL);
			 PrintASC16(j,6+start_col,ASC16_Num[Item[k]%10],NORMAL);
	  }
   }
   //m=0;
   for(j=start_page+(100-first_Item)*2;j<8;j+=2)
   {
	  if(Item[k]!=0)
	  {
			 PrintASC16(j,18+start_col,ASC16_Dot,NORMAL);
			 PrintASC16(j,start_col,ASC16_Num[Item[k]/100],NORMAL);
			 PrintASC16(j,6+start_col,ASC16_Num[(Item[k]%100)/10],NORMAL);
			 PrintASC16(j,12+start_col,ASC16_Num[Item[k]%10],NORMAL);
	  }
   }
}
else if(first_Item>=100 && first_Item+ItemCnt-1>=100 && first_Item+ItemCnt-1<1000)
{
		  //k=0;
		  if(ItemCnt>=1) Item[0]=first_Item;
	   if(ItemCnt>=2) Item[1]=first_Item+1;
	   if(ItemCnt>=3) Item[2]=first_Item+2;
	   if(ItemCnt==4) Item[3]=first_Item+3;
	   for(j=start_page,k=0;j<8;j+=2,k++)
	   {
				  if(Item[k]!=0)
		   {
			 PrintASC16(j,18+start_col,ASC16_Dot,NORMAL);
			 PrintASC16(j,start_col,ASC16_Num[Item[k]/100],NORMAL);
			 PrintASC16(j,6+start_col,ASC16_Num[(Item[k]%100)/10],NORMAL);
			 PrintASC16(j,12+start_col,ASC16_Num[Item[k]%10],NORMAL);
		   }
	}
}
else if(first_Item>=100 &&  first_Item<1000 &&  first_Item+ItemCnt-1>=1000)
{
   k=0;
	  if(ItemCnt>=1) Item[0]=first_Item;
   if(ItemCnt>=2) Item[1]=first_Item+1;
   if(ItemCnt>=3) Item[2]=first_Item+2;
   if(ItemCnt==4) Item[3]=first_Item+3;
   for(j=start_page;j<start_page+(1000-first_Item)*2;j+=2)
   {
	  if(Item[k]!=0)
	  {
			 PrintASC16(j,18+start_col,ASC16_Dot,NORMAL);
			 PrintASC16(j,start_col,ASC16_Num[Item[k]/100],NORMAL);
			 PrintASC16(j,6+start_col,ASC16_Num[(Item[k]%100)/10],NORMAL);
			 PrintASC16(j,12+start_col,ASC16_Num[Item[k]%10],NORMAL);
	  }
   }
   //m=0;
   for(j=start_page+(1000-first_Item)*2;j<8;j+=2)
   {
	  if(Item[k]!=0)
	  {
			 PrintASC16(j,24+start_col,ASC16_Dot,NORMAL);
			 PrintASC16(j,start_col,ASC16_Num[Item[k]/1000],NORMAL);
			 PrintASC16(j,6+start_col,ASC16_Num[(Item[k]%1000)/100],NORMAL);
			 PrintASC16(j,12+start_col,ASC16_Num[((Item[k]%1000)%100)/10],NORMAL);
			 PrintASC16(j,18+start_col,ASC16_Num[Item[k]%10],NORMAL);
	  }
   }
}
else if(first_Item>=1000 && first_Item+ItemCnt-1>=1000 && first_Item+ItemCnt-1<10000)
{
		  //k=0;
		  if(ItemCnt>=1) Item[0]=first_Item;
	   if(ItemCnt>=2) Item[1]=first_Item+1;
	   if(ItemCnt>=3) Item[2]=first_Item+2;
	   if(ItemCnt==4) Item[3]=first_Item+3;
	   for(j=start_page,k=0;j<8;j+=2,k++)
	   {
		   if(Item[k]!=0)
		   {
			 PrintASC16(j,24+start_col,ASC16_Dot,NORMAL);
			 PrintASC16(j,start_col,ASC16_Num[Item[k]/1000],NORMAL);
			 PrintASC16(j,6+start_col,ASC16_Num[(Item[k]%1000)/100],NORMAL);
			 PrintASC16(j,12+start_col,ASC16_Num[((Item[k]%1000)%100)/10],NORMAL);
			 PrintASC16(j,18+start_col,ASC16_Num[Item[k]%10],NORMAL);
		   }
	}
}*/

/*************** 退到上级菜单，根据当前的Function,设置MenuItem和Frame的值 ************
输入参数:
	Function: 当前处理的功能号
输出参数:
	Frame: 窗口号
	MenuItem: 菜单项号
*************************************************************************************/
void ExitToMenu()
{
	Frame = EXIT_Frame;
	EXIT_Frame = 0;
	MenuItem = MenuItem_num;
	MenuItem_num = 0;
	// printf("MenuItem is %d and Frame is %d\n", MenuItem, Frame);
	/* add by mukesong for key flag  (begin)*/
	LEDSTATE &= 0xFB;
	/* add by mukesong for key flag  (end)*/
}
/************** 6*8数字串的格式化单行上下居中显示********************************
输入参数:
	Page:  行
	Col:   列
	Value: ASC-'0'格式的数据
	Len:   显示定长，偶数，最长22
	Flag:  显示格式标志 0: 正常，不足补空格  1：正常，不足补下划线  2:星号，不足补下划线
输出参数:
	无
返回值:无
********************************************************************************/
void DispDigits(unsigned char Page, unsigned char Col, unsigned char *Value, unsigned char Len, unsigned char Flag)
{
	unsigned char i;
	for (i = 0; i < Len; i++)
	{
		if (Value[i] == 0x18) // 0x18当前缓冲区空标志
		{
			if (Flag == 0)
				Buffer[i] = ASC8_Space;
			else
				Buffer[i] = ASC8_Line;
		}
		else
		{
			if (Flag == 2)
				Buffer[i] = ASC8_Star;
			else
				Buffer[i] = ASC8_Num[Value[i]];
		}
	}
	PrintString8(Page, Col, Buffer, Len, NORMAL | CENTER);
}

void DispDigits2(unsigned char Page, unsigned char Col, unsigned char *Value, unsigned char Len)
{
	unsigned char i;
	for (i = 0; i < Len; i++)
	{
		if (Value[i] == 0x18) // 0x18当前缓冲区空标志
		{
			Buffer[i] = ASC8_Line;
		}
		else
		{
			Buffer[i] = ASC8_Num[Value[i]];
		}
	}
	PrintString8(Page, Col, Buffer, Len, NORMAL | CENTER);
}

/************** 6*8数字串的格式化单行上下居中显示********************************
输入参数:
	Page:  行
	Col:   列
	Value: ASC-'0'格式的数据
	Len:   显示定长，偶数，最长22
	Flag:  显示格式标志 0: 正常，不足补空格  1：正常，不足补下划线  2:星号，不足补下划线
输出参数:
	无
返回值:无
********************************************************************************/
void DispVersion(unsigned char Page, unsigned char Col, unsigned char *Value, unsigned char Len, unsigned char Flag)
{
	unsigned char i, j = 0; /*FIXME*/
	if (Flag == 0)
	{
		for (i = 0; i < Len; i++)
		{
			if (i % 4 == 0)
				Buffer[i] = ASC8_Space;
			else
			{
				// printf("\n");
				Buffer[i] = ASC8_Num[Value[j]];
				j++;
			}
		}
	}
	else if (Flag == 1)
	{
		Buffer[0] = ASC8_Num[Value[0]];
		Buffer[1] = ASC8_Dot;
		Buffer[2] = ASC8_Num[Value[1]];
		Buffer[3] = ASC8_Num[Value[2]];
	}

	PrintString8(Page, Col, Buffer, Len, NORMAL | CENTER);
}
/**************************显示个人密钥是否启用********************************************
输入参数：  1 page 2 col  3 FLAG :1 启用 0 未启用 4  REVERSE_FLAG:  0 NORMAL 1 REVERSE
输出参数：  无
返回：
*******************************************************************************/
void DISP_TURN_ON_FLAG(unsigned char page, unsigned char col, unsigned char *FLAG, unsigned char REVERSE_Flag)
{
	if (FLAG[0] == 1)
		PrintASC16(page, col, ASC16_Star, REVERSE_Flag);
	else
		PrintASC16(page, col, ASC16_Space, REVERSE_Flag);
}
/************** 6*8数字串的格式化单行上下居中显示********************************
输入参数:
	Page:  行
	Col:   列
	Value: ASC-'0'格式的数据
	Len:   显示定长，偶数，最长22
	Flag:  显示格式标志 0: 正常，不足补空格  1：正常，不足补下划线  2:星号，不足补下划线
	REVERSE_FLAG:  0 NORMAL 1 REVERSE
输出参数:
	无
返回值:无
********************************************************************************/
void DispDigits_Reverse(unsigned char Page, unsigned char Col, unsigned char *Value, unsigned char Len, unsigned char Flag, unsigned char REVERSE_FLAG)
{
	unsigned char i;
	for (i = 0; i < Len; i++)
	{
		if (Value[i] == 0x18)
		{
			if (Flag == 0)
				Buffer[i] = ASC8_Space;
			else
				Buffer[i] = ASC8_Line;
		}
		else
		{
			if (Flag == 2)
				Buffer[i] = ASC8_Star;
			else
				Buffer[i] = ASC8_Num[Value[i]];
		}
	}
	PrintString8(Page, Col, Buffer, Len, REVERSE_FLAG | CENTER);
}
/************** 日志大小8*16格式化单行上下居中显示********************************
输入参数:
	Page:  行
	Col:   列
	Value: 高、低两字节

输出参数:
	无
返回值:无
********************************************************************************/
void Disp_LogSize(unsigned char Page, unsigned char Col, unsigned char *Value)
{
	unsigned char i, log[4];
	unsigned int j;
	memset(log, '\0', 4);
	i = Value[0];
	j = Value[1] * 256 + Value[2];
	log[0] = j / 1000;
	log[1] = (j % 1000) / 100;
	log[2] = ((j % 1000) % 100) / 10;
	log[3] = j % 10;
	if (log[0] != 0)
		Buffer[0] = ASC16_Num[log[0]];
	else
		Buffer[0] = ASC16_Space;
	if (log[1] != 0 || log[0] != 0)
		Buffer[1] = ASC16_Num[log[1]];
	else
		Buffer[1] = ASC16_Space;
	if (log[1] != 0 || log[0] != 0 || log[2] != 0)
		Buffer[2] = ASC16_Num[log[2]];
	else
		Buffer[2] = ASC16_Space;
	Buffer[3] = ASC16_Num[log[3]];
	switch (i)
	{
	case UNIT_T:
		Buffer[4] = ASC16_TChar;
		break;
	case UNIT_G:
		Buffer[4] = ASC16_G_Char;
		break;
	case UNIT_M:
		Buffer[4] = ASC16_M_Char;
		break;
	case UNIT_K:
		Buffer[4] = ASC16_K_Char;
		break;
	default:
		Buffer[4] = ASC16_Space;
		break;
	}
	Buffer[5] = ASC16_B_Char;
	PrintString16(Page, Col, Buffer, 6, NORMAL);
}
/************** 同步失败序号8*16格式化单行上下居中显示********************************
输入参数:
	Page:  行
	Col:   列
	Value: 根据协议

输出参数:
	无
返回值:无
********************************************************************************/
void Disp_num_failure(unsigned char Page, unsigned char Col, unsigned char *Value)
{
	unsigned char i;
	for (i = 0; i < Value[0]; i++)
	{
		Buffer[i] = ASC16_Num[Value[i + 1]];
	}
	if (Value[0] <= 5)
		PrintString16(Page, Col, Buffer, Value[0], NORMAL);
	else
	{
		PrintString16(Page, Col, Buffer, 5, NORMAL);
		PrintString16(Page + 2, Col, Buffer + 5, Value[0] - 5, NORMAL);
	}
}
/************** 将BCD字符串展开为BIN字符串**************************************
输入参数:
	BCDBuf: BCD字符串
	BCDLen: BCD字符串的长度
输出参数:
	BINBuf: BIN字符串(即ASC码-'0')
返回值:	无
********************************************************************************/
void BCDToBIN(unsigned char *BCDBuf, unsigned char BCDLen, unsigned char *BINBuf)
{
	unsigned char i, j;
	for (i = BCDLen; i != 0; i--)
	{
		j = BCDBuf[i - 1];
		BINBuf[i * 2 - 1] = j & 0x0F;
		BINBuf[i * 2 - 2] = j >> 4;
	}
}
/************** 将ASC字符串展开为BIN字符串**************************************
输入参数:
	ASCBuf: ASC字符串
	ASCLen: ASC字符串的长度
输出参数:
	BINBuf: BIN字符串(即ASC码-'0')
返回值:	无
********************************************************************************/
void ASCToBIN(unsigned char *ASCBuf, unsigned char ASCLen, unsigned char *BINBuf)
{
	unsigned char i;
	for (i = 0; i <= ASCLen; i++)
	{
		BINBuf[i] = ASCBuf[i] - 0x30;
	}
}
/************** 将BIN字符串转变为ASC字符串**************************************
输入参数:
	BINBuf: BIN字符串
	BINLen: BIN字符串的长度
输出参数:
	ASCBuf: ASC字符串(即BIN码+'0')
返回值:	无
********************************************************************************/
void BINToASC(unsigned char *BINBuf, unsigned char BINLen, unsigned char *ASCBuf)
{
	unsigned char i;
	for (i = 0; i <= BINLen; i++)
	{
		ASCBuf[i] = BINBuf[i] + 0x30;
	}
}
/************** 将BIN字符串展开为BCD字符串**************************************
输入参数:
	BINBuf: BIN字符串(即ASC码-'0')
	BINLen: BIN字符串的长度
输出参数:
	BCDBuf: BCD字符串
返回值:	无
********************************************************************************/
void BINToBCD(unsigned char *BINBuf, unsigned char BINLen, unsigned char *BCDBuf)
{
	unsigned char i, j, k, m;
	for (i = 0, j = 0; i < BINLen; i += 2)
	{
		k = BINBuf[i] << 4;
		m = BINBuf[i + 1];
		BCDBuf[j++] = k + m;
		// BCDBuf[j++]=BINBuf[i]<<4+BINBuf[i+1];
	}
}
/********************* 根据当前选中项刷新输入箭头光标 ********************
输入参数:
   CurSel: 当前选中项
   AllSel: 总共可选项
   first_page: 放置光标的第一页
   second_page:放置光标的第二页
输出参数:
	无
返回值:	无
*************************************************************************/
void RefreshArrowPos(unsigned char CurSel, unsigned char AllSel, unsigned char first_page, unsigned char second_page)
{

	if (AllSel == 2)
	{
		if (CurSel == 1)
		{
			PrintASC16(first_page, 119, ASC16_Arrow, NORMAL);
			PrintASC16(second_page, 119, ASC16_Space, NORMAL);
		}
		else
		{
			PrintASC16(first_page, 119, ASC16_Space, NORMAL);
			PrintASC16(second_page, 119, ASC16_Arrow, NORMAL);
		}
	}
	else if (AllSel == 3)
	{
		if (CurSel == 1)
		{
			PrintASC16(first_page, 119, ASC16_Arrow, NORMAL);
			PrintASC16(first_page + 2, 119, ASC16_Space, NORMAL);
			PrintASC16(first_page + 4, 119, ASC16_Space, NORMAL);
		}
		else if (CurSel == 2)
		{
			PrintASC16(first_page, 119, ASC16_Space, NORMAL);
			PrintASC16(first_page + 2, 119, ASC16_Arrow, NORMAL);
			PrintASC16(first_page + 4, 119, ASC16_Space, NORMAL);
		}
		else
		{
			PrintASC16(first_page, 119, ASC16_Space, NORMAL);
			PrintASC16(first_page + 2, 119, ASC16_Space, NORMAL);
			PrintASC16(first_page + 4, 119, ASC16_Arrow, NORMAL);
		}
	}
	else if (AllSel == 4)
	{
		if (CurSel == 1)
		{
			PrintASC16(first_page, 119, ASC16_Arrow, NORMAL);
			PrintASC16(first_page + 2, 119, ASC16_Space, NORMAL);
			PrintASC16(first_page + 4, 119, ASC16_Space, NORMAL);
			PrintASC16(first_page + 6, 119, ASC16_Space, NORMAL);
		}
		else if (CurSel == 2)
		{
			PrintASC16(first_page, 119, ASC16_Space, NORMAL);
			PrintASC16(first_page + 2, 119, ASC16_Arrow, NORMAL);
			PrintASC16(first_page + 4, 119, ASC16_Space, NORMAL);
			PrintASC16(first_page + 6, 119, ASC16_Space, NORMAL);
		}
		else if (CurSel == 3)
		{
			PrintASC16(first_page, 119, ASC16_Space, NORMAL);
			PrintASC16(first_page + 2, 119, ASC16_Space, NORMAL);
			PrintASC16(first_page + 4, 119, ASC16_Arrow, NORMAL);
			PrintASC16(first_page + 6, 119, ASC16_Space, NORMAL);
		}
		else
		{
			PrintASC16(first_page, 119, ASC16_Space, NORMAL);
			PrintASC16(first_page + 2, 119, ASC16_Space, NORMAL);
			PrintASC16(first_page + 4, 119, ASC16_Space, NORMAL);
			PrintASC16(first_page + 6, 119, ASC16_Arrow, NORMAL);
		}
	}
}
/************** 将键入数压入键盘缓冲区（BCD）**************************************
输入参数:
	ValBuf: 键盘缓冲区
	BufLen: 缓冲区长度
	CurLen: 当前输入内容长度
	Key: 键入值
输出参数:
	ValBuf: 键盘缓冲区
	CurLen: 当前输入内容长度
返回值: 无
********************************************************************************/
void AddIntoBuf(unsigned char *ValBuf, unsigned char BufLen, unsigned char *CurLen, unsigned char Key)
{
	unsigned char i;
	if ((*CurLen) < BufLen)
	{
		for (i = 0; i < BufLen - 1; i++)
			ValBuf[i] = ValBuf[i + 1];
		ValBuf[i] = Key;

		(*CurLen)++;
	}
}
/************** 从键盘缓冲区（BCD）中删除最后一个键入值**************************************
输入参数:
	ValBuf: 键盘缓冲区
	BufLen: 缓冲区长度
	CurLen: 当前输入内容长度
输出参数:
	ValBuf: 键盘缓冲区
	CurLen: 当前输入内容长度
返回值: 无
********************************************************************************/
void DelFromBuf(unsigned char *ValBuf, unsigned char BufLen, unsigned char *CurLen)
{
	unsigned char i;
	if ((*CurLen) > 0)
	{
		for (i = BufLen - 1; i > 0; i--)
			ValBuf[i] = ValBuf[i - 1];
		ValBuf[0] = 0x18; // 0x18当前缓冲区空标志
		(*CurLen)--;
	}
}
/**************************显示错误号********************************************
输入参数：  Buf[0]
输出参数：  无
返回：无
*******************************************************************************/
void Disp_error_no(void)
{

	unsigned char first_num, second_num;
	first_num = (Buf[1] & 0xF0) >> 4;
	second_num = Buf[1] & 0x0F;
	PrintASC16(4, 56, ASC16_Num[0], NORMAL);
	PrintASC16(4, 64, ASC16_xChar, NORMAL);
	if (first_num < 10)
		PrintASC16(4, 72, ASC16_Num[first_num], NORMAL);
	else if (first_num == 10)
		PrintASC16(4, 72, ASC16_A_Char, NORMAL);
	else if (first_num == 11)
		PrintASC16(4, 72, ASC16_B_Char, NORMAL);
	else if (first_num == 12)
		PrintASC16(4, 72, ASC16_CChar, NORMAL);
	else if (first_num == 13)
		PrintASC16(4, 72, ASC16_D_Char, NORMAL);
	else if (first_num == 14)
		PrintASC16(4, 72, ASC16_E_Char, NORMAL);
	else if (first_num == 15)
		PrintASC16(4, 72, ASC16_F_Char, NORMAL);
	if (second_num < 10)
		PrintASC16(4, 80, ASC16_Num[second_num], NORMAL);
	else if (second_num == 10)
		PrintASC16(4, 80, ASC16_A_Char, NORMAL);
	else if (second_num == 11)
		PrintASC16(4, 80, ASC16_B_Char, NORMAL);
	else if (second_num == 12)
		PrintASC16(4, 80, ASC16_CChar, NORMAL);
	else if (second_num == 13)
		PrintASC16(4, 80, ASC16_D_Char, NORMAL);
	else if (second_num == 14)
		PrintASC16(4, 80, ASC16_E_Char, NORMAL);
	else if (second_num == 15)
		PrintASC16(4, 80, ASC16_F_Char, NORMAL);
	PrintASC16(4, 88, ASC16_Claim, NORMAL);
}
/**************************显示数字********************************************
输入参数：  Buf[0],page 页，col 列
输出参数：  无
返回：无
*******************************************************************************/
void Disp_digit_number(unsigned char *addr, unsigned char disp_len, unsigned char page, unsigned char col)
{
	unsigned char len, i, left, right, j = col;
	len = disp_len;
	for (i = len - 1; i >= 1; i--)
	{
		left = *(addr + i) & 0x0F;
		right = (*(addr + i) & 0xF0) >> 4;
		if (len == 1 && !right)
		{
			PrintASC16(page, j, ASC16_Num[left], NORMAL);
		}
		else
		{
			PrintASC16(page, j, ASC16_Num[left], NORMAL);
			PrintASC16(page, j - 8, ASC16_Num[right], NORMAL);
			j -= 16;
		}
	}
	left = *(addr + i) & 0x0F;
	right = (*(addr + i) & 0xF0) >> 4;
	if (len == 1 && !right)
	{
		PrintASC16(page, j, ASC16_Num[left], NORMAL);
	}
	else if (!right)
	{
		PrintASC16(page, j, ASC16_Num[left], NORMAL);
		j -= 8;
	}
	else
	{
		PrintASC16(page, j, ASC16_Num[left], NORMAL);
		PrintASC16(page, j - 8, ASC16_Num[right], NORMAL);
		j -= 16;
	}
}
/**************************判断IP地址格式是否正确********************************************
输入参数：  1、IP_value  2、FLAG 0:IP、网关和域名 1：掩码
输出参数：  无
返回：格式正确 1  格式错误 0
*******************************************************************************/
unsigned char Check_IP_Result(unsigned char *IP_value, unsigned char FLAG)
{
	unsigned char j;
	for (j = 0; j < 12; j += 3) //中间6位0~255
	{
		if (IP_value[j] > 2)
			return 0;
		else if (IP_value[j] == 2)
		{
			if (IP_value[j + 1] > 5)
				return 0;
			else if (IP_value[j + 1] == 5)
			{
				if (IP_value[j + 2] > 5)
					return 0;
			}
		}
	}
#if 0  /* delete it by mukesong 2011-01-19 (begin) */

    if(!FLAG)
   {
       if(((!IP_value[0] && !IP_value[1] && !IP_value[2]) || (!IP_value[9] && !IP_value[10] && !IP_value[11]))==1) return 0;  //前3位和后3位非0

	     if(IP_value[0]>2)//前3位不大于223
	        return 0;
	     else if(IP_value[0]==2)
	     {
	         if(IP_value[1]>2)
	            return 0;
	         else if(IP_value[1]==2)
	         {
	            if(IP_value[2]>3)
	               return 0;
	         }
         }
	     if(IP_value[9]>2)//后3位不大于254
	        return 0;
	     else if(IP_value[9]==2)
	     {
	         if(IP_value[10]>5)
	            return 0;
	         else if(IP_value[10]==5)
	         {
	            if(IP_value[11]>4)
	               return 0;
	         }
         }
   }
   else
   {
       if((IP_value[0]!=2) || (IP_value[1]!=5) ||(IP_value[2]!=5))  return 0;//前3位为255
       if((!IP_value[9] && !IP_value[10] && !IP_value[11])!=1)  return 0;//最后3位为0
   }
#endif /* delete the code by mukesong 2011-01-19 (end) */
	return 1;
}
/**************************显示1行IP地址********************************************
输入参数：  1 page 2 col  3 IP_addr 4  FLAG
输出参数：  无
返回：
*******************************************************************************/
void Disp_IP_ADDR(unsigned char page, unsigned char col, unsigned char *IP_addr, unsigned char FLAG, unsigned char REVERSE_Flag)
{
	Buffer[5] = ASC8_Dot;
	DispDigits_Reverse(page, col, IP_addr, 3, FLAG, REVERSE_Flag);
	PrintString8(page, col + 18, Buffer + 5, 1, REVERSE_Flag | CENTER);
	DispDigits_Reverse(page, col + 24, IP_addr + 3, 3, FLAG, REVERSE_Flag);
	PrintString8(page, col + 42, Buffer + 5, 1, REVERSE_Flag | CENTER);
	DispDigits_Reverse(page, col + 48, IP_addr + 6, 3, FLAG, REVERSE_Flag);
	PrintString8(page, col + 66, Buffer + 5, 1, REVERSE_Flag | CENTER);
	DispDigits_Reverse(page, col + 72, IP_addr + 9, 3, FLAG, REVERSE_Flag);
}
/**************************显示IP地址是否同步********************************************
输入参数：  1 page 2 col  3 FLAG :1 同步 0 不同步 4  REVERSE_FLAG:  0 NORMAL 1 REVERSE
输出参数：  无
返回：
*******************************************************************************/
void DISP_SYNC_FLAG(unsigned char page, unsigned char col, unsigned char *FLAG, unsigned char REVERSE_Flag)
{
	if (FLAG[0] == 0x01)
		/*[是]*/
		PrintFormatStr(page, col, STR_JLGZRZS + 9, 1, REVERSE_Flag);
	else
		/*[否]*/
		PrintFormatStr(page, col, STR_JLGZRZF + 9, 1, REVERSE_Flag);
}
/**************************显示系统日期********************************************
输入参数：  1 page 2 col  3 Date 4  FLAG 5 REVERSE_Flag
输出参数：  无
返回：
*******************************************************************************/
void Display_Date(unsigned char page, unsigned char col, unsigned char *Date, unsigned char FLAG, unsigned char REVERSE_Flag)
{
	Buffer[5] = ASC8_Bias;
	DispDigits_Reverse(page, col, Date, 4, FLAG, REVERSE_Flag);
	PrintString8(page, col + 25, Buffer + 5, 1, REVERSE_Flag | CENTER);
	DispDigits_Reverse(page, col + 32, Date + 4, 2, FLAG, REVERSE_Flag);
	PrintString8(page, col + 45, Buffer + 5, 1, REVERSE_Flag | CENTER);
	DispDigits_Reverse(page, col + 52, Date + 6, 2, FLAG, REVERSE_Flag);
	// PrintString8(page,col+60,Buffer+5,1,REVERSE_Flag|CENTER);
}
/**************************显示系统时间********************************************
输入参数：  1 page 2 col  3 Time 4  FLAG 5 REVERSE_Flag
输出参数：  无
返回：
*******************************************************************************/
void Display_Time(unsigned char page, unsigned char col, unsigned char *Time, unsigned char FLAG, unsigned char REVERSE_Flag)
{
	Buffer[5] = ASC8_Colon;
	DispDigits_Reverse(page, col, Time, 2, FLAG, REVERSE_Flag);
	PrintString8(page, col + 12, Buffer + 5, 1, REVERSE_Flag | CENTER);
	DispDigits_Reverse(page, col + 18, Time + 2, 2, FLAG, REVERSE_Flag);
}
/**************************判断时间格式是否正确********************************************
输入参数：  time_value
输出参数：  无
返回：   1 格式正确  0  格式错误
*******************************************************************************/
unsigned char Right_Or_Error_HourAndMinute(unsigned char *time_value)
{
	unsigned char hour, minute;
	hour = time_value[0] * 10 + time_value[1];
	minute = time_value[2] * 10 + time_value[3];
	if (hour <= 23 && minute <= 59)
		return 1;
	else
		return 0;
}
/**************************判断日期格式是否正确********************************************
输入参数：  time_value
输出参数：  无
返回：   1 格式正确  0  格式错误
*******************************************************************************/
unsigned char Right_Or_Error_Time(unsigned char *time_value)
{
	unsigned char month, day;
	unsigned int year;
	year = 2000 + time_value[0] * 10 + time_value[1];
	month = time_value[2] * 10 + time_value[3];
	day = time_value[4] * 10 + time_value[5];
	// printf("the year is %d the month is %d the day is %d\n", year, month, day);

	if (month >= 1 && month <= 12)
	{
		if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12)
		{
			if (day > 31)
			{
				return 0;
			}
		}
		else if (month == 2)
		{
			if (year % 4 == 0)
			{
				if (day > 29)
				{
					return 0;
				}
			}
			else
			{
				if (day > 28)
				{
					return 0;
				}
			}
		}
		else
		{
			if (day > 30)
			{
				return 0;
			}
		}
		return 1;
	}
	else
	{
		return 0;
	}
}

/**************************判断8位长度日期格式是否正确********************************************
输入参数：  time_value
输出参数：  无
返回：   1 格式正确  0  格式错误
*******************************************************************************/
unsigned char Right_Or_Error_LongTime(unsigned char *time_value)
{
	unsigned char month, day;
	unsigned int year;
	year = time_value[0] * 1000 + time_value[1] * 100 + time_value[2] * 10 + time_value[3];
	month = time_value[4] * 10 + time_value[5];
	day = time_value[6] * 10 + time_value[7];
	// printf("the year is %d the month is %d the day is %d\n", year, month, day);

	if (month >= 1 && month <= 12)
	{
		if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12)
		{
			if (day > 31)
			{
				return 0;
			}
		}
		else if (month == 2)
		{
			if (year % 4 == 0)
			{
				if (day > 29)
				{
					return 0;
				}
			}
			else
			{
				if (day > 28)
				{
					return 0;
				}
			}
		}
		else
		{
			if (day > 30)
			{
				return 0;
			}
		}
		return 1;
	}
	else
	{
		return 0;
	}
}

/*************************请求发送后接收信息错误处理********************************************
输入参数：  len 接收到的数据长度
输出参数：  无
返回：   无
*******************************************************************************/
void Rev_Error_dealwith(int len)
{
	if (len == -R_NO_RESPONSE)
		Buf[1] = R_NO_RESPONSE; //无应答
	else if (len == -R_TX_ERR)
		Buf[1] = R_TX_ERR; // STX或ETX错误
	else if (len == -R_LRC_ERR)
		Buf[1] = R_LRC_ERR; // LRC错误
	else if (len == -R_LEN_ERR)
		Buf[1] = R_LEN_ERR; // LEN错误
							// else if(len==-R_ERROR)  //接收数据错误，直接放在Buf[1]中
}