#include "upper_computer_rw_api.h"
#include "rtc.h"
#include "key.h"
#include "master_slave_inter.h"
#include "string.h"
#include "test_log.h"
#include "system_parameter.h"
#include "valve_control.h"
#include "system_log.h"
#include "e2p.h"
#include "gpio.h"
#include "delay.h"
#include "low_pwr_test.h"
#include "gprs.h"
#include "check_out.h"
#include "stdlib.h"


UC_SLAVE_PARA_UNION_T slave_para_union_g = {0};

/************************************** Write Data **************************************************************/
/************************************** Write Data **************************************************************/
static const UC_RECV_WRITE_FUNC_TABLE_DRV_T uc_recv_write_tab_func[] = {
		{30,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE,UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_WriteFlowAlarmCfgHandler},
		{31,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE,UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_WritePressAlarmCfgHandler},
		{32,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE,UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_WriteTempAlarmCfgHandler},
		{33,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE,UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_WritePulseFactorHandler},
		{UCC_MASTER_INFO_RW,SET_PARA_MODE,UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteMasterInfoHandler},
    {UCC_TIME_RW, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteTimeHandler},
		
		{UCC_SLAVE_INFO_RW_2, SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteSlave_TransitionHandler},
    {UCC_SLAVE_INFO_RW, SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteSlave_TransitionHandler},
    
		{UCC_FUNC_CFG_RW, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteFuncCfgHandler},
    {UCC_ALARM_CFG_RW, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteAlarmCtlHandler},
    {UCC_ALARM_SEND_RW, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteAlarmSendHandler},
    {UCC_VALVE_CTL_RW, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteValveCtlHandler},
    /*¼ÆÁ¿Ïà¹Ø*/
		{UCC_SLAVE_PIPE_RW, SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteSlave_TransitionHandler},
    {UCC_SLAVE_UT_RW, SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteSlave_TransitionHandler},
    {UCC_SLAVE_CORR_SET_RW, SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteSlave_TransitionHandler},
		{UCC_SLAVE_UT_REAL_2_RW, SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteSlave_TransitionHandler},
    {UCC_SLAVE_RST_WO, SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteSlave_TransitionHandler},
		{UCC_SLAVE_ZERO_2_ZERO_WO, SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteSlave_TransitionHandler},
		{UCC_SLAVE_RES_RW, SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteSlave_TransitionHandler},
		{UCC_SLAVE_PWR_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_WriteSalve_PwrHandler},
		{UCC_SLAVE_CAL_DATA_PARA_RW,SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_WriteSlave_TransitionHandler},
		{UCC_SLAVE_CORR_FIXED_RW,SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_WriteSlave_TransitionHandler},

		
		{UCC_BASIC_INFO_RW,SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteBasicInfoHandler},
		{UCC_FLOW_CFG_PARA_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteFlowAlarmCfg_2Handler},
		{UCC_PRESS_CFG_PARA_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WritePressAlarmCfg_2Handler},
		{UCC_TEMP_CFG_PARA_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteTempAlarmCfg_2Handler},
		{UCC_BILLING_CFG_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteBillingAlarmCfg_Handler},
		{UCC_CAL_PULSE_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WritePulseFactor_2Handler},
		{UCC_PRICE_CFG_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WritePriceCfgHandler},
		{UCC_GPRS_CFG_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteGprsCfgHandler},
		{UCC_AES_KEYS_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteAes128KeysHandler},
		{UCC_SAVE_TIME_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteSaveTimeCfgHandler},
		{UCC_BALANCE_SET_WO,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteBalanceSetHandler},
		{UCC_CUMULATE_SET_RW,SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_WriteCumulateSetHandler},
		{UCC_FUNC_CFG_RW_2,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_WriteFuncCfg_2Handler},
		{UCC_ALARM_CFG_SEND_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_WriteAlarmCtlSend_2Handler},
		{UCC_VALVE_CTL_RW_2,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_WriteValveCtl_2Handler},
		{UCC_VALVE_FLAG_WO,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_WriteValveFlag_Handler},
		{UCC_MICRO_CONSTANT_PARA_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_WriteMicroConstant_Handler},
		{UCC_SEC_CORR_SET_PARA_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_WriteSecCorrSet_Handler},
		{UCC_ZERO_DRIFT_CFG_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_WriteZeroDriftCfg_Handler},
};
/************************************** Read Data **************************************************************/
/************************************** Read Data **************************************************************/
static const UC_RECV_READ_FUNC_TABLE_DRV_T uc_recv_read_tab_func[] = {
		{30,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE,UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadFlowAlarmCfgHandler},
		{31,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE,UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadPressAlarmCfgHandler},
		{32,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE,UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadTempAlarmCfgHandler},
		{33,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE,UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadPulseFactorHandler},
		{UCC_MASTER_INFO_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE,UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadMasterInfoHandler},
    {UCC_TIME_RW, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadTimeHandler},
    /*¼ÆÁ¿Ïà¹Ø*/
		{UCC_SLAVE_INFO_RW_2, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadSlave_TransitionHandler},
		{UCC_SLAVE_INFO_RW, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadSlave_TransitionHandler},
    
		{UCC_STATE_BYTES_RO, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadStateBytesHandler},
    {UCC_FUNC_CFG_RW, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadFuncCfgHandler},
    {UCC_ALARM_CFG_RW, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadAlarmCtlHandler},
    {UCC_ALARM_SEND_RW, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadAlarmSendHandler},
    {UCC_VALVE_CTL_RW, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadValveCtlHandler},
    /*¼ÆÁ¿Ïà¹Ø*/
		{UCC_SLAVE_PIPE_RW, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadSlave_TransitionHandler},
    {UCC_SLAVE_UT_RW, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadSlave_TransitionHandler},
    {UCC_SLAVE_CORR_SET_RW, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadSlave_TransitionHandler},
    {UCC_SLAVE_CORR_REAL_RO, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadSlave_TransitionHandler},
    {UCC_SLAVE_RAW_DATA_RO, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadSlave_TransitionHandler},
    {UCC_SLAVE_TP_DATA_RO, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadSlave_TransitionHandler},
		{UCC_SLAVE_UT_REAL_1_RO, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadSlave_TransitionHandler},
		{UCC_SLAVE_UT_REAL_2_RW, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadSlave_TransitionHandler},
    {UCC_SLAVE_STATUS_RO, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadSlave_TransitionHandler},
    {UCC_SLAVE_ALARM_RO, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadSlave_TransitionHandler},
    {UCC_SLAVE_REAL_DATA_RO, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadSlave_TransitionHandler},
		{UCC_SLAVE_RES_RW, NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadSlave_TransitionHandler},
		{UCC_SLAVE_PWR_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadSalve_PwrHandler},
		{UCC_SLAVE_TEMP_TIMEDIFF_RO,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadSlave_TransitionHandler},
		{UCC_SLAVE_CAL_DATA_PARA_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadSlave_TransitionHandler},
		{UCC_SLAVE_CORR_FIXED_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadSlave_TransitionHandler},
		
		
		{UCC_BASIC_INFO_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadBasicInfoHandler},
		{UCC_FLOW_CFG_PARA_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadFlowAlarmCfg_2Handler},
		{UCC_PRESS_CFG_PARA_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadPressAlarmCfg_2Handler},
		{UCC_TEMP_CFG_PARA_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadTempAlarmCfg_2Handler},
		{UCC_BILLING_CFG_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadBillingAlarmCfg_Handler},
		{UCC_CAL_PULSE_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadPulseFactor_2Handler},
		{UCC_PRICE_CFG_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadPriceCfgHandler},
		{UCC_GPRS_CFG_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadGprsCfgHandler},
		{UCC_AES_KEYS_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadAes128KeysHandler},
		{UCC_SAVE_TIME_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadSaveTimeCfgHandler},
		{UCC_CUMULATE_SET_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER, Uc_ReadRealCumulateHandler},
		{UCC_STATE_BYTES_RO_2,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadStateBytes_2Handler},
		{UCC_FUNC_CFG_RW_2,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE , UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadFuncCfg_2Handler},
		{UCC_ALARM_CFG_SEND_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadAlarmCtlSend_2Handler},
		{UCC_VALVE_CTL_RW_2,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadValveCtl_2Handler},
		{UCC_REALTIME_PARA_RO,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadRealParaHandler},
		{UCC_MICRO_CONSTANT_PARA_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadMicroConstantHandler},
		{UCC_CYCLIC_LOG_DATA_INFO_RO,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadCyclicLogDataHandler},
		{UCC_SEC_CORR_SET_PARA_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadSecCorrSetHandler},
		{UCC_SEC_CORR_REAL_PARA_RO,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadSecCorrRealHandler},
		{UCC_ZERO_DRIFT_CFG_RW,NORMAL_MODE | DISPLAY_PARA | SET_PARA_MODE, UC_NORMAL_USER | UC_POWER_USER | UC_ADMIN_USER | UC_SUPERUSER,Uc_ReadZeroDriftCfgHandler},
};

/************************************** Write Data **************************************************************/
/************************************** Write Data **************************************************************/
/************************************** Write Data **************************************************************/
ErrorStatus_STM32 Uc_WriteTimeHandler(uint8_t *pData)
{
  if (Set_Sys_Rtc_Time(pData[0], pData[1], pData[2], pData[3], pData[4], pData[5],1) == SUCCESS_0)
	{
		/*ÀúÊ·¼Ç¼¹¹Ôì*/
		timing_log_g.record_time_before[0] = calendar_g.Year;
		timing_log_g.record_time_before[1] = calendar_g.Month;
		timing_log_g.record_time_before[2] = calendar_g.Date;
		timing_log_g.record_time_before[3] = calendar_g.Hour;
		timing_log_g.record_time_before[4] = calendar_g.Minute;
		timing_log_g.record_time_before[5] = calendar_g.Second;
		timing_log_g.timing_cause = TC_UPPER;
		Get_Sys_Rtc_Time(&calendar_g); //ÉèÖÃÍêʱ¼äºóÁ¢Âí¸üÐÂÒ»ÏÂʱ¼ä
		__PERIOD_FIRST_CALC_FLAG_SET(gprs_send_period);
		__PERIOD_FIRST_CALC_FLAG_SET(alka_get_power_period);
		__PERIOD_FIRST_CALC_FLAG_SET(lith_get_power_period);
		__PERIOD_FIRST_CALC_FLAG_SET(mcu_get_temperature_period);
		return RealTimeData_LogStore(&save_realtime_data_g, &sys_realtime_data_g, &billing_real_para_g, &calendar_g);//´¢´æ
	}    
  else
    return ERROR_1;
}
ErrorStatus_STM32 Uc_WriteFlowAlarmCfgHandler(uint8_t *pData)
{
	SYS_FLOW_ALARM_CFG_T sys_flow_alarm_cfg_temp = {0};
	memcpy(&sys_flow_alarm_cfg_temp,pData,20);
	sys_flow_alarm_cfg_temp.sys_flow_up_1 = BLEndianFloat(sys_flow_alarm_cfg_temp.sys_flow_up_1);
	sys_flow_alarm_cfg_temp.sys_flow_up_2 = BLEndianFloat(sys_flow_alarm_cfg_temp.sys_flow_up_2);
	sys_flow_alarm_cfg_temp.sys_flow_down_1 = BLEndianFloat(sys_flow_alarm_cfg_temp.sys_flow_down_1);
	sys_flow_alarm_cfg_temp.flow_up_2_replace_value = BLEndianFloat(sys_flow_alarm_cfg_temp.flow_up_2_replace_value);
	sys_flow_alarm_cfg_temp.small_flow_excision_value = BLEndianFloat(sys_flow_alarm_cfg_temp.small_flow_excision_value);
	if(sys_flow_alarm_cfg_temp.sys_flow_up_1 != sys_flow_alarm_cfg_g.sys_flow_up_1)
	{
		/*¹¹Ôìbefore*/
		memcpy(&para_amend_log_g.para_amend_union.flow_cfg_amend_s.flow_cfg_before,&sys_flow_alarm_cfg_g,20);
		/*¹¹Ôìnow*/
		memcpy(&para_amend_log_g.para_amend_union.flow_cfg_amend_s.flow_cfg_now,&sys_flow_alarm_cfg_temp,20);
		memcpy(&sys_flow_alarm_cfg_g,&sys_flow_alarm_cfg_temp,20);
		Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_FLOW_ALARM_CFG],1);
		para_amend_log_g.mender = SDM_UPPER;
		__SYS_ALARM_BYTES_SET(flow_para_amend,SET);
	}
	return SUCCESS_0;
}

ErrorStatus_STM32 Uc_WritePressAlarmCfgHandler(uint8_t *pData)
{
	SYS_PRESS_ALARM_CFG_T press_temp = {0};
	memcpy(&press_temp,pData,36);
	press_temp.press_correction_factor = BLEndianFloat(press_temp.press_correction_factor);
	press_temp.press_intercept = BLEndianFloat(press_temp.press_intercept);
	press_temp.press_up_value = BLEndianFloat(press_temp.press_up_value);
	press_temp.press_up_up_value = BLEndianFloat(press_temp.press_up_up_value);
	press_temp.press_down_value = BLEndianFloat(press_temp.press_down_value);
	press_temp.press_down_down_value = BLEndianFloat(press_temp.press_down_down_value);
	press_temp.press_up_scope = BLEndianFloat(press_temp.press_up_scope);
	press_temp.press_down_scope = BLEndianFloat(press_temp.press_down_scope);
	press_temp.press_down_down_replace = BLEndianFloat(press_temp.press_down_down_replace);
	if(press_temp.press_up_value != sys_press_alarm_cfg_g.press_up_value)
	{
		/*¹¹Ôìbefore*/
		memcpy(&para_amend_log_g.para_amend_union.press_cfg_amend_s.press_cfg_before,&sys_press_alarm_cfg_g,36);
		/*¹¹Ôìnow*/
		memcpy(&para_amend_log_g.para_amend_union.press_cfg_amend_s.press_cgf_now,&press_temp,36);
		memcpy(&sys_press_alarm_cfg_g,&press_temp,36);
		Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_PRESS_ALARM_CFG],1);
		para_amend_log_g.mender = SDM_UPPER;
		__SYS_ALARM_BYTES_SET(press_para_amend,SET);
	}
	return SUCCESS_0;
}

ErrorStatus_STM32 Uc_WriteTempAlarmCfgHandler(uint8_t *pData)
{
	SYS_TEMP_ALARM_CFG_T temp_temp = {0};
	memcpy(&temp_temp,pData,30);
	temp_temp.temp_correction_factor = BLEndianFloat(temp_temp.temp_correction_factor);
	temp_temp.temp_intercept = BLEndianFloat(temp_temp.temp_intercept);
	temp_temp.temp_up_value = BSWAP_16(temp_temp.temp_up_value);
	temp_temp.temp_up_up_value = BSWAP_16(temp_temp.temp_up_up_value);;
	temp_temp.temp_down_value = BSWAP_16(temp_temp.temp_down_value);
	temp_temp.temp_down_down_value = BSWAP_16(temp_temp.temp_down_down_value);
	temp_temp.temp_up_scope = BSWAP_16(temp_temp.temp_up_scope);
	temp_temp.temp_down_scope = BSWAP_16(temp_temp.temp_down_scope);
	temp_temp.temp_up_up_replace = BSWAP_16(temp_temp.temp_up_up_replace);
	temp_temp.temp_drastic_change = BLEndianFloat(temp_temp.temp_drastic_change);
	temp_temp.cpu_temp_up_scope = BSWAP_16(temp_temp.cpu_temp_up_scope);
	temp_temp.cpu_temp_down_scope = BSWAP_16(temp_temp.cpu_temp_down_scope);
	
	if(temp_temp.temp_up_value != sys_temp_alarm_cfg_g.temp_up_value)
	{
		/*¹¹Ôìbefore*/
		memcpy(&para_amend_log_g.para_amend_union.temp_cfg_amend_s.temp_cfg_before,&sys_temp_alarm_cfg_g,30);
		/*¹¹Ôìnow*/
		memcpy(&para_amend_log_g.para_amend_union.temp_cfg_amend_s.temp_cgf_now,&temp_temp,30);
		memcpy(&sys_temp_alarm_cfg_g,&temp_temp,30);
		Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_TEMP_ALARM_CFG],1);
		para_amend_log_g.mender = SDM_UPPER;
		__SYS_ALARM_BYTES_SET(temp_para_amend,SET);
	}
	return SUCCESS_0;
}


ErrorStatus_STM32 Uc_WritePulseFactorHandler(uint8_t *pData)/*Ôݶ¨*/
{
#pragma pack(1)		
	typedef struct {
		uint32_t cal_pulse_factor_temp;
		uint16_t cal_pulse_width_temp;
	}TEMP_CAL_PULSE_PARA;
#pragma pack()		
	TEMP_CAL_PULSE_PARA temp_cal_pulse_para = {0};
	memcpy(&temp_cal_pulse_para,pData,6);
	/*´óС¶Ëת»»*/
	temp_cal_pulse_para.cal_pulse_factor_temp = BSWAP_32(temp_cal_pulse_para.cal_pulse_factor_temp);
	temp_cal_pulse_para.cal_pulse_width_temp = BSWAP_16(temp_cal_pulse_para.cal_pulse_width_temp);
	if(temp_cal_pulse_para.cal_pulse_factor_temp != cal_pulse_para_g.cal_pulse_factor)
	{
		/*¹¹Ôìbefore*/
		para_amend_log_g.para_amend_union.cal_pulse_amend_s.cal_pulse_cfg_before.cal_pulse_factor = cal_pulse_para_g.cal_pulse_factor;
		para_amend_log_g.para_amend_union.cal_pulse_amend_s.cal_pulse_cfg_before.cal_pulse_width = cal_pulse_para_g.cal_pulse_width;
		/*¹¹Ôìnow*/
		para_amend_log_g.para_amend_union.cal_pulse_amend_s.cal_pulse_cfg_now.cal_pulse_factor = temp_cal_pulse_para.cal_pulse_factor_temp;
		para_amend_log_g.para_amend_union.cal_pulse_amend_s.cal_pulse_cfg_now.cal_pulse_width = temp_cal_pulse_para.cal_pulse_width_temp;
		cal_pulse_para_g.cal_pulse_factor = temp_cal_pulse_para.cal_pulse_factor_temp;
		cal_pulse_para_g.cal_pulse_width = temp_cal_pulse_para.cal_pulse_width_temp;
		Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_CAL_PULSE_CFG],1);//²ÎÊý´æ´¢
		para_amend_log_g.mender = SDM_UPPER;
		__SYS_ALARM_BYTES_SET(pluse_cal_amend,SET);
	}
	return SUCCESS_0;
}

ErrorStatus_STM32 Uc_WriteSlave_TransitionHandler(uint8_t *pData)
{
  uint8_t cmd = 0;
  uint16_t ms_cnt = 500, //²»¿ÉÐ޸ĸüС
           uc_table_id = uc_recv_para_g.uc_recv_buf_union.uc_recv_buf[12] << 8 | uc_recv_para_g.uc_recv_buf_union.uc_recv_buf[13];
  switch (uc_table_id)
  {
  case UCC_SLAVE_INFO_RW:
	case UCC_SLAVE_INFO_RW_2:
    cmd = SC_RW_HARDWARE;
    break;
  case UCC_SLAVE_PIPE_RW:
    cmd = PIPE_RW_PARA;
    break;
  case UCC_SLAVE_UT_RW:
    cmd = UT_RW_PARA;
    break;
  case UCC_SLAVE_CORR_SET_RW:
    cmd = CORR_RW_SET;
    break;
	case UCC_SLAVE_UT_REAL_2_RW:
    cmd = UT_RW_REAL_PARA_2;
    break;
  case UCC_SLAVE_RST_WO:
    cmd = SC_SYS_RST;
    break;
	case UCC_SLAVE_ZERO_2_ZERO_WO:
    cmd = SC_ZERO_2_ZERO;
		break;
	case UCC_SLAVE_RES_RW:
		cmd = SC_RES_PARA;
		break;
	case UCC_SLAVE_CAL_DATA_PARA_RW:
		cmd = CAL_DATA_PARA;
    break;
	case UCC_SLAVE_CORR_FIXED_RW:
		cmd = CORR_RW_FIXED;
		break;
  default:
    break;
  }
  /*Ö÷°åת·¢µ½Á÷Á¿°åÒª¼õÈ¥ÉÏλ»úЭÒéÍ·³¤¶È£¬CRCУÑ鳤¶ÈºÍ±íºÅ³¤¶È*/
  Send_Write_Slave_Command(cmd, pData, uc_recv_para_g.uc_recv_length - UC_PROTOCOL_HEAD_LENGTH - UC_DATA_TABLE_BYTES_LENGTH - 2);
  while (ms_cnt--) // ÔÚ¹¤³ÌģʽϽo¸ö1sµÄµÈ´ýʱ¼ä
  {
    delay_ms(1);
		if(Measure_Uart3_Rx_DMA_CH1_Check(10) == SUCCESS_0) //ºË²éÊý¾ÝÊÇ·ñ´«ÊäÍê³É
			break;
  }
  if (Slave_Result_Handler(INTER_DATA_WRITE, &inter_recv_para_g) == INTER_OK)
    return SUCCESS_0;
  else
  {
    /*½øÐдíÎó´¦Àí£¨ÔÝÎÞ£©*/
    return ERROR_1;
  }
}

ErrorStatus_STM32 Uc_WriteSalve_PwrHandler(uint8_t *pData)
{
	if(pData[0] == 0)
		SLAVE_PWR_OFF;
	else
		SLAVE_PWR_ON;
	return SUCCESS_0;
}

ErrorStatus_STM32 Uc_WriteMasterInfoHandler(uint8_t *pData)
{
	memcpy(&master_soft_hard_para_g, pData, 15);
  return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_MASTER_SOFT_HARD],1);//´¢´æ;
}

ErrorStatus_STM32 Uc_WriteFuncCfgHandler(uint8_t *pData)
{
  memcpy(&sys_func_cfg_bytes_g, pData, SYS_FUNC_CTL_BYTES_TYPE_LENGTH);
  return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_FUNC_CFG_BYTES],1);//´¢´æ;
}
ErrorStatus_STM32 Uc_WriteFuncCfg_2Handler(uint8_t *pData)
{
	/*before*/
	memcpy(para_amend_log_g.para_amend_union.sys_func_cfg_amend_s.func_cfg_bytes_before,&sys_func_cfg_bytes_g,SYS_FUNC_CTL_BYTES_TYPE_LENGTH);
	/*now*/	
	memcpy(&sys_func_cfg_bytes_g, pData, SYS_FUNC_CTL_BYTES_TYPE_LENGTH);
	memcpy(para_amend_log_g.para_amend_union.sys_func_cfg_amend_s.func_cfg_bytes_now,pData,SYS_FUNC_CTL_BYTES_TYPE_LENGTH);
	para_amend_log_g.mender = SDM_UPPER;
	sys_para_amend_log_flag_g = SYS_FUNC_CFG_BYTES_AMEND;
	
	sys_admin_g.sys_admin.state_bytes.lcd_mode = sys_func_cfg_bytes_g.sys_func_cfg_bytes_s.lcd_mode;
	sys_admin_g.sys_admin.state_bytes.virtual_billing = sys_func_cfg_bytes_g.sys_func_cfg_bytes_s.virtual_billing;
	sys_admin_g.sys_admin.state_bytes.account_state = sys_func_cfg_bytes_g.sys_func_cfg_bytes_s.account_state;
	sys_admin_g.sys_admin.state_bytes.billing_type = sys_func_cfg_bytes_g.sys_func_cfg_bytes_s.billing_type;
  return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_FUNC_CFG_BYTES],1);//´¢´æ;
}
ErrorStatus_STM32 Uc_WriteAlarmCtlHandler(uint8_t *pData)
{
  memcpy(&sys_alarm_ctl_bytes_g, pData, SYS_ALARM_CTL_BYTES_TYPE_LENGTH);
  return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_ALARM_CTL_BYTES],1);
}
ErrorStatus_STM32 Uc_WriteAlarmSendHandler(uint8_t *pData)
{
  memcpy(&sys_alarm_send_bytes_g, pData, SYS_ALARM_SEND_BYTES_TYPE_LENGTH);
  return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_ALARM_SEND_BYTES],1);
}
ErrorStatus_STM32 Uc_WriteAlarmCtlSend_2Handler(uint8_t *pData)
{
	uint16_t temp_alarm_ctl_byte_2 = sys_alarm_ctl_bytes_g.alarm_ctl_send_union[1] & 0xFFFC, 
		temp_alarm_send_byte_2 = sys_alarm_send_bytes_g.alarm_ctl_send_union[1] & 0xFFFC;
	/*before*/
	memcpy(para_amend_log_g.para_amend_union.sys_alarm_ctl_bytes_amend_s.alarm_ctl_bytes_before,&sys_alarm_ctl_bytes_g,SYS_ALARM_CTL_BYTES_TYPE_LENGTH);
	memcpy(para_amend_log_g.para_amend_union.sys_alarm_ctl_bytes_amend_s.alarm_send_bytes_before,&sys_alarm_send_bytes_g,SYS_ALARM_SEND_BYTES_TYPE_LENGTH);
	/*now*/
	/*ÓÉÓÚ¡°¼Æ·ÑÓë·§±¨¾¯¿ØÖÆ/Éϱ¨×Ö¡±µ¥¶ÀÔÚ¸÷ÖÖÓà¶î/Ìõ¼þ¹Ø·§ÃüÁîÖÐÐ޸ģ¬ËùÒÔÔÚ´Ë´¦ÃüÁî²»ÐÞ¸Ä*/
	memcpy(&sys_alarm_ctl_bytes_g,pData,2);
	sys_alarm_ctl_bytes_g.alarm_ctl_send_union[1] = temp_alarm_ctl_byte_2 | (pData[2] & 0x03);
	memcpy(&sys_alarm_ctl_bytes_g.alarm_ctl_send_union[2], &pData[4], SYS_ALARM_CTL_BYTES_TYPE_LENGTH - 4);
	
	memcpy(&sys_alarm_send_bytes_g,&pData[SYS_ALARM_CTL_BYTES_TYPE_LENGTH],2);
	sys_alarm_send_bytes_g.alarm_ctl_send_union[1] = temp_alarm_send_byte_2 | (pData[SYS_ALARM_CTL_BYTES_TYPE_LENGTH + 2] & 0x03);
	memcpy(&sys_alarm_send_bytes_g.alarm_ctl_send_union[2], &pData[SYS_ALARM_CTL_BYTES_TYPE_LENGTH + 4], SYS_ALARM_SEND_BYTES_TYPE_LENGTH - 4);
	
	memcpy(para_amend_log_g.para_amend_union.sys_alarm_ctl_bytes_amend_s.alarm_ctl_bytes_now,&sys_alarm_ctl_bytes_g,SYS_ALARM_CTL_BYTES_TYPE_LENGTH);
	memcpy(para_amend_log_g.para_amend_union.sys_alarm_ctl_bytes_amend_s.alarm_send_bytes_now,&sys_alarm_send_bytes_g,SYS_ALARM_SEND_BYTES_TYPE_LENGTH);
	para_amend_log_g.mender = SDM_UPPER;
	sys_para_amend_log_flag_g = ALARM_CTL_SEND_BYTES_AMEND;
	return (ErrorStatus_STM32)(Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_ALARM_CTL_BYTES],1) | 
		Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_ALARM_SEND_BYTES],1));
}
ErrorStatus_STM32 Uc_WriteValveCtlHandler(uint8_t *pData)
{
  memcpy(&valve_ctl_bytes_g, pData, VALVE_CTL_LENGTH);
  return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_VALVE_CTL_BYTES],1);
}
ErrorStatus_STM32 Uc_WriteValveCtl_2Handler(uint8_t *pData)
{
	uint16_t temp_valve_ctl_2 = 0;
	memcpy(&temp_valve_ctl_2,&valve_ctl_bytes_g.valve_ctr_2,2);
	temp_valve_ctl_2 &= 0xFFFC; 
	/*before*/
	memcpy(para_amend_log_g.para_amend_union.sys_valve_ctl_bytes_amend_s.valve_ctl_bytes_before,&valve_ctl_bytes_g,VALVE_CTL_LENGTH);
	/*now*/
	memcpy(&valve_ctl_bytes_g,pData,2);
	temp_valve_ctl_2 |= (pData[2] & 0x03);
	memcpy(&valve_ctl_bytes_g.valve_ctr_2,&temp_valve_ctl_2,2);
	memcpy(&valve_ctl_bytes_g.valve_ctr_4, &pData[6], VALVE_CTL_LEN - 6);
	memcpy(para_amend_log_g.para_amend_union.sys_valve_ctl_bytes_amend_s.valve_ctl_bytes_now,pData,VALVE_CTL_LENGTH);
	para_amend_log_g.mender = SDM_UPPER;
	sys_para_amend_log_flag_g = VALVE_CTL_BYTES_AMEND;
	return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_VALVE_CTL_BYTES],1);
}
ErrorStatus_STM32 Uc_WriteValveFlag_Handler(uint8_t *pData)
{
	if(pData[0] == 4 && __SYS_STATUS_BYTES_GET(valve_state) == VALVE_CL && __SYS_STATUS_BYTES_GET(valve_lock) == RESET)
	{
		__SYS_STATUS_BYTES_STATUS(valve_lock, SET, AV_NORMAL);
		__VALVE_WORK_TYPE_SET(VWT_LOCK);
//		op_cl_valve_cause_id = AV_NORMAL;                        // ûÓпª¹Ø·§Ô­ÒòID
	}
	else if(pData[0] == 5 && __SYS_STATUS_BYTES_GET(valve_state) == VALVE_CL && __SYS_STATUS_BYTES_GET(valve_lock) == SET)
	{
		__SYS_STATUS_BYTES_STATUS(valve_lock, RESET, AV_NORMAL);
		__VALVE_WORK_TYPE_SET(VWT_UNLOCK);
//		op_cl_valve_cause_id = AV_NORMAL;                        // ûÓпª¹Ø·§Ô­ÒòID
	}		
	else
		return ERROR_1;
	return SUCCESS_0;
}

ErrorStatus_STM32 Uc_WriteBasicInfoHandler(uint8_t *pData)
{
	uint16_t write_data_length = MASTER_BASIC_FORMAT_SIZE - SIZEOF_OF(MASTER_BASIC_PARA_T,reserve);
	uint8_t device_type_before = atoi((char *)&master_basic_papa_g.specifications_model[7]);

	memcpy(&master_basic_papa_g,pData,write_data_length);
	memcpy(gprs_protocol_head_tail_g.gprs_protocol_head.device_num,master_basic_papa_g.factory_number,
		sizeof(gprs_protocol_head_tail_g.gprs_protocol_head.device_num));// É豸±àºÅ
	Sys_GetUnitType_Set(device_type_before);
	return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_MASTER_BASIC],1);//´¢´æ
}

ErrorStatus_STM32 Uc_WriteMicroConstant_Handler(uint8_t *pData)
{
	uint16_t write_data_length = MICRO_CONSTANT_FLOW_FORMAT_SIZE - SIZEOF_OF(MICRO_CONSTANT_FLOW_PARA_T,reserve);
	memcpy(&micro_constant_flow_para_g,pData,write_data_length);
	return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_MICRO_CONSTANT_FLOW],1);
}

ErrorStatus_STM32 Uc_WriteSecCorrSet_Handler(uint8_t *pData)
{
	uint16_t write_data_length = SEC_ORDER_CORR_PARA_FORMAT_SIZE - SIZEOF_OF(SECOND_ORDER_CORR_T,reserve);
	uint8_t slave_cmd = CORR_SEC_PARA;
	Send_Write_Slave_Command(slave_cmd,pData,write_data_length);
	/*Ô¤ÁôµÄ10¸ö¸¡µãÊýµ±oldÖµÓÃ*/
	memcpy(&sec_order_corr_set_g.reserve[0],&sec_order_corr_set_g,write_data_length);
	/*before*/
	memcpy(&para_amend_log_g.para_amend_union.sec_corr_para_amend_s.sec_corr_para_before,&sec_order_corr_set_g,write_data_length);
	/*now*/
	memcpy(&para_amend_log_g.para_amend_union.sec_corr_para_amend_s.sec_corr_para_now,pData,write_data_length);
	memcpy(&sec_order_corr_set_g,pData,write_data_length);
	sys_para_amend_log_flag_g = SEC_ORDER_CORR_PARA_AMEND; //ÓÃÓÚ´æ´¢
	SecondOrder_RealParaCalculate_Init();
	return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_SEC_ORDER_CORR_SET],1);
}

ErrorStatus_STM32 Uc_WriteFlowAlarmCfg_2Handler(uint8_t *pData)
{
	uint16_t write_data_length = SYS_FLOW_ALARM_CFG_FORMAT_SIZE - SIZEOF_OF(SYS_FLOW_ALARM_CFG_T,reserve);
	/*before*/
	memcpy(&para_amend_log_g.para_amend_union.flow_cfg_amend_s.flow_cfg_before,&sys_flow_alarm_cfg_g,write_data_length);
	/*now*/
	memcpy(&sys_flow_alarm_cfg_g,pData,write_data_length);
	memcpy(&para_amend_log_g.para_amend_union.flow_cfg_amend_s.flow_cfg_now,pData,write_data_length);
	para_amend_log_g.mender = SDM_UPPER;
	__SYS_ALARM_BYTES_SET(flow_para_amend,SET); //ÓÃÓÚ±¨¾¯Éϱ¨
	sys_para_amend_log_flag_g = GAS_CFG_PARA_AMEND; //ÓÃÓÚ´æ´¢
	return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_FLOW_ALARM_CFG],1);//´¢´æ
}
ErrorStatus_STM32 Uc_WritePressAlarmCfg_2Handler(uint8_t *pData)
{
	uint16_t write_data_length = SYS_PRESS_ALARM_CFG_FORMAT_SIZE - SIZEOF_OF(SYS_PRESS_ALARM_CFG_T,reserve);
	/*before*/
	memcpy(&para_amend_log_g.para_amend_union.press_cfg_amend_s.press_cfg_before,&sys_press_alarm_cfg_g,write_data_length);
	/*now*/
	memcpy(&sys_press_alarm_cfg_g,pData,write_data_length);
	memcpy(&para_amend_log_g.para_amend_union.press_cfg_amend_s.press_cgf_now,pData,write_data_length);
	para_amend_log_g.mender = SDM_UPPER;
	__SYS_ALARM_BYTES_SET(press_para_amend,SET);
	sys_para_amend_log_flag_g = PRESS_CFG_PARA_AMEND;
	return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_PRESS_ALARM_CFG],1);//´¢´æ
}
ErrorStatus_STM32 Uc_WriteTempAlarmCfg_2Handler(uint8_t *pData)
{
	uint16_t write_data_length = SYS_TEMP_ALARM_CFG_FORMAT_SIZE - SIZEOF_OF(SYS_TEMP_ALARM_CFG_T,reserve);
	/*before*/
	memcpy(&para_amend_log_g.para_amend_union.temp_cfg_amend_s.temp_cfg_before,&sys_temp_alarm_cfg_g,write_data_length);
	/*now*/
	memcpy(&sys_temp_alarm_cfg_g,pData,write_data_length);
	memcpy(&para_amend_log_g.para_amend_union.temp_cfg_amend_s.temp_cgf_now,pData,write_data_length);
	para_amend_log_g.mender = SDM_UPPER;
	__SYS_ALARM_BYTES_SET(temp_para_amend,SET);
	sys_para_amend_log_flag_g = TEMP_CFG_PARA_AMEND;
	return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_TEMP_ALARM_CFG],1);//´¢´æ
}

ErrorStatus_STM32 Uc_WriteBillingAlarmCfg_Handler(uint8_t *pData)
{
	uint8_t value_cnt = 0,alarm_ctl_cnt = 0,valve_ctl_cnt = 0;
	BILLING_ALARM_CFG_T billing_alarm_temp = {0};
	uint16_t write_data_length = SYS_BILLING_ALARM_CFG_FORMAT_SIZE - SIZEOF_OF(BILLING_ALARM_CFG_T,reserve);
	memcpy(&billing_alarm_temp.valve_close_ctl[0],pData,write_data_length - 4);
	/*before*/
	memcpy(&para_amend_log_g.para_amend_union.billing_alarm_cfg_amend_s.billing_alarm_before,&billing_alarm_cfg_g,write_data_length);
	
	if(billing_alarm_cfg_g.balance_small_value[0] != billing_alarm_temp.balance_small_value[0])
	{
		value_cnt++;
		billing_alarm_cfg_g.balance_small_value[0] = billing_alarm_temp.balance_small_value[0];
		if(__SYS_ALARM_CTL_BYTES_GET(balance_small_1) == RESET)
		{
			alarm_ctl_cnt++;
			__SYS_ALARM_CTL_SEND_BYTES_SET(balance_small_1,SET);
		}
	}
	if(billing_alarm_cfg_g.balance_small_value[1] != billing_alarm_temp.balance_small_value[1])
	{
		value_cnt++;
		billing_alarm_cfg_g.balance_small_value[1] = billing_alarm_temp.balance_small_value[1];
		if(__SYS_ALARM_CTL_BYTES_GET(balance_small_2) == RESET)
		{
			alarm_ctl_cnt++;
			__SYS_ALARM_CTL_SEND_BYTES_SET(balance_small_2,SET);
		}
	}
	if(billing_alarm_cfg_g.balance_small_value[2] != billing_alarm_temp.balance_small_value[2])
	{
		value_cnt++;
		billing_alarm_cfg_g.balance_small_value[2] = billing_alarm_temp.balance_small_value[2];
		if(__SYS_ALARM_CTL_BYTES_GET(balance_small_3) == RESET)
		{
			alarm_ctl_cnt++;
			__SYS_ALARM_CTL_SEND_BYTES_SET(balance_small_3,SET);
		}
	}
	if(billing_alarm_cfg_g.balance_small_value[3] != billing_alarm_temp.balance_small_value[3])
	{
		value_cnt++;
		billing_alarm_cfg_g.balance_small_value[3] = billing_alarm_temp.balance_small_value[3];
		if(__SYS_ALARM_CTL_BYTES_GET(balance_small_4) == RESET)
		{
			alarm_ctl_cnt++;
			__SYS_ALARM_CTL_SEND_BYTES_SET(balance_small_4,SET);
		}
	}
	billing_alarm_cfg_g.balance_small_value[4] = billing_alarm_temp.balance_small_value[4];
	
	if(billing_alarm_cfg_g.cumulate_flow_value != billing_alarm_temp.cumulate_flow_value)
	{
		value_cnt++;
		billing_alarm_cfg_g.cumulate_flow_value = billing_alarm_temp.cumulate_flow_value;
		if(billing_alarm_cfg_g.cumulate_flow_value == 0 && __SYS_ALARM_CTL_BYTES_GET(set_cumulate_up_to) == SET)
		{
			alarm_ctl_cnt++;
			__SYS_ALARM_CTL_SEND_BYTES_SET(set_cumulate_up_to,RESET);
		}else if(billing_alarm_cfg_g.cumulate_flow_value != 0 && __SYS_ALARM_CTL_BYTES_GET(set_cumulate_up_to) == RESET)
		{
			alarm_ctl_cnt++;
			__SYS_ALARM_CTL_SEND_BYTES_SET(set_cumulate_up_to,SET);
		}
	}
	if(billing_alarm_cfg_g.no_gprs_days != billing_alarm_temp.no_gprs_days)
	{
		value_cnt++;
		billing_alarm_cfg_g.no_gprs_days = billing_alarm_temp.no_gprs_days;
		if(billing_alarm_cfg_g.no_gprs_days == 0 && __SYS_ALARM_CTL_BYTES_GET(no_gprs_date_up_to) == SET)
		{
			alarm_ctl_cnt++;
			__SYS_ALARM_CTL_SEND_BYTES_SET(no_gprs_date_up_to,RESET);
		}else if(billing_alarm_cfg_g.no_gprs_days != 0 && __SYS_ALARM_CTL_BYTES_GET(no_gprs_date_up_to) == RESET)
		{
			alarm_ctl_cnt++;
			__SYS_ALARM_CTL_SEND_BYTES_SET(no_gprs_date_up_to,SET);
		}
	}
	if(billing_alarm_cfg_g.no_use_gas_days != billing_alarm_temp.no_use_gas_days)
	{
		value_cnt++;
		billing_alarm_cfg_g.no_use_gas_days = billing_alarm_temp.no_use_gas_days;
		if(billing_alarm_cfg_g.no_use_gas_days == 0 && __SYS_ALARM_CTL_BYTES_GET(no_use_gas_date_up_to) == SET)
		{
			alarm_ctl_cnt++;
			__SYS_ALARM_CTL_SEND_BYTES_SET(no_use_gas_date_up_to,RESET);
		}else if(billing_alarm_cfg_g.no_use_gas_days != 0 && __SYS_ALARM_CTL_BYTES_GET(no_use_gas_date_up_to) == RESET)
		{
			alarm_ctl_cnt++;
			__SYS_ALARM_CTL_SEND_BYTES_SET(no_use_gas_date_up_to,SET);
		}
	}
	if(billing_alarm_cfg_g.valve_close_ctl[0] != billing_alarm_temp.valve_close_ctl[0])
	{
		valve_ctl_cnt++;
		billing_alarm_cfg_g.valve_close_ctl[0] = billing_alarm_temp.valve_close_ctl[0];
	}
	if(billing_alarm_cfg_g.valve_close_ctl[1] != billing_alarm_temp.valve_close_ctl[1])
	{
		valve_ctl_cnt++;
		billing_alarm_cfg_g.valve_close_ctl[1] = billing_alarm_temp.valve_close_ctl[1];
	}
	
	if(alarm_ctl_cnt)
	{
		billing_alarm_cfg_g.alarm_ctl_byte_2 = sys_alarm_ctl_bytes_g.alarm_ctl_send_union[1];
		billing_alarm_cfg_g.alarm_send_byte_2 = sys_alarm_send_bytes_g.alarm_ctl_send_union[1];
		Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_ALARM_CTL_BYTES],1);
		Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_ALARM_SEND_BYTES],1);
	}
	if(valve_ctl_cnt)
	{
		//¸³Óè·§¿Ø×Ö
		memcpy(&valve_ctl_bytes_g.valve_ctr_2,&billing_alarm_cfg_g.valve_close_ctl[0],SIZEOF_OF(BILLING_ALARM_CFG_T,valve_close_ctl));
		Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_VALVE_CTL_BYTES],1);
	}
	
	if(value_cnt || alarm_ctl_cnt || valve_ctl_cnt)
	{
		/*now*/
		memcpy(&para_amend_log_g.para_amend_union.billing_alarm_cfg_amend_s.billing_alarm_now,&billing_alarm_cfg_g,write_data_length);
		para_amend_log_g.mender = SDM_UPPER;
		sys_para_amend_log_flag_g = BILLING_ALARM_CFG_AMEND;
		return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_BILLING_ALARM_CFG],1);
	}
	else
		return ERROR_1;
}

ErrorStatus_STM32 Uc_WritePulseFactor_2Handler(uint8_t *pData)
{
	uint16_t write_data_length = SYS_CAL_PULSE_PARA_FORMAT_SIZE - SIZEOF_OF(CAL_PULSE_PARA_T,reserve);
	/*before*/
	memcpy(&para_amend_log_g.para_amend_union.cal_pulse_amend_s.cal_pulse_cfg_before,&cal_pulse_para_g,write_data_length);
	/*now*/
	memcpy(&cal_pulse_para_g,pData,write_data_length);
	memcpy(&para_amend_log_g.para_amend_union.cal_pulse_amend_s.cal_pulse_cfg_now,pData,write_data_length);
	para_amend_log_g.mender = SDM_UPPER;
	__SYS_ALARM_BYTES_SET(pluse_cal_amend,SET);
	sys_para_amend_log_flag_g = PLUSE_CAL_PARA_AMEND;
	return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_CAL_PULSE_CFG],1);//´¢´æ
}
ErrorStatus_STM32 Uc_WritePriceCfgHandler(uint8_t *pData)
{
	uint16_t write_data_length = SYS_LADDER_PRICE_CFG_FORMAT_SIZE - SIZEOF_OF(LADDER_PRICE_CFG_PARA_T,reserve);
	/*before*/
	memcpy(&para_amend_log_g.para_amend_union.billing_price_amend_s.price_cfg_before,&ladder_price_cfg_para_new_g,write_data_length);
	/*now*/
	memcpy(&ladder_price_cfg_para_new_g,pData,write_data_length);
	memcpy(&para_amend_log_g.para_amend_union.billing_price_amend_s.price_cfg_now,pData,write_data_length);
	para_amend_log_g.mender = SDM_UPPER;
	__SYS_ALARM_BYTES_SET(billing_para_amend,SET);
	sys_para_amend_log_flag_g = BILLING_PARA_AMEND;
	return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_LADDER_PRICE_CFG_NEW],1);//´¢´æ
}
ErrorStatus_STM32 Uc_WriteGprsCfgHandler(uint8_t *pData)
{
	uint16_t write_data_length = SYS_GPRS_NETWORK_CFG_FORMAT_SIZE - 
					SIZEOF_OF(GPRS_NETWORK_CFG_PARA_T,reserve) - SIZEOF_OF(GPRS_NETWORK_CFG_PARA_T,aes128_secret_key);
	uint16_t temp_send_time = gprs_network_cfg_para_g.gprs_send_period_min_time;
	memcpy(&gprs_network_cfg_para_g,pData,write_data_length);
	if(temp_send_time != gprs_network_cfg_para_g.gprs_send_period_min_time)
		__PERIOD_FIRST_CALC_FLAG_SET(gprs_send_period);
	return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_GPRS_NETWORK_CFG],1);//´¢´æ
}
ErrorStatus_STM32 Uc_WriteAes128KeysHandler(uint8_t *pData)
{
	uint8_t i = 0;
	uint16_t write_data_length = SIZEOF_OF(GPRS_NETWORK_CFG_PARA_T,aes128_secret_key);
	memcpy(gprs_network_cfg_para_g.aes128_secret_key,pData,write_data_length);
	/*ÃÜÔ¿*/
	if(my_memcmp(gprs_network_cfg_para_g.aes128_secret_key[1],&i,8 * 16) > 0)
		memcpy(KVer_AES_128,gprs_network_cfg_para_g.aes128_secret_key[1],sizeof(KVer_AES_128)); //Õýʽ
	else
		memcpy(KVer_AES_128,gprs_network_cfg_para_g.aes128_secret_key[0],sizeof(KVer_AES_128)); //²âÊÔ
	return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_GPRS_NETWORK_CFG],1);//´¢´æ
}
ErrorStatus_STM32 Uc_WriteSaveTimeCfgHandler(uint8_t *pData)
{
	uint16_t write_data_length = SAVE_DATA_START_PARA_FORMAT_SIZE - SIZEOF_OF(SAVE_DATA_START_PARA_T,reserve);
	memcpy(&save_day_month_timing_g,pData,write_data_length);
	return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_SAVE_DATA_START_TIME],1);//´¢´æ
}

ErrorStatus_STM32 Uc_WriteZeroDriftCfg_Handler(uint8_t *pData)
{
	uint16_t write_data_length = ZERO_DRIFT_CFG_SIZE - SIZEOF_OF(ZERO_DRIFT_CORR_CFG_T,reserve);
	memcpy(&zero_drift_cfg_g,pData,write_data_length);
	return Sys_Log_E2pParaMultipleWrite(&sys_store_para_table[PARA_ZERO_DRIFT_CFG],1);//´¢´æ
}

ErrorStatus_STM32 Uc_WriteBalanceSetHandler(uint8_t *pData)
{
	uint8_t pay_flag = pData[0];
	int64_t pay_value = 0;
	if(pay_flag == 1) //³äÖµ
	{
		memcpy(&pay_value,&pData[1],8); 
		billing_real_para_g.balance_now += pay_value * 0.001; // Ôö¼ÓÓà¶î
		pay_para_g.pay_value = pay_value;
		pay_para_g.pay_value_cumulate += pay_para_g.pay_value;	
		pay_para_g.mender = SDM_UPPER;
		pay_para_g.pay_type = 1;
		pay_flag_g = 1;//³äÖµ±ê־λ
	}else if(pay_flag == 2) //ÇåÁã
	{
		/*before*/
		para_amend_log_g.para_amend_union.balance_amend_s.balance_before = billing_real_para_g.balance_now;
		/*now*/
		para_amend_log_g.para_amend_union.balance_amend_s.balance_now = billing_real_para_g.balance_now = 0;
		__SYS_ALARM_BYTES_SET(balance_amend,SET);
		sys_para_amend_log_flag_g = BALANCE_PARA_AMEND;
	}
	return RealTimeData_LogStore(&save_realtime_data_g, &sys_realtime_data_g, &billing_real_para_g, &calendar_g); // ´æ´¢
}
ErrorStatus_STM32 Uc_WriteCumulateSetHandler(uint8_t *pData)
{
	ErrorStatus_STM32 result = ERROR_1; 
	double cumulate_sc = 0,cumulate_wc = 0;
	memcpy(&cumulate_sc,pData,8);
	memcpy(&cumulate_wc,&pData[8],8);
	if((cumulate_sc != sys_realtime_data_g.measure_para_s.forward_cumulate_sc) ||
			(cumulate_wc != sys_realtime_data_g.measure_para_s.forward_cumulate_wc))
	{
		/*¹¹Ôìbefore*/
		para_amend_log_g.para_amend_union.gas_cumulate_amend_s.cumulate_sc_before = sys_realtime_data_g.measure_para_s.forward_cumulate_sc;
		para_amend_log_g.para_amend_union.gas_cumulate_amend_s.cumulate_wc_before = sys_realtime_data_g.measure_para_s.forward_cumulate_wc;
		/*¹¹Ôìnow*/
		para_amend_log_g.para_amend_union.gas_cumulate_amend_s.cumulate_sc_after = sys_realtime_data_g.measure_para_s.forward_cumulate_sc = cumulate_sc;
		para_amend_log_g.para_amend_union.gas_cumulate_amend_s.cumulate_wc_after = sys_realtime_data_g.measure_para_s.forward_cumulate_wc = cumulate_wc;
		para_amend_log_g.mender = SDM_UPPER;
		__SYS_ALARM_BYTES_SET(gas_cumulate_amend,SET);
		sys_para_amend_log_flag_g = GAS_CUMULATE_PARA_AMEND;
		result = RealTimeData_LogStore(&save_realtime_data_g, &sys_realtime_data_g, &billing_real_para_g, &calendar_g); // ´æ´¢
	}
	return result;
}

/*ÉÏλ»úдÊý¾Ý·µ»Ø´¦Àíº¯Êý*/
void Upper_ComputerWriteResultProcess(ErrorStatus_STM32 result_state, uint8_t *pData, UC_RECV_DATA_UNION_T *uc_recv_union_p)
{
  /*¹¹ÔìЭÒéÍ·*/
  uc_recv_union_p->uc_protocol_head_s.data_field_length = 3;
  /*°ÑÖ¡Í·½á¹¹ÌåÊý¾Ý¿½±´µ½·¢ËÍÊý×é*/
  memcpy(pData, &uc_recv_union_p->uc_protocol_head_s, UC_PROTOCOL_HEAD_LENGTH);
  /*¹¹ÔìÊý¾ÝÓò*/
  pData[UC_PROTOCOL_HEAD_LENGTH] = uc_recv_union_p->uc_recv_buf[12];
  pData[UC_PROTOCOL_HEAD_LENGTH + 1] = uc_recv_union_p->uc_recv_buf[13];
  pData[UC_PROTOCOL_HEAD_LENGTH + 2] = result_state;
}

/*ÉÏλ»úдÊý¾Ý´¦Àíº¯Êý*/
ErrorStatus_STM32 Upper_ComputerWriteProcess(uint16_t work_permissions, uint16_t table_id, uint8_t *pWriteData)
{
  ErrorStatus_STM32 write_result_flag = ERROR_1;
  // ²é±í
  for (uint8_t i = 0; i < UC_RECV_WRITE_TABLE_NUM; i++)
  {
    if (uc_recv_write_tab_func[i].uc_data_table == table_id && uc_recv_write_tab_func[i].UcRecvWriteFuncHandler != NULL)
    {
      if ((work_permissions & uc_recv_write_tab_func[i].func_admin_user) != 0) // Óû§È¨ÏÞÅжÏ
      {
        /*ģʽȨÏÞÅжÏ*/
				if(uc_recv_write_tab_func[i].func_admin_mode & sys_display_para_g.sys_and_display_mode)
				{
					E2p_GPIO_Clk_Init();
					write_result_flag = uc_recv_write_tab_func[i].UcRecvWriteFuncHandler(pWriteData);
				}	
      }
      else
      {
      }
      break;
    }
  }
  return write_result_flag;
}

/************************************** Read Data **************************************************************/
/************************************** Read Data **************************************************************/
/************************************** Read Data **************************************************************/
ErrorStatus_STM32 Uc_ReadTimeHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint16_t i = 0;
  /*¹¹ÔìÊý¾ÝÓòÄÚÈÝ*/
  pOutputData[i++] = calendar_g.Year & 0xFF;
  pOutputData[i++] = calendar_g.Month;
  pOutputData[i++] = calendar_g.Date;
  pOutputData[i++] = calendar_g.Hour;
  pOutputData[i++] = calendar_g.Minute;
  pOutputData[i++] = calendar_g.Second;
  *pData_field_len = i + UC_DATA_TABLE_BYTES_LENGTH; //+UC_DATA_TABLE_BYTES_LENGTHΪ±íºÅÊý¾ÝÕ¼2×Ö½Ú
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadFlowAlarmCfgHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
	uint8_t reserved_bytes = 0;
	SYS_FLOW_ALARM_CFG_T read_flow_cfg_temp = {0};
	float * ptr;
	memcpy(&read_flow_cfg_temp,&sys_flow_alarm_cfg_g,20);
	ptr = &read_flow_cfg_temp.sys_flow_up_1;
	for(uint8_t i = 0;i < (20 /sizeof(float));i++)
		*(ptr + i) = BLEndianFloat(*(ptr + i));
	memcpy(pOutputData,ptr,20);
	*pData_field_len = 20 + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
	return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadPressAlarmCfgHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
	uint8_t reserved_bytes = 0;
	SYS_PRESS_ALARM_CFG_T read_press_cfg_temp = {0};
	float * ptr = &read_press_cfg_temp.press_correction_factor;
	memcpy(&read_press_cfg_temp,&sys_press_alarm_cfg_g,36);
	for(uint8_t i = 0;i < (36 /sizeof(float));i++)
		*(ptr + i) = BLEndianFloat(*(ptr + i));
	memcpy(pOutputData,ptr,36);
	*pData_field_len = 36 + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
	return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadTempAlarmCfgHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
	uint8_t reserved_bytes = 0;
	SYS_TEMP_ALARM_CFG_T read_temp_cfg_temp = {0};
	float * ptr_f = &read_temp_cfg_temp.temp_correction_factor;
	int16_t * ptr_16 = &read_temp_cfg_temp.temp_up_value;
	memcpy(&read_temp_cfg_temp,&sys_temp_alarm_cfg_g,30);
	for(uint8_t i = 0;i < (8 /sizeof(float));i++)
		*(ptr_f + i) = BLEndianFloat(*(ptr_f + i));
	for(uint8_t i = 0;i < (14 /sizeof(int16_t));i++)
		*(ptr_16 + i) = BSWAP_16(*(ptr_16 + i));
	read_temp_cfg_temp.temp_drastic_change = BLEndianFloat(read_temp_cfg_temp.temp_drastic_change);
	read_temp_cfg_temp.cpu_temp_up_scope = BSWAP_16(read_temp_cfg_temp.cpu_temp_up_scope);
	read_temp_cfg_temp.cpu_temp_down_scope = BSWAP_16(read_temp_cfg_temp.cpu_temp_down_scope);
	memcpy(pOutputData,&read_temp_cfg_temp,30);
	*pData_field_len = 30 + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
	return SUCCESS_0;
}

ErrorStatus_STM32 Uc_ReadPulseFactorHandler(uint8_t *pOutputData, uint16_t *pData_field_len) /*ÔÝʱ*/
{
#pragma pack(1)	
	typedef struct {
		uint32_t cal_pulse_factor_temp;
		uint16_t cal_pulse_width_temp;
	}TEMP_CAL_PULSE_PARA;
#pragma pack()		
	uint8_t reserved_bytes = 0,PARA_NUM = sizeof(TEMP_CAL_PULSE_PARA);
	TEMP_CAL_PULSE_PARA temp_cal_pulse_para = {0};
	/*´óС¶Ëת»»*/
	temp_cal_pulse_para.cal_pulse_factor_temp = BSWAP_32(cal_pulse_para_g.cal_pulse_factor);
	temp_cal_pulse_para.cal_pulse_width_temp = BSWAP_16(cal_pulse_para_g.cal_pulse_width);
	memcpy(pOutputData,&temp_cal_pulse_para,PARA_NUM);
	*pData_field_len = PARA_NUM + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
	return SUCCESS_0;
}


ErrorStatus_STM32 Uc_ReadSlave_TransitionHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t cmd;
  uint16_t ms_cnt = 500,//²»Òª³¬¹ý1S£¬²»¿ÉÐ޸ĸüС
           uc_table_id = uc_recv_para_g.uc_recv_buf_union.uc_recv_buf[12] << 8 | uc_recv_para_g.uc_recv_buf_union.uc_recv_buf[13];
  void *ptr = &slave_para_union_g;
  switch (uc_table_id)
  {
  case UCC_SLAVE_INFO_RW:
	case UCC_SLAVE_INFO_RW_2:
    cmd = SC_RW_HARDWARE;
    break;
  case UCC_SLAVE_PIPE_RW:
    cmd = PIPE_RW_PARA;
    break;
  case UCC_SLAVE_UT_RW:
    cmd = UT_RW_PARA;
    break;
  case UCC_SLAVE_CORR_SET_RW:
    cmd = CORR_RW_SET;
    break;
  case UCC_SLAVE_CORR_REAL_RO:
    cmd = CORR_RO_REAL;
    break;
  case UCC_SLAVE_RAW_DATA_RO:
    cmd = RAW_RO_DATA;
    break;
  case UCC_SLAVE_TP_DATA_RO:
    cmd = SC_RO_TP;
    break;
  case UCC_SLAVE_STATUS_RO:
    cmd = SC_RO_STATUS;
    break;
  case UCC_SLAVE_ALARM_RO:
    cmd = SC_RO_ALARM;
		break;
  case UCC_SLAVE_REAL_DATA_RO:
    cmd = DATA_RO_REAL_TIME;
    break;
	case UCC_SLAVE_UT_REAL_1_RO:
		cmd = UT_RO_REAL_PARA_1;
		break;
	case UCC_SLAVE_UT_REAL_2_RW:
		cmd = UT_RW_REAL_PARA_2;
		break;
	case UCC_SLAVE_RES_RW:
		cmd = SC_RES_PARA;
		break;
	case UCC_SLAVE_TEMP_TIMEDIFF_RO:
		cmd = DATA_RO_TEMP_TIME_DIFF;
		break;
	case UCC_SLAVE_CAL_DATA_PARA_RW:
		cmd = CAL_DATA_PARA;
		break;
	case UCC_SLAVE_CORR_FIXED_RW:
		cmd = CORR_RW_FIXED;
		break;
  default:
    break;
  }
  Send_Read_Slave_Command(cmd);
  while (ms_cnt--) 
  {
    delay_ms(1);
		if(Measure_Uart3_Rx_DMA_CH1_Check(200) == SUCCESS_0) //ºË²éÊý¾ÝÊÇ·ñ´«ÊäÍê³É
			break;
  }
  if (Slave_Result_Handler(INTER_DATA_READ, &inter_recv_para_g) == INTER_OK)
  {
    memcpy(pOutputData, ptr, inter_recv_para_g.inter_recv_length - CMD_DATATABLE_CRC_LENGTH);
//    memcpy(pOutputData, &inter_recv_para_g.inter_recv_union.inter_recv_buf[2],
//           inter_recv_para_g.inter_recv_length - CMD_DATATABLE_CRC_LENGTH);
    *pData_field_len = inter_recv_para_g.inter_recv_length - CMD_DATATABLE_CRC_LENGTH + UC_DATA_TABLE_BYTES_LENGTH;
		memset(&slave_para_union_g,0,SLAVE_UNION_PARA_LENGTH);
    return SUCCESS_0;
  }
  else
  {
    /*½øÐдíÎó´¦Àí£¨ÔÝÎÞ£©*/
    return ERROR_1;
  }
}

ErrorStatus_STM32 Uc_ReadSalve_PwrHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
	pOutputData[0] = !GPIO_ReadOutputDataBit(MEASURE_PWR_PORT,MEASURE_PWR_PIN);
	*pData_field_len = UC_DATA_TABLE_BYTES_LENGTH + 1;
	return SUCCESS_0;
}

ErrorStatus_STM32 Uc_ReadMasterInfoHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
	uint8_t reserved_bytes = 0;
	uint16_t read_data_length = MASTER_SOFT_HARD_FORMAT_SIZE - SIZEOF_OF(MASTER_SOFT_HARD_PARA_T,reserve);
	memcpy(pOutputData, &master_soft_hard_para_g, read_data_length);
  *pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}

ErrorStatus_STM32 Uc_ReadStateBytesHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t reserved_bytes = 4;
  memcpy(pOutputData, (void *)&sys_admin_g.sys_admin.state_bytes, SYS_STATUS_BYTES_TYPE_LENGTH);
  *pData_field_len = SYS_STATUS_BYTES_TYPE_LENGTH + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadStateBytes_2Handler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
	uint8_t reserved_bytes = 0;
  memcpy(pOutputData, (void *)&sys_admin_g.sys_admin.state_bytes, SYS_STATUS_BYTES_TYPE_LENGTH);
  *pData_field_len = SYS_STATUS_BYTES_TYPE_LENGTH + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadFuncCfgHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t reserved_bytes = 8;
  memcpy(pOutputData, &sys_func_cfg_bytes_g, SYS_FUNC_CTL_BYTES_TYPE_LENGTH);
  *pData_field_len = SYS_FUNC_CTL_BYTES_TYPE_LENGTH + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadFuncCfg_2Handler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
	  uint8_t reserved_bytes = 0;
  memcpy(pOutputData, &sys_func_cfg_bytes_g, SYS_FUNC_CTL_BYTES_TYPE_LENGTH);
  *pData_field_len = SYS_FUNC_CTL_BYTES_TYPE_LENGTH + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadAlarmCtlHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t reserved_bytes = 2;
  memcpy(pOutputData, &sys_alarm_ctl_bytes_g, SYS_ALARM_CTL_BYTES_TYPE_LENGTH);
  *pData_field_len = SYS_ALARM_CTL_BYTES_TYPE_LENGTH + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadAlarmSendHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t reserved_bytes = 2;
  memcpy(pOutputData, &sys_alarm_send_bytes_g, SYS_ALARM_SEND_BYTES_TYPE_LENGTH);
  *pData_field_len = SYS_ALARM_SEND_BYTES_TYPE_LENGTH + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadAlarmCtlSend_2Handler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
	uint8_t reserved_bytes = 0;
	memcpy(pOutputData, &sys_alarm_ctl_bytes_g, SYS_ALARM_CTL_BYTES_TYPE_LENGTH);
  memcpy(&pOutputData[SYS_ALARM_CTL_BYTES_TYPE_LENGTH], &sys_alarm_send_bytes_g, SYS_ALARM_SEND_BYTES_TYPE_LENGTH);
  *pData_field_len = SYS_ALARM_CTL_BYTES_TYPE_LENGTH + SYS_ALARM_SEND_BYTES_TYPE_LENGTH + 
		UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadValveCtlHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t reserved_bytes = 2;
  memcpy(pOutputData, &valve_ctl_bytes_g, VALVE_CTL_LENGTH);
  *pData_field_len = VALVE_CTL_LENGTH + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadValveCtl_2Handler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
	uint8_t reserved_bytes = 0;
  memcpy(pOutputData, &valve_ctl_bytes_g, VALVE_CTL_LENGTH);
  *pData_field_len = VALVE_CTL_LENGTH + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadBasicInfoHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t reserved_bytes = 0;
	uint16_t read_data_length = MASTER_BASIC_FORMAT_SIZE - SIZEOF_OF(MASTER_BASIC_PARA_T,reserve);
  memcpy(pOutputData, &master_basic_papa_g, read_data_length);
  *pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadFlowAlarmCfg_2Handler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t reserved_bytes = SIZEOF_OF(SYS_FLOW_ALARM_CFG_T,reserve);
	uint16_t read_data_length = SYS_FLOW_ALARM_CFG_FORMAT_SIZE - reserved_bytes;
  memcpy(pOutputData, &sys_flow_alarm_cfg_g, read_data_length);
  *pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadPressAlarmCfg_2Handler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t reserved_bytes = SIZEOF_OF(SYS_PRESS_ALARM_CFG_T,reserve);
	uint16_t read_data_length = SYS_PRESS_ALARM_CFG_FORMAT_SIZE - reserved_bytes;
  memcpy(pOutputData, &sys_press_alarm_cfg_g, read_data_length);
  *pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadTempAlarmCfg_2Handler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t reserved_bytes = SIZEOF_OF(SYS_TEMP_ALARM_CFG_T,reserve);
	uint16_t read_data_length = SYS_TEMP_ALARM_CFG_FORMAT_SIZE - reserved_bytes;
  memcpy(pOutputData, &sys_temp_alarm_cfg_g, read_data_length);
  *pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadBillingAlarmCfg_Handler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t reserved_bytes = SIZEOF_OF(BILLING_ALARM_CFG_T,reserve);
	uint16_t read_data_length = SYS_BILLING_ALARM_CFG_FORMAT_SIZE - reserved_bytes;
  memcpy(pOutputData, &billing_alarm_cfg_g.valve_close_ctl[0], read_data_length - 4);
  *pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadPulseFactor_2Handler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t reserved_bytes = SIZEOF_OF(CAL_PULSE_PARA_T,reserve);
	uint16_t read_data_length = SYS_CAL_PULSE_PARA_FORMAT_SIZE - reserved_bytes;
  memcpy(pOutputData, &cal_pulse_para_g, read_data_length);
  *pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadPriceCfgHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t reserved_bytes = SIZEOF_OF(LADDER_PRICE_CFG_PARA_T,reserve);
	uint16_t read_data_length = SYS_LADDER_PRICE_CFG_FORMAT_SIZE - reserved_bytes;
  memcpy(pOutputData, &ladder_price_cfg_para_new_g, read_data_length);
  *pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadGprsCfgHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t reserved_bytes = SIZEOF_OF(GPRS_NETWORK_CFG_PARA_T,reserve) + SIZEOF_OF(GPRS_NETWORK_CFG_PARA_T,aes128_secret_key);
	uint16_t read_data_length = SYS_GPRS_NETWORK_CFG_FORMAT_SIZE - reserved_bytes;
  memcpy(pOutputData, &gprs_network_cfg_para_g, read_data_length);
  *pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadAes128KeysHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t reserved_bytes = 0;
	uint16_t read_data_length = SIZEOF_OF(GPRS_NETWORK_CFG_PARA_T,aes128_secret_key) - reserved_bytes;
  memcpy(pOutputData, gprs_network_cfg_para_g.aes128_secret_key, read_data_length);
  *pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadSaveTimeCfgHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t reserved_bytes = SIZEOF_OF(SAVE_DATA_START_PARA_T,reserve);
	uint16_t read_data_length = SAVE_DATA_START_PARA_FORMAT_SIZE - reserved_bytes;
  memcpy(pOutputData, &save_day_month_timing_g, read_data_length);
  *pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadRealCumulateHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
  uint8_t reserved_bytes = 0;
	uint16_t read_data_length = SIZEOF_OF(struct measure_para,forward_cumulate_sc) + SIZEOF_OF(struct measure_para,forward_cumulate_sc) - reserved_bytes;
	memcpy(pOutputData,&sys_realtime_data_g.measure_para_s.forward_cumulate_sc,SIZEOF_OF(struct measure_para,forward_cumulate_sc));
	memcpy(&pOutputData[8],&sys_realtime_data_g.measure_para_s.forward_cumulate_wc,SIZEOF_OF(struct measure_para,forward_cumulate_sc));
  *pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
  return SUCCESS_0;
}

ErrorStatus_STM32 Uc_ReadRealParaHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
	uint8_t reserved_bytes = 0;
	uint16_t read_data_length = REALTIME_DATA_FORMAT_SIZE + 
															SIZEOF_OF(BILLING_REAL_PARA_T,price_now) + SIZEOF_OF(BILLING_REAL_PARA_T,balance_now);
	memcpy(pOutputData,&sys_realtime_data_g,REALTIME_DATA_FORMAT_SIZE);
	memcpy(&pOutputData[REALTIME_DATA_FORMAT_SIZE],
					&billing_real_para_g.price_now,SIZEOF_OF(BILLING_REAL_PARA_T,price_now));
	memcpy(&pOutputData[REALTIME_DATA_FORMAT_SIZE + SIZEOF_OF(BILLING_REAL_PARA_T,price_now)],
					&billing_real_para_g.balance_now,SIZEOF_OF(BILLING_REAL_PARA_T,balance_now));
	*pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH + reserved_bytes;
	return SUCCESS_0;
}
ErrorStatus_STM32 Uc_ReadMicroConstantHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
	uint8_t reserved_bytes = SIZEOF_OF(MICRO_CONSTANT_FLOW_PARA_T,reserve);
	uint16_t read_data_length = MICRO_CONSTANT_FLOW_FORMAT_SIZE - reserved_bytes;
	memcpy(pOutputData,&micro_constant_flow_para_g,read_data_length);
	*pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH;
	return SUCCESS_0;
}

ErrorStatus_STM32 Uc_ReadCyclicLogDataHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
	uint16_t read_data_length = SYSLOG_CYCLIC_INFO_LEN + 2 + 
		SIZEOF_OF(SYSLOG_CYCLIC_TABLE_T,data_size) + SIZEOF_OF(SYSLOG_CYCLIC_TABLE_T,data_num);
	uint16_t store_num = 0;
	for(uint8_t i = 0;i < SYSLOG_CYCLIC_INFO_NUM;i++)
	{
		store_num = (sys_log_cyclic_table[i].table_id->log_index - 1) + 
			(sys_log_cyclic_table[i].table_id->log_cyclic_full_cnt * sys_log_cyclic_table[i].data_num);
		memcpy(&pOutputData[read_data_length * i],&store_num,2);
		memcpy(&pOutputData[read_data_length * i + 2],sys_log_cyclic_table[i].table_id,SYSLOG_CYCLIC_INFO_LEN);
		memcpy(&pOutputData[read_data_length * i + 2 + SYSLOG_CYCLIC_INFO_LEN],&sys_log_cyclic_table[i].data_size,4);
	}
	*pData_field_len = read_data_length * SYSLOG_CYCLIC_INFO_NUM + UC_DATA_TABLE_BYTES_LENGTH;
	return SUCCESS_0;
}

ErrorStatus_STM32 Uc_ReadSecCorrSetHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
	uint8_t reserved_bytes = SIZEOF_OF(SECOND_ORDER_CORR_T,reserve);
	uint16_t read_data_length = SEC_ORDER_CORR_PARA_FORMAT_SIZE - reserved_bytes;
	memcpy(pOutputData,&sec_order_corr_set_g,read_data_length);
	*pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH;
	return SUCCESS_0;
}


ErrorStatus_STM32 Uc_ReadSecCorrRealHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
	uint8_t reserved_bytes = SIZEOF_OF(SECOND_ORDER_CORR_T,reserve);
	uint16_t read_data_length = SEC_ORDER_CORR_PARA_FORMAT_SIZE - reserved_bytes;
	memcpy(pOutputData,&sec_order_corr_real_g,read_data_length);
	*pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH;
	return SUCCESS_0;
}

ErrorStatus_STM32 Uc_ReadZeroDriftCfgHandler(uint8_t *pOutputData, uint16_t *pData_field_len)
{
	uint8_t reserved_bytes = SIZEOF_OF(ZERO_DRIFT_CORR_CFG_T,reserve);
	uint16_t read_data_length = ZERO_DRIFT_CFG_SIZE - reserved_bytes;
	memcpy(pOutputData,&zero_drift_cfg_g,read_data_length);
	*pData_field_len = read_data_length + UC_DATA_TABLE_BYTES_LENGTH;
	return SUCCESS_0;
}

/*ÉÏλ»ú¶ÁÊý¾Ý·µ»Ø´¦Àíº¯Êý*/
void Upper_ComputerReadResultProcess(ErrorStatus_STM32 result_state, uint8_t *pData, UC_RECV_DATA_UNION_T *uc_recv_union_p)
{

  /*°ÑÖ¡Í·½á¹¹ÌåÊý¾Ý¿½±´µ½·¢ËÍÊý×é*/
  memcpy(pData, &uc_recv_union_p->uc_protocol_head_s, UC_PROTOCOL_HEAD_LENGTH);
  /*¹¹ÔìÊý¾ÝÓò±íºÅ*/
  pData[UC_PROTOCOL_HEAD_LENGTH] = uc_recv_union_p->uc_recv_buf[12];
  pData[UC_PROTOCOL_HEAD_LENGTH + 1] = uc_recv_union_p->uc_recv_buf[13];
  if (result_state == ERROR_1)
    memset(&pData[UC_PROTOCOL_HEAD_LENGTH + 2], 0, uc_recv_union_p->uc_protocol_head_s.data_field_length - 2); // ³ýÁ˱íºÅµÄÊý¾ÝÓò²¿·Ö½o0
}

/*ÉÏλ»ú¶ÁÊý¾Ý´¦Àíº¯Êý*/
ErrorStatus_STM32 Upper_ComputerReadProcess(uint16_t work_permissions, uint16_t table_id, uint8_t *pOutput)
{
  ErrorStatus_STM32 read_result_flag = ERROR_1;
  // ²é±í
  for (uint8_t i = 0; i < UC_RECV_READ_TABLE_NUM; i++)
  {
    if (uc_recv_read_tab_func[i].uc_data_table == table_id && uc_recv_read_tab_func[i].UcRecvReadFuncHandler != NULL)
    {
      if ((work_permissions & uc_recv_read_tab_func[i].func_admin_user) != 0) // Óû§È¨ÏÞÅжÏ
      {
        /*ģʽȨÏÞÅжÏ*/
				if(uc_recv_read_tab_func[i].func_admin_mode & sys_display_para_g.sys_and_display_mode)
					 read_result_flag = uc_recv_read_tab_func[i].UcRecvReadFuncHandler(pOutput,
																																						&uc_recv_para_g.uc_recv_buf_union.uc_protocol_head_s.data_field_length);
      }
      else
      {
      }
      break;
    }
  }
  return read_result_flag;
}