/********************************************************************
版权所有：	
文件版本： V1.00
文件名称： PDAComm.c
生成日期： 2008年10月9日
作    者：
使用范围：

功    能：与面板通信处理程序
更新信息：
更新日志1：
修改者:
修改日期:
修改内容:
修改原因:
*********************************************************************/


#include  "head.h"
//#include "hzk.h"						

PDA_DEF g_tPDA; // PDA数据与面板通信的结构定义
PDA_COMM g_tUartPDA;  // 与PDA通信的串口数据结构定义
struct PDA_Log g_PDA_Log = {0};

float 	g_arrPDASetBuf[MAX_SET_NUMBER];

const PDA_Record g_PDA_Record[]=
{
	{"PDA遥控合闸"},
	{"PDA遥控分闸"},
	{"定值整定成功"},
	{"定值整定失败"},
	{"内部定值成功"},
	{"内部定值失败"},
	{"参数整定成功"},
	{"参数整定失败"},
	{"信号复归"},
	{"系统重启"},
};

typedef union FLOAT_TT
{
	float ff;
	BYTE tt[4];
}FLOAT_TT;

static void _pda_comm_app(void);
static void _pda_auto_app(void);
static void _pda_record_opelog(BYTE code,int i);
static void _pda_get_event_show(EVENT_SHOW *pe,bool bPDA);
int PDA_TransFile(PDA_COMM *pt,unsigned char *buf);

/******************************************************************************
函数名称：	PDA_Comm_Init
函数版本：	01.01
创建作者：	
创建日期：	2015-04-16
函数说明：	pda初始化
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
void PDA_Comm_Init(void)
{
	memset((BYTE *)&g_tPDA,0,sizeof(g_tPDA));
}

/******************************************************************************
函数名称：	PDA_Board_Recv
函数版本：	01.01
创建作者：	
创建日期：	2015-04-16
函数说明：	pda接收数据
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
void PDA_Board_Recv(int len,BYTE *para)	
{
	PDA_COMM *pt = &g_tUartPDA;

	memcpy(pt->r_buf[pt->r_head], para, len);

	pt->r_head = (pt->r_head + 1) & (UART_FRAME_MAXCNT - 1);	
}

/******************************************************************************
函数名称：	PDA_app
函数版本：	01.01
创建作者：	
创建日期：	2015-04-16
函数说明：	pda应用
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
void PDA_app(void)
{
	if(g_tUartPDA.r_head != g_tUartPDA.r_tail)
	{
		_pda_comm_app();	
		g_tUartPDA.r_tail = (g_tUartPDA.r_tail + 1) & (UART_FRAME_MAXCNT - 1);
	}
	
	_pda_auto_app();

	if(g_tUartPDA.s_head != g_tUartPDA.s_tail)
	{
		// 将报文加入发送队列
		Add_Uart_Frame(PDA_BOARD, (int)g_tUartPDA.s_buf[g_tUartPDA.s_tail][1] + 6, g_tUartPDA.s_buf[g_tUartPDA.s_tail]);
		g_tUartPDA.s_tail = (g_tUartPDA.s_tail + 1) & (UART_FRAME_MAXCNT - 1);
	}
}
/******************************************************************************
函数名称：	_pda_data_echo
函数版本：	01.01
创建作者：	
创建日期：	2015-04-16
函数说明：	pda组帧发送
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
void pda_data_echo(BYTE cmd,BYTE sum,BYTE *para)
{
	PDA_COMM *pt = &g_tUartPDA;
	BYTE i;
	BYTE srcbuf[UART_FRAME_LEN];
	BYTE *pd=srcbuf;

	*pd++ = (BYTE)(tRunPara.byAddr>>8);		
	*pd++ = (BYTE)tRunPara.byAddr;
	*pd++ = cmd;

	for(i=0;i<sum;i++)
	{
		*pd++=para[i];
	}
	// 组包
	(void)protocol_packet(srcbuf, (int)sum+3,  MAIN_BOARD, PDA_BOARD, pt->s_buf[pt->s_head]);	
	// 发送队列调整
	pt->s_head = (pt->s_head + 1) & (UART_FRAME_MAXCNT - 1);
}

/******************************************************************************
函数名称：	_pda_comm_app
函数版本：	01.01
创建作者：	
创建日期：	2015-04-16
函数说明：	主函数调用与面板通信任务,10ms调用1次，100ms左右调用一次刷屏命令
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static void _pda_comm_app(void) 
{
	PDA_COMM *pt=&g_tUartPDA;
	PDA_DEF *pda=&g_tPDA;
	BYTE *pd;	
	DWORD password;

	// 有新的报文,取出新报文,调整报文序列
	pd=&pt->r_buf[pt->r_tail][4];

	// 校验报文是否发给本装置,或广播包
	if((pd[0]<<8|pd[1])!=tRunPara.byAddr && (pd[0]<<8|pd[1])!=0xffff)return; 

	switch(pd[2])
	{		
		case 0x61:		//搜索设备
		{
			if((pd[0]<<8|pd[1])==0xffff)
			{
				rt_printf("收到PDA广播信号...\r\n");
				pda->bSearch=true;
				memset(g_PDA_Log.pda_id_buf,0,sizeof(g_PDA_Log.pda_id_buf));
				memcpy(g_PDA_Log.pda_id_buf,pd+4,8);
				pda->dEchoT=dTCounter+(BYTE)tRunPara.byAddr*3*T_5ms;  //等待应答时间
			}			
		}	
		break;
		
		case 0x62:		//获取设备信息
		break;
		
		case 0x63:		//定值修改
		{
			if(pd[3]==0x01)  // 得到定值条目个数
			{
				pt->arrAppBuf[0]=0x01;
				pt->arrAppBuf[1]=pd[4];
				switch(pd[4])
				{
					case SET_CLASS_OUTSIDE:
					//	pt->arrAppBuf[2]=SET_NUMBER;
						pt->arrAppBuf[2]=SW_SET_NUMBER;
						break;
					case SET_CLASS_INSIDE:
						pt->arrAppBuf[2]=CSTSET_NUMBER;
						break;
					case SET_CLASS_PARAMETER:
						pt->arrAppBuf[2]=EQUIP_PARA_NUMBER;
						break;
					default:	
						pt->arrAppBuf[2]=0;
				}
				
				pda_data_echo(0xE3,3,pt->arrAppBuf);
			}
			else if(pd[3]==0x02)  // 得到定值条目
			{
				switch(pd[4])
				{
					case SET_CLASS_OUTSIDE:
						if(!ReadSet(m_runsection,(void *)g_arrPDASetBuf))  // 读当前定值无效
						{
							rt_err_set(ERR_CODE_SET,0);
							GetDefSet((float*)g_arrPDASetBuf);
						}
						pda->bySetNum=SET_NUMBER;
					
						break;
					case SET_CLASS_INSIDE:
						if(!ReadPara((void*)g_arrPDASetBuf,EEP_CSTSET_ADDR,CSTSET_NUMBER,&tCstSetTable[0]))
						{
							GetDefPara((float*)g_arrPDASetBuf,CSTSET_NUMBER,&tCstSetTable[0]);
						}
						pda->bySetNum=CSTSET_NUMBER;
												
						break;
					case SET_CLASS_PARAMETER:
						if(!ReadPara((void*)g_arrPDASetBuf,EEP_EQUIP_PARA_ADDR,EQUIP_PARA_NUMBER,&tEquipParaTable[0]))
						{
							GetDefPara((float*)g_arrPDASetBuf,EQUIP_PARA_NUMBER,&tEquipParaTable[0]);
						}
						pda->bySetNum=EQUIP_PARA_NUMBER;						
						break;
					default:	
						pda->bySetNum=0;
						break;						

				}
				pda->bySetType=pd[4];
				pda->bySendNo=pd[5];
				pda->byItemNo=pda->bySendNo+pd[6];
				if(pda->byItemNo>pda->bySetNum)
				{
					pda->byItemNo=pda->bySetNum;
				}
			}
			else if(pd[3]==0x03)  // 定值修改一个条目
			{
				PDA_SETITEM tPdaSet;
				BYTE *pset;	
				int i;
				BYTE setno;
				const TSETTABLE *pSet;
				
				pset=(BYTE*)&tPdaSet;
				for(i=0;i<sizeof(PDA_SETITEM);i++)
				{
					*pset++=pd[6+i];
				}
				setno=pd[5];  // 	定值序号
				if(setno<pda->bySetNum)
				{

					if(pda->bySetType==SET_CLASS_OUTSIDE)  // 定值条目
					{
						pSet=&tSwSetTable[setno];
					}
					else if(pda->bySetType==SET_CLASS_INSIDE)  //内部 定值条目
					{
						pSet=&tCstSetTable[setno];
					}

					else
					{
						pSet=&tEquipParaTable[setno];
					}
				
					if((CheckFloatSet(&tPdaSet.fNew,pSet->fMax,pSet->fMin)==0)  //判断用户修改的值是否有效
						|| (tPdaSet.wType == SETTYPE_IP)
						|| (tPdaSet.wType == SETTYPE_YMD)
						|| (tPdaSet.wType == SETTYPE_HMS))
					{
						g_arrPDASetBuf[setno]=tPdaSet.fNew;
					}
				}
				pt->arrAppBuf[0]=0x03;
				pt->arrAppBuf[1]=pda->bySetType;
				pt->arrAppBuf[2]=setno;
				pda_data_echo(0xE3,3,pt->arrAppBuf);
			}
			else if(pd[3]==0x04)  // 定值固化
			{
				switch(pda->bySetType)
				{
					case SET_CLASS_OUTSIDE:    //外部定值
						if(SaveSet(m_runsection,(void *)g_arrPDASetBuf))
						{
							soe_record_opt(EV_SET_OK,0);   //定值整定成功
							_pda_record_opelog(1, 2);
							MakeRunSet(0); 
							if(soe_check(EV_SET_FAIL))  //产生过
							{
								soe_record_ev(EV_SET_FAIL,0,0,0,0);  // 无效定值区返回 
								rt_err_clr(ERR_CODE_SET,0);
							}
						}
						else
						{
							soe_record_opt(EV_SET_FAIL,0); 
							_pda_record_opelog(1, 3);
						}
						break;
					case SET_CLASS_INSIDE:   //内部定值
						if(SavePara((void *)g_arrPDASetBuf,EEP_CSTSET_ADDR,CSTSET_NUMBER,&tCstSetTable[0]))
						{
							soe_record_opt(EV_CSTSET_OK,0);  // 内部定值整定成功
							_pda_record_opelog(1, 4);
							MakeRunSet(0); // 将当前运行定值区转换为运行定值区
							if(soe_check(EV_CSTSET_FAIL))  //没有产生过
							{
								soe_record_ev(EV_CSTSET_FAIL,0,0,0,0);  // 内部定值错误
								rt_err_clr(ERR_CODE_SET_IN,0);
							}	
						}
						else
						{
							soe_record_opt(EV_CSTSET_FAIL,0);  // 内部定值整定失败
							_pda_record_opelog(1, 5);
						}													
						break;
					case SET_CLASS_PARAMETER:   //参数设置
						if(SavePara((void *)g_arrPDASetBuf,EEP_EQUIP_PARA_ADDR,EQUIP_PARA_NUMBER,&tEquipParaTable[0]))
						{
							soe_record_opt(EV_EQUPARA_OK,0);
							_pda_record_opelog(1, 6);
							MakeRunPara(false, false); 
							if(soe_check(EV_EQUPARA_FAIL))  //产生过
							{
								soe_record_ev(EV_EQUPARA_FAIL,0,0,0,0);  // 无效定值区返回 
								rt_err_clr(ERR_CODE_EQU_PARA,0);
							}
						}
						else
						{
							soe_record_opt(EV_EQUPARA_FAIL,0);
							_pda_record_opelog(1, 7);
						}						
						break;
					default:							
						break;						

				}				
				
				pt->arrAppBuf[0]=0x04;
				pt->arrAppBuf[1]=pda->bySetType;
				pda_data_echo(0xE3,2,pt->arrAppBuf);
			}
			break;
		}

		case 0x64:		//事件记录
		{
			if(pd[3]==0x01)  // 得到定值条目个数
			{
				pt->arrAppBuf[0]=0x01;
				pt->arrAppBuf[1]=pd[4];
				switch(pd[4])
				{
					case REC_CLASS_EVENT:
						pt->arrAppBuf[2]=(BYTE)g_soe_info.wEvNumber;
						pt->arrAppBuf[3]=(BYTE)(g_soe_info.wEvNumber>>8);
						break;
					case REC_CLASS_OPERATION:
						pt->arrAppBuf[2]=(BYTE)g_soe_info.wOpNumber;
						pt->arrAppBuf[3]=(BYTE)(g_soe_info.wOpNumber>>8);
						break;
					default:	
						pt->arrAppBuf[2]=0;
						pt->arrAppBuf[3]=0;
				}
				
				pda_data_echo(0xE4,4,pt->arrAppBuf);
			}
			else if(pd[3]==0x02)  // 得到事件记录
			{
				EVENT_SHOW tEv; // 自动弹出事件的结构
				WORD evno,eepno;
				DWORD addr;
				bool bRet=true;
				evno=pd[5]+(WORD)(pd[6]<<8);  // 	SOE序号
				switch(pd[4])
				{
					case REC_CLASS_EVENT:	
					{
						if(evno>=g_soe_info.wEvNumber)
						{
							bRet=false;
							return;
						}	

						if(evno<=g_soe_info.wEvIndex)
						{
							eepno=g_soe_info.wEvIndex-evno;
						}
						else
						{

							eepno=g_soe_info.wEvIndex+(g_soe_info.wEvNumber-evno);
						}

						addr=EEP_SOE_ADDR+eepno*(sizeof(EVENT_SAVE))+4;
					}
					break;
					case REC_CLASS_OPERATION:	
					{
						if(evno>=g_soe_info.wOpNumber)
						{
							bRet=false;
							return;
						}
						if(evno<=g_soe_info.wOpIndex)
						{
							eepno=g_soe_info.wOpIndex-evno;
						}
						else
						{

							eepno=g_soe_info.wOpIndex+(g_soe_info.wOpNumber-evno);
						}
						addr=EEP_OPERATE_ADDR+eepno*(sizeof(EVENT_SAVE))+4;
					}
						break;
					default:	
						bRet=false;
				}
				if(bRet)
				
				{
					char *ps=(char*)g_tUartPDA.arrAppBuf;
					BYTE sum,i;
					char tmpstr[100];
					e2prom_read(addr,(BYTE *)&tEv.tEv,sizeof(EVENT_STRUCT)); 
					_pda_get_event_show(&tEv,true);		
					*ps++=0x02;
					*ps++=pd[4];
					*ps++=(BYTE)evno;		//起始序号					
					*ps++=(BYTE)(evno>>8);		//起始序号					
					sum=4;
					*ps=0;
					sprintf(tmpstr,"20%02hu年%02hu月%0hu日\r\n%02hu:%02hu:%02hu.%03hu秒\r\n",
								tEv.year,tEv.month,tEv.day,tEv.hour,tEv.min,tEv.sec,tEv.ms);

					strcpy(ps,tmpstr);
					sum+=strlen((char*)tmpstr);						

					sprintf(tmpstr,"%s\r\n",tEv.namestr);
					strcat(ps,tmpstr);
					sum+=strlen((char*)tmpstr);
					
					for(i=1;i<tEv.sParaNum;i++)
					{
						sprintf(tmpstr,"%s\r\n",tEv.str[i]);
						strcat(ps,tmpstr);
						sum+=strlen((char*)tmpstr);
					}	
					sum+=1;	//字符串最后一个字节/0

					pda_data_echo(0xE4,sum,g_tUartPDA.arrAppBuf);
				}			
			}
		}	
		break;
		case 0x65:		//遥测值遥信上送
		{
			if(pd[3]==0x01)  // 得到条目个数
			{
				pt->arrAppBuf[0]=0x01;
				pt->arrAppBuf[1]=pd[4];
				switch(pd[4])
				{
					case STATUS_CLASS_MEASURE:
						rt_printf("设备应答成功!\r\n");			
						pt->arrAppBuf[2]=PUB_AC_NUM_ALL + SW_AC_NUM_ALL;
						break;
					case STATUS_CLASS_SIGNAL:
						pt->arrAppBuf[2]=SW_DI_NUM + PUB_DI_NUM;
					//	pt->arrAppBuf[2]=g_equ_config->di_num;
						break;
					default:	
						pt->arrAppBuf[2]=0;
				}				
				pda_data_echo(0xE5,3,pt->arrAppBuf);

			}
			else if(pd[3]==0x02)  // 得到条目描述
			{
				switch(pd[4])
				{
					case STATUS_CLASS_MEASURE:
						pda->bySetNum=PUB_AC_NUM_ALL + SW_AC_NUM_ALL;
						pda->bySetType=SET_CLASS_MEASURE;
						
						break;
					case STATUS_CLASS_SIGNAL:
						pda->bySetNum=SW_DI_NUM + PUB_DI_NUM;
						pda->bySetType=SET_CLASS_SIGNAL;
												
						break;
					default:	
						pda->bySetNum=0;
						break;	
				}
				pda->bySendNo=pd[5];
				pda->byItemNo=pda->bySendNo+pd[6];
				if(pda->byItemNo>pda->bySetNum)
				{
					pda->byItemNo=pda->bySetNum;
				}
			}
			else if(pd[3]==0x03)  // 测量值上送
			{
				BYTE *ps=g_tUartPDA.arrAppBuf;
				BYTE sum=0;
				int i;
				BYTE *pdat=(BYTE*)g_sw_pub.ac_in;
				*ps++=0x03;
				*ps++=pd[4];
				switch(pd[4])
				{
					case STATUS_CLASS_MEASURE:
					{
						sum=2;
						for(i=0;i<(PUB_AC_NUM+SW_AC_NUM);i++)
						{
							*ps++=0;
							*ps++=(g_ui[i].e>>16);
							*ps++=(g_ui[i].e>>8);
							*ps++=g_ui[i].e;
							sum+=4;
						}	

						for(i=SW_AC_NUM;i<SW_AC_NUM_ALL;i++)
						{
							*ps++=0;
							*ps++=(g_sw[0].ac_in[i]>>16);
							*ps++=(g_sw[0].ac_in[i]>>8);
							*ps++=g_sw[0].ac_in[i];
							sum+=4;
						}							
						for(i=PUB_AC_NUM*4;i<PUB_AC_NUM_ALL*4;i++)
						{
							*ps++=*pdat++;
							sum++;
						}						
					}
					break;
					case STATUS_CLASS_SIGNAL:
					{															
						int i;
						long value=0;
						struct equ_config_di *ecd;

						sum=6;

						for(i=0;i<PUB_DI_NUM;i++)
						{
							if((short)g_sw_pub.di_cfg_index[i]!=INDEX_INVALLID)  //此遥信有配置
							{
								ecd=&g_equ_config_di[g_sw_pub.di_cfg_index[i]];

								if(g_di[ecd->slot].value[0] & 1<<ecd->index)
								{
									value |= (1<<i);
								}
							}
						}	
						for(i=0;i<SW_DI_NUM;i++)
						{
							if((short)g_sw[0].di_cfg_index[i]!=INDEX_INVALLID)  //此遥信有配置
							{
								ecd=&g_equ_config_di[g_sw[0].di_cfg_index[i]];

								if(g_di[ecd->slot].value[0] & 1<<ecd->index)
								{
									value |= (1<<(i+PUB_DI_NUM));
								}
							}
						}
						*ps++=(value>>24);
						*ps++=(value>>16);
						*ps++=(value>>8);
						*ps++=value;
					}
					break;					
					default:	
						return;	
				}
			
				pda_data_echo(0xE5,sum,g_tUartPDA.arrAppBuf);
			}
		}
		break;	
		case 0x66:		// 遥控类操作
		{
			//Delayms(dTCounter, T_1s*4);
			if(pd[3]==0x01)  // 信号复归
			{
				pt->arrAppBuf[0]=0x01;
				_pda_record_opelog(1, 8);
				SignalReset(0, false);	
				pda_data_echo(0xE6,1,pt->arrAppBuf);
				g_file_led_sign = 1;			// 故障LED状态文件记录标志	
				g_protect_restore = 1;
				clear_tfd_fault();
				rt_printf("PDA复归信号产生\r\n");
			}
			else if(pd[3]==0x02)  // 遥控合闸
			{
				pt->arrAppBuf[0]=0x02;
				_pda_record_opelog(1, 0);
				pda->bPDAHz=true;				
				pda_data_echo(0xE6,1,pt->arrAppBuf);
			}
			else if(pd[3]==0x03)  // 遥控分闸
			{
				pt->arrAppBuf[0]=0x03;
				_pda_record_opelog(1, 1);
				pda->bPDATz=true;				
				pda_data_echo(0xE6,1,pt->arrAppBuf);
			}

			else if(pd[3]==0x04)  //获取时间
			{
				BYTE sum;
				struct timespec ts;
				struct rtc_time_t ct;
				
				clk_time_get(&ts);
				timespec_to_rtc(ts,&ct,1);
							
				sum=sizeof(ct);
				pt->arrAppBuf[0]=0x04;
				memcpy((BYTE *)&pt->arrAppBuf[1],(BYTE*)&ct,sum);
				pda_data_echo(0xE6,sum+1,pt->arrAppBuf);
			}
			else if(pd[3]==0x05)  //设置时间
			{			
				struct rtc_time_t ct;
				memcpy((BYTE *)&ct,&pd[4],sizeof(ct));
				sys_time_set_rmt(&ct);
				pt->arrAppBuf[0]=0x05;
				pda_data_echo(0xE6,1,pt->arrAppBuf);
			}
			else if(pd[3]==0x06)  //重启设备
			{			
				pt->arrAppBuf[0]=0x06;
				_pda_record_opelog(1, 9);
				pda_data_echo(0xE6,1,pt->arrAppBuf);
				Delayms(dTCounter,T_5s);
				rt_irq_disable();
				while(1) ;								
			}
		}
		break;	
		case 0x67:		// 文件类操作
		{
			PDA_TransFile(pt,&pd[3]);
		}
		break;	
		case 0x68:		// 密码验证
		{
			if(pd[3]==0x01)  // 普通密码
			{
				password = ((DWORD)pd[4]<<24)+((DWORD)pd[5]<<16)+((DWORD)pd[6]<<8)+pd[7];
				if(password!=tRunPara.wPassword && password!=PASS_WORD)
				{
					pt->arrAppBuf[0]=0x03;	
				}
				else
				{
					pt->arrAppBuf[0]=0x01;	
				}		
				pda_data_echo(0xE8,1,pt->arrAppBuf);
			}
			else if(pd[3]==0x02)  //  特殊密码，进特内部设置菜单和进行文件传输
			{
				password = ((DWORD)pd[4]<<24)+((DWORD)pd[5]<<16)+((DWORD)pd[6]<<8)+pd[7];
				if(password==INTER_PASSWORD)
				{
					pt->arrAppBuf[0]=0x02;	
				}
				else
				{
					pt->arrAppBuf[0]=0x03;	
				}		
				pda_data_echo(0xE8,1,pt->arrAppBuf);
			}
		}
		break;

		//报文:68 03 03 68 00 65 6d d2
		case 0x6D:		// 装置信息
		{
			
			BYTE cmd_len;
			pt->arrAppBuf[0] = 0x01;
			sprintf(&pt->arrAppBuf[1],EQUIP_NAME_STRING"\r\n版本号:V%d.%02d.%02d\r\n生成日期:\r\n%s\r\n校验码:%04XH\r\n",
				(VER_NUM>>16)&0XFF,(VER_NUM>>8)&0XFF,VER_NUM&0XFF,VER_TIME,m_CodeCrc);
			cmd_len = strlen(pt->arrAppBuf+1)+1;

			rt_printf("cmd_len = %d\r\n",cmd_len);
			pda_data_echo(0xED,cmd_len,pt->arrAppBuf);
		}
		break;
	}
}


/******************************************************************************
函数名称：	_pda_auto_app
函数版本：	01.01
创建作者：	
创建日期：	2015-04-16
函数说明：	pda实时巡检,用于非一问一答模式功能
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static void _pda_auto_app(void)  //
{
	PDA_DEF *pda=&g_tPDA;
	if(pda->bSearch)
	{
		if(dTCounter>=pda->dEchoT)  //设备扫描应答时间到
		{
			g_tUartPDA.arrAppBuf[0]=0x01;        //标明是新设备
			pda_data_echo(0xE1,1,g_tUartPDA.arrAppBuf);
		//	_pda_data_echo(0xE1,0,(BYTE *)0);
			pda->bSearch=false;
		}
	}
	if((pda->bySendNo>=pda->bySetNum)||(pda->bySendNo>=pda->byItemNo))  // 纠错处理
	{
		pda->bySendNo=0;
		pda->byItemNo=0;
		return;
	}
	if((pda->bySendNo!=pda->byItemNo)&&(!g_tUartPDA.bSend))  //需发送定值信息、测量值等条目信息，且允许发送
	{
		const TSETTABLE *pSet;
		PDA_SETITEM tItem;				
		BYTE *pd=g_tUartPDA.arrAppBuf;
		BYTE *pdata=(BYTE*)&tItem.wType;
		BYTE mode=SEND_MODE_SET;
		BYTE bySetType=pda->bySetType;
		BYTE sum;
		int i;
		if(pda->bySetType==SET_CLASS_OUTSIDE)  // 外部定值
		{
			pSet=&tSwSetTable[pda->bySendNo];
		}
		else if(pda->bySetType==SET_CLASS_INSIDE)  // 内部定值
		{
			pSet=&tCstSetTable[pda->bySendNo];
		}

		else if(pda->bySetType==SET_CLASS_PARAMETER)  // 参数设置
		{
			pSet=&tEquipParaTable[pda->bySendNo];
		}
		else if(pda->bySetType==SET_CLASS_MEASURE)  // 测量值
		{
			mode=SEND_MODE_MEA;
			bySetType=STATUS_CLASS_MEASURE;
		}
		else if(pda->bySetType==SET_CLASS_SIGNAL)  // 遥信
		{
			mode=SEND_MODE_YX;
			bySetType=STATUS_CLASS_SIGNAL;
		}		
		else
		{
			return;
		}		
		if(mode==SEND_MODE_SET)
		{  // 发送定值条目信息
			
			tItem.wType=pSet->wType;
			tItem.wUnit = pSet->wUnit;
			tItem.wList = set_get_list_index(pSet->list);
			tItem.fMin=pSet->fMin;
			tItem.fMax=pSet->fMax;
			tItem.fDef=pSet->fDef;
			tItem.fDev=g_arrPDASetBuf[pda->bySendNo];
			tItem.fNew=g_arrPDASetBuf[pda->bySendNo];
			for(i=0;i<18;i++)
			{
				tItem.szName[i]=pSet->szName[i];
			}	

		}
		else if(mode==SEND_MODE_MEA)
		{
			BYTE tmpstr[24];
			int no1,no2,no3;
			for(i=0;i<24;i++)
			{
				tmpstr[i]=0;
			}
			tItem.wType=8;
			tItem.wList = -1;
			tItem.fDef=0;
		//	tItem.fMax=g_ui[pda->bySendNo].normal;  //定义额定值 lmm20140418
			tItem.fMax=0;
			tItem.fMin=0;
			tItem.fNew=0;
			//公共实遥测
			if(pda->bySendNo < PUB_AC_NUM)
			{
			tItem.wUnit =g_pub_ac_desc[pda->bySendNo].unit; 	
			tItem.fDev=g_ui[pda->bySendNo].e;
			rt_printf("A%d:%f\r\n",pda->bySendNo,tItem.fDev);
		//	tItem.fMax=g_unit[g_pub_ac_desc[pda->bySendNo].unit].normal;
			sprintf((char*)tmpstr,"%-4.4s",g_pub_ac_desc[pda->bySendNo].name);
			}
			//开关实遥测
			else if(((PUB_AC_NUM-1) < pda->bySendNo) &&(pda->bySendNo < UI_NUM))
			{
				no1 = pda->bySendNo -PUB_AC_NUM;
				tItem.wUnit =g_sw_ac_desc[no1].unit;    		
				tItem.fDev=g_ui[pda->bySendNo].e;
				rt_printf("B%d:%f\r\n",pda->bySendNo,tItem.fDev);
				sprintf((char*)tmpstr,"%-4.4s",g_sw_ac_desc[no1].name);				
			}
			//开关计算遥测
			else if(((UI_NUM- 1) < pda->bySendNo) && (pda->bySendNo < (PUB_AC_NUM + SW_AC_NUM_ALL)))
			{
				no2 = pda->bySendNo -UI_NUM;
				tItem.wUnit =g_sw_ac_desc[no2].unit;   		
				tItem.fDev=g_sw[0].ac_in[no2];
				rt_printf("C%d:%f\r\n",pda->bySendNo,tItem.fDev);
				sprintf((char*)tmpstr,"%-4.4s",g_sw_ac_desc[no2].name);				
			}
			//公共计算遥测
			else
	//		else if((PUB_AC_NUM + SW_AC_NUM_ALL - 1) < pda->bySendNo <(PUB_AC_NUM_ALL+ SW_AC_NUM_ALL))
			{
				no3 = pda->bySendNo -SW_AC_NUM_ALL;
				tItem.wUnit =g_pub_ac_desc[no3].unit;   		
				tItem.fDev=g_sw_pub.ac_in[no3-PUB_AC_NUM];
				rt_printf("D%d:%f\r\n",pda->bySendNo,tItem.fDev);
				sprintf((char*)tmpstr,"%-4.4s",g_pub_ac_desc[no3].name);				
			}			

			for(i=0;i<24;i++)
			{
				tItem.szName[i]=tmpstr[i];
			}	
		}
		else if(mode==SEND_MODE_YX)
		{
		
			BYTE tmpstr[24];
	//		static int num1,num2;
			tItem.wType=8;
			tItem.wUnit =0;
			tItem.wList = -1;
			tItem.fDef=0;;
			tItem.fMax=0;
			tItem.fMin=0;
			tItem.fDev=0;
			tItem.fNew=0;
			for(i=0;i<24;i++)
			{
				tmpstr[i]=0;
			}

			//公共遥信
			if(pda->bySendNo < PUB_DI_NUM)
			{
				strcpy((char*)tmpstr,g_pub_di_name[pda->bySendNo]);
			}	
			//开关遥信
			else   
			{
				strcpy((char*)tmpstr,g_sw_di_name[pda->bySendNo -PUB_DI_NUM]);
			}
		
			for(i=0;i<20;i++)
			{
				tItem.szName[i]=tmpstr[i];
			}

		}		
	
		else
		{
			return;
		}	
			
		*pd++=0x02;
		*pd++=bySetType;
		*pd++=pda->bySendNo;		//起始序号
		sum=3;
		for(i=0;i<sizeof(PDA_SETITEM);i++)
		{
			*pd++=*pdata++;
			sum++;
		}	
		if(mode==SEND_MODE_SET)
		{
			pda_data_echo(0xE3,sum,g_tUartPDA.arrAppBuf);
		}
		else
		{
			pda_data_echo(0xE5,sum,g_tUartPDA.arrAppBuf);
		}
		pda->bySendNo++;

	}

}



/******************************************************************************
函数名称：	_pda_record_opelog
函数版本：	01.01
创建作者：	
创建日期：	2015-04-16
函数说明：	PDA操作日志
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static void _pda_record_opelog(BYTE code,int i)
{
	PDA_LOG_STRUCT ev;
	char log_buf[40];

	memset(ev.log_name,0,sizeof(ev.log_name));
	memset(ev.pda_id,0,sizeof(ev.pda_id));
	memset(log_buf,0,sizeof(log_buf));
	
	sprintf(ev.log_name,"%s",g_PDA_Record[i].strName);
	sprintf(ev.pda_id,"PDA编号:%s ",g_PDA_Log.pda_id_buf);
	
	strcat(log_buf,ev.pda_id);
	strcat(log_buf,ev.log_name);

	log_str_time(0,log_buf,1,0);
}

/******************************************************************************
函数名称：	_pda_get_event_show
函数版本：	01.01
创建作者：	
创建日期：	2015-04-16
函数说明：	PDA查询事件
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
static void _pda_get_event_show(EVENT_SHOW *pe,bool bPDA)
{
	EVENT_STRUCT *er=&pe->tEv;
	char tmpstr[24];
	char tmpstr1[24];
	bool bAdd=false;
	bool bfirstpara=false;
	u8 soe_type;
	
	struct rtc_time_t tTime;
	timespec_to_rtc(er->ts,&tTime,1);
		
	pe->year=tTime.year;
	pe->month=tTime.month;
	pe->day=tTime.day;	
	pe->hour=tTime.hour;
	pe->min=tTime.min;
	pe->sec=(tTime.ms/1000);
	pe->ms=(tTime.ms%1000);
	pe->sParaCur=-1;
	pe->sParaNum=0;
	sprintf((char *)pe->valuestr,"%-20.20s","");  // 清参数区
	sprintf((char *)pe->str[1],"%-20.20s","");  // 清参数区
	sprintf((char *)pe->str[2],"%-20.20s","");  // 清参数区
	sprintf((char *)pe->str[3],"%-20.20s","");  // 清参数区

	soe_type = er->ev_type&SOE_TYPE_MASK;
	if(soe_type==SOE_TYPE_EV||soe_type==SOE_TYPE_OPT)   // 不是遥信变位
	{
		int i;
		int ev_sw=0;
		int len=0;
		u16 code;
		const SOE_DEF * psoe;

		if(er->ev_code>=EV_NUMBER)
		{
			sprintf(tmpstr,"错误代码:%d",er->ev_code);
			sprintf((char *)pe->namestr,"%-16.16s",tmpstr);
			return;
		}		

		if (er->ev_code < EV_SW_NUM)
		{
			code = er->ev_code;
			ev_sw = 1;
		}
		else if ((er->ev_code >= EV_SW_NUM)&& (er->ev_code < EV_PUB_START))
		{
			code = er->ev_code % EV_SW_NUM;
			ev_sw = (er->ev_code / EV_SW_NUM) + 1;
		}
		else
		{
			code = er->ev_code - EV_SW_NUM*(SWITCH_NUM_MAX-1);
		}

		#if SWITCH_NUM_MAX != 1
		{
			if ((ev_sw > 0) && (ev_sw <= g_sw_num))
			{
				sprintf(pe->namestr,"开关%02d ",ev_sw);
				len = strlen(pe->namestr);
			}
		}
		#endif

		psoe=&tAllSOE[code];
		if(soe_ev_is_on(er)) // 置1 ,产生，显示参数
		{
			BYTE paranum=0;
			sprintf((char*)&pe->namestr[len],"%-20.20s",psoe->strName);
			strcpy((char*)pe->str[pe->sParaNum++],psoe->strName);
			for(i=0;i<3;i++)  // 统计参数个数及最大参数的索引值
			{
				BYTE index=(psoe->Attrib[i]&0x1f);
				if(index)
				{
					paranum++;
				}
			}
			if(paranum>1)  // 多个参数可显示加号
			{
				bAdd=true;
			}
			for(i=0;i<3;i++)
			{
				BYTE index=(psoe->Attrib[i]&0x1f);
				if(index)
				{
					switch((psoe->Attrib[i]>>5)&0x07)
					{
						case 0:  // 浮点数
							FUC_Get_LongValue_String(er->ev_arg[i],tmpstr1);
							sprintf((char*)tmpstr,"%s=%s%s",ev_para[index].strName,tmpstr1,g_unit[ev_para[index].byNo].name);
							break;
						case 1: // 整型值
							sprintf(tmpstr,"%s=%d%s",ev_para[index].strName,er->ev_arg[i],g_unit[ev_para[index].byNo].name);
							break;
						case 2: // 遥控操作
							{
								BYTE sw=(er->ev_arg[0]>>8)&0xff; //开关号
								BYTE no=(er->ev_arg[0]>>0)&0xff;	//序号
								char *ykowner;
								ykowner=get_yk_owner((er->ev_arg[0]>>16)&0xff);
								if(sw==0)
								{
									sprintf(tmpstr,"%s:公共开出%02d",ykowner,no);
								}
								else
								{
									sprintf(tmpstr,"%s:开关%02d开出%02d",ykowner,sw,no);
								}
							}						
							break;	
						case 3: // 压板操作
							{
								strcpy(tmpstr,"投入");
							}						
							break;	
							
						default:strcpy(tmpstr,"参数错误");		
						break;
					}
					if(!bfirstpara)
					{
						bfirstpara=true;
						pe->sParaCur=i;
						if(bAdd)
						{
							sprintf((char *)pe->valuestr,"%-18.18s+",tmpstr);
						}
						else
						{
							sprintf((char *)pe->valuestr,"%-19.19s",tmpstr);
						}
					}
					sprintf((char *)pe->str[pe->sParaNum++],"%-19.19s",tmpstr); // PDA参数 增加
				}
			}
		}
		else // 置 0，显示返回值
		{
			if(strlen(psoe->strName)>16)
			{
				sprintf((char*)&pe->namestr[len],"%-20.20s",psoe->strName);				
				sprintf((char*)pe->valuestr,"%-15.15s",ev_back[(psoe->soe_def&0x03)]);
				strcpy((char*)tmpstr,psoe->strName);  // 添加到PDA显示，没有参数


			}
			else
			{
				strcpy((char*)&pe->namestr[len],psoe->strName);
				strcat((char*)pe->namestr,ev_back[(psoe->soe_def&0x03)]);
			}
			strcpy((char *)pe->str[pe->sParaNum++],(char*)pe->namestr);		
			strcpy((char *)pe->str[pe->sParaNum++],(char *)pe->valuestr);
		}
		
	}
	else  if(soe_type==SOE_TYPE_YX)// 变位记录
	{
		BYTE solt=(BYTE)(er->ev_code>>8);		//板卡号
		BYTE dino=(BYTE)(er->ev_code);		//遥信号
	
		sprintf((char*)pe->namestr,"板卡%02d开入%02d变位",solt,dino+1);  // 板卡xx开入xx变位
		if(soe_ev_is_on(er)) // 置1 ,产生，显示参数
		{
			strcpy(tmpstr,"分->合");
		}
		else
		{
			strcpy(tmpstr,"合->分");

		}
		sprintf((char *)pe->valuestr,"%-16.16s",tmpstr);
		strcpy((char *)pe->str[pe->sParaNum++],(char*)pe->namestr);		
		strcpy((char *)pe->str[pe->sParaNum++],(char *)pe->valuestr);

		sprintf((char *)pe->str[pe->sParaNum++],"(%s)",equ_di_name(solt,dino));  //开入对应的开关遥信名称

	}	
	else
	{
		sprintf(tmpstr,"未知类型:%d",er->ev_code);
		sprintf((char *)pe->namestr,"%-16.16s",tmpstr);
		strcpy((char *)pe->str[pe->sParaNum++],(char*)pe->namestr);		
		
	}		
	//strcpy((char *)pe->namestr,(char*)pe->valuestr);
	//strcpy((char *)pe->namestr,(char*)pe->str[0]);

}