#include "master_slave_inter.h"
#include "uart.h"
#include "mbcrc.h"
#include "string.h"
#include "tim.h"
#include "check_out.h"
#include "dma.h"
#include "low_pwr_test.h"
#include "rtc.h"
#include "power_manage.h"
#include "math.h"
#include "delay.h"
#include "gpio.h"
#include "test_log.h"


TYPE_CHECK_SIZE(MICRO_CONSTANT_FLOW_PARA_T,38);//ºË²é½á¹¹Ìå´óС	
MICRO_CONSTANT_FLOW_PARA_T micro_constant_flow_para_g =
{
	.micro_flow_time_start_bcd = {0},
	.micro_flow_time_end_bcd = {0x23,0x59},
	.micro_flow_once_duration_min = 240,
	.micro_flow_threshold = 1000 * G10_FLOW_MIN,
	.micro_flow_duration_days = 3,
	
	.constant_flow_time_start_bcd = {0},
	.constant_flow_time_end_bcd = {0x23,0x59},
	.constant_flow_once_duration_min = 120,
	.constant_flow_threshold_down = 1000 * G10_FLOW_MIN,
	.constant_flow_threshold_up = 1200 * G10_FLOW_MAX,
	.constant_flow_duration_days = 1,
};

TYPE_CHECK_SIZE(ZERO_DRIFT_CORR_CFG_T,7);//ºË²é½á¹¹Ìå´óС
ZERO_DRIFT_CORR_CFG_T zero_drift_cfg_g = {SET,{0,0}};

void Measure_IO_Init(void)
{
	CMU_PERCLK_SetableEx(PADCLK, ENABLE);  //PADʱÖÓ£¨GPIO£©Ê¹Äܺ¯Êý
	
	OutputIO(MEASURE_PWR_PORT,MEASURE_PWR_PIN,OUT_PUSHPULL);
	OutputIO(MAIN_TO_SLAVE_PORT,MAIN_TO_SLAVE_PIN,OUT_PUSHPULL);
	OutputIO(SYNC_PORT,SYNC_PIN,OUT_PUSHPULL);
	
	SLAVE_PWR_OFF;
	SLAVE_SYNC(RESET);
	SLAVE_CONNECT(RESET);
}


/*´Ó»úдÊý¾Ý³¤¶È*/
uint8_t Slave_Write_DataLength(uint8_t data_table)
{
  uint8_t len = CMD_DATATABLE_CRC_LENGTH;
  switch (data_table)
  {
  case SC_SYS_RST:
    len += ONE_BYTE_DATA_LENGTH;
    break;
  case SC_SYS_UPDATA:
    break;
  case SC_RW_HARDWARE:
    len += WRITE_HARDWARE_DATA_LENGTH;
    break;
  case UT_RW_CAL:
    len += WRITE_UT_CAL_DATA_LENGTH;
    break;
  case UT_RW_ERR_TH:
    len += WRITE_UT_ERR_TH_DATA_LENGTH;
    break;
  case CAL_MODE_ENTER:
    len += ONE_BYTE_DATA_LENGTH;
    break;
  case CAL_MODE_EXIT:
    len += ONE_BYTE_DATA_LENGTH;
    break;
  case PARA_MODE_ENTER:
    len += ONE_BYTE_DATA_LENGTH;
    break;
  case PARA_MODE_EXIT:
    len += ONE_BYTE_DATA_LENGTH;
    break;
  case UART_RW_PARA:
    len += WRITE_UART_DATA_LENGTH;
    break;
  default:
    break;
  }
  return len;
}
/*
д´Ó»úÊý¾Ý
data_table £ºÊý¾Ý±í
pBuffer £º¾ßÌåÊý¾ÝÄÚÈÝ
*/
static uint8_t rw_buffer_g[255] = {0};
void Send_Write_Slave_Command(uint8_t data_table, uint8_t *pBuffer, uint16_t data_len)
{
  uint8_t buffer[2] = {SC_DATA_WR, data_table};
  uint16_t write_buffer_length = CMD_DATATABLE_CRC_LENGTH + data_len;
  uint16_t crc_temp = 0;
	Main2Slave_GPIO_Usart3_Clk_Init();
  /*¹¹ÔìÖ¡Í·*/
  memcpy(rw_buffer_g, buffer, 2);
  /*¹¹ÔìÖ¡Êý¾ÝÄÚÈÝ*/
  memcpy(&rw_buffer_g[2], pBuffer, data_len);
  /*¹¹ÔìCRCУÑé*/
  crc_temp = usMBCRC16(0xFFFF,rw_buffer_g, write_buffer_length - 2);
  rw_buffer_g[write_buffer_length - 2] = crc_temp;
  rw_buffer_g[write_buffer_length - 1] = crc_temp >> 8;

  //	printf("write_send = ");
  //	for (uint8_t i = 0; i < write_buffer_length; i++)
  //		printf("%02X ", write_buffer_g[i]);

	Measure_DMA_CH1_Reload();
  SLAVE_CONNECT(SET); // »½ÐÑ´Ó»ú
  delay_ms(2);
  SLAVE_CONNECT(RESET);
	
  // ÆôÓÃ×èÈû·¢ËÍ
  return MASTER_SEND_NORMAL(rw_buffer_g, write_buffer_length);
}
/*¶Á´Ó»úÊý¾Ý*/
void Send_Read_Slave_Command(uint8_t data_table)
{
  uint16_t crc_temp = 0;
	Main2Slave_GPIO_Usart3_Clk_Init();
	rw_buffer_g[0] = SC_DATA_RD;
	rw_buffer_g[1] = data_table;
  crc_temp = usMBCRC16(0xFFFF,rw_buffer_g, 2);
  rw_buffer_g[2] = crc_temp;
  rw_buffer_g[3] = crc_temp >> 8;

  //	printf("read_send = ");
  //	for (uint8_t i = 0; i < 4; i++)
  //		printf("%02X ", buffer[i]);
	Measure_DMA_CH1_Reload();
  SLAVE_CONNECT(SET); // »½ÐÑ´Ó»ú
  delay_ms(2);
  SLAVE_CONNECT(RESET);
  //	//ÆôÓ÷Ç×èÈûʽ£¨ÖжÏʽ£©·¢ËÍÊý¾Ý£¨ÒÔºó¸ÄÓÃDMA·¢ËÍ£©
  //	return HAL_UART_Transmit_IT(&huart1,buffer,4);
	return MASTER_SEND_NORMAL(rw_buffer_g,CMD_DATATABLE_CRC_LENGTH);
//		return HAL_UART_Transmit(&huart1, rw_buffer_g, CMD_DATATABLE_CRC_LENGTH, 200);// ÆôÓÃ×èÈûʽ
}

ErrorStatus_STM32 sys_mode_conversion_show_g = SUCCESS_0;
/*Ö÷´ÓϵͳģʽÇл»³ÌÐò*/
void Master_Slave_SysModeConversionProcess(SYS_DISPLAY_PAPA_T *sys_display_para_p)
{
  uint8_t sys_mode_cmd[1],temp;
  uint16_t ms_cnt = 500;                    // Ñ­»·µÄºÁÃëÖµ£¬²»¿ÉÐ޸ĸüС
  SYS_DISPLAY_MODE sys_mode_result;         // ϵͳģʽ½á¹û
  INTER_STATUS result_code = INTER_UNKNOWN; // ´Ó»ú·µ»Ø½á¹û
#ifdef NO_SLAVE_SET_MODE_TEST
  uint8_t slave_result_data[] = {0x52, 0, 0x3C, 0xD0};
#endif
  switch (sys_display_para_p->temp_sys_mode_flag)
  {
  case CNV_PARA_MODE_ENTER:
    sys_mode_cmd[0] = PARA_MODE_ENTER;
    sys_mode_result = SET_PARA_MODE;
    break;
  case CNV_CAL_MODE_ENTER:
    sys_mode_cmd[0] = CAL_MODE_ENTER;
    sys_mode_result = CALIB_MODE;
    break;
  case CNV_PARA_MODE_EXIT:
    sys_mode_cmd[0] = PARA_MODE_EXIT;
    sys_mode_result = NORMAL_MODE;
    break;
  case CNV_CAL_MODE_EXIT:
    sys_mode_cmd[0] = CAL_MODE_EXIT;
    sys_mode_result = NORMAL_MODE;
    break;
	case CNV_DISPLAY_MODE_ENTER:
		sys_mode_result = DISPLAY_PARA;
		break;
	case CNV_DISPLAY_MODE_EXIT:
		sys_mode_result = NORMAL_MODE;
  default:
    break;
  }
	if(sys_display_para_p->temp_sys_mode_flag == CNV_DISPLAY_MODE_ENTER || 
			sys_display_para_p->temp_sys_mode_flag == CNV_DISPLAY_MODE_EXIT)
	{
		result_code = INTER_OK;
	}
	else
	{
		Send_Write_Slave_Command(sys_mode_cmd[0], sys_mode_cmd, ONE_BYTE_DATA_LENGTH);
		while (--ms_cnt)//µÈ´ý´Ó»ú·µ»ØµÄ³¬Ê±Ê±¼ä µ¥Î»£ºms£¨ÔÝÓÃÑÓ³Ù£¬ÒÔºó¿ÉÓö¨Ê±Æ÷CNTÖµ£©
		{
			/*Âß¼­ÎªµÈ´ýXXºÁÃ룬ÔÚ´ËÆڼ䴩²åÅж¨DMAÊÇ·ñÍê³É*/
			/*µ±ÔڵȴýµÄXXºÁÃëÄÚ£¬¿ªÊ¼½ÓÊÕµ½Êý¾Ý£¬ÅжÏDMAÔÚ20ºÁÃëÄÚÊÇ·ñµØÖ·Æ«ÒÆÍê±Ï£¬Íê±ÏÔò³É¹¦*/
			delay_ms(1);
			if(Measure_Uart3_Rx_DMA_CH1_Check(20) == SUCCESS_0) //ºË²éÊý¾ÝÊÇ·ñ´«ÊäÍê³É
				break;
		}
#ifdef NO_SLAVE_SET_MODE_TEST
		inter_recv_para_g.inter_recv_flag = SET;
		inter_recv_para_g.inter_recv_length = sizeof(slave_result_data);
		memcpy(inter_recv_para_g.inter_recv_union.inter_recv_buf, slave_result_data, inter_recv_para_g.inter_recv_length);
#endif
		result_code = Slave_Result_Handler(INTER_DATA_WRITE, &inter_recv_para_g);
	}
  sys_display_para_p->temp_sys_mode_flag = CNV_NONE;
  if (result_code == INTER_OK)
  {
    sys_mode_conversion_show_g = SUCCESS_0;
#ifdef RS232_PRINTF		
    LOG_D("Çл»Ä£Ê½³É¹¦\r\n");
#endif		
    sys_display_para_p->sys_and_display_mode = sys_mode_result;
		if(sys_display_para_p->sys_and_display_mode == NORMAL_MODE)
			temp = 0;
		else if(sys_display_para_p->sys_and_display_mode == DISPLAY_PARA)
			temp = 3;
		else if(sys_display_para_p->sys_and_display_mode == CALIB_MODE)
			temp = 1;
		else if(sys_display_para_p->sys_and_display_mode == SET_PARA_MODE)
			temp = 2;
		__SYS_STATUS_BYTES_STATUS(work_state, temp, AV_NORMAL);
    if (sys_display_para_p->sys_and_display_mode == CALIB_MODE) // ¼ì¶¨Ä£Ê½Ïà¹Ø²ÎÊý³õʼ»¯
    {
			pwr_vol_g.lith_flag  = LMS_OPEN_VALVE_BEFORE;//½øÈë¼ì¶¨Ä£Ê½Ö®Ç°ÐèÒªÏÈ¿ª·§£¬ÏÈ¿ª·§Ö®Ç°ÐèÒªÅжϵçѹ
			cal_mode_force_exit_cnt_g = cal_mode_exit_cnt_g = 0;
//      auto_exit_start_min_time_g = Bcd_2_Hex(calendar_g.hour) * 60 + Bcd_2_Hex(calendar_g.minute);
			Pulse_Awaken_Init();
			NVIC_DisableIRQ(RTC_IRQn);// ¹Ø±ÕRTCÖжÏ		
			CalMode_BasicTimer_Clk_Init();
			BTx_CR1_CHEN_Setable(BT1,ENABLE); //Æô¶¯»ù´¡¶¨Ê±Æ÷
			LPTIM_CR_EN_Setable(DISABLE); //¹Ø±ÕµÍ¹¦ºÄ¶¨Ê±Æ÷
    }
    else
		{
			cal_mode_exit_save_cumulate_flag_g = 1;

			NVIC_SetPriority(RTC_IRQn,1);//¿ªÆôRTCÖжÏ
			NVIC_EnableIRQ(RTC_IRQn);	
			
			BTx_CR1_CHEN_Setable(BT1,DISABLE);
			LPTIM_CR_EN_Setable(ENABLE);

		}  
    if (sys_display_para_p->sys_and_display_mode == NORMAL_MODE) // ÆÕͨģʽÏà¹Ø²ÎÊý³õʼ»¯
    {
			cal_display_exit_data_g = temp_data_g = 0;
      sys_display_para_p->display_page_status.normal_page_status = SC_INSTANT_TOTAL; // ÿ´ÎÇл»ÆÕͨģʽ¶¼ÓɵÚÒ»¸öÒ³ÃæÏÔʾ
      __SYS_DELAY_SEC_FLAG_CLEAR_(sys_active_time);                                  // Çå³ýϵͳ¼¤»îʱ¼ä±ê־λ
      __SYS_DELAY_SEC_TIME_SET_(sys_active_time, SYS_WAKE_UP_TIME);                  // ÉèÖû½ÐÑʱ¼äÃëÊý
    }
    if (sys_display_para_p->sys_and_display_mode == SET_PARA_MODE)
      auto_exit_start_min_time_g = Bcd_2_Hex(calendar_g.Hour) * 60 + Bcd_2_Hex(calendar_g.Minute);
		if (sys_display_para_p->sys_and_display_mode == DISPLAY_PARA)
		{
			sys_display_para_g.display_page_status.para_page_status = METER_NUM; //ÿ´ÎÇл»µ½ÏÔʾ²ÎÊý¶¼ÓɵÚÒ»¸öÒ³Ã濪ʼ
			__SYS_DELAY_SEC_TIME_SET_(sys_active_time, DISPLAY_PARA_TIME);       // ÉèÖû½ÐÑʱ¼äÃëÊý
		}
				
  }
  else
  {
    /*½øÐдíÎó´¦Àí*/
    sys_mode_conversion_show_g = ERROR_1;
  }
}
/*´Ó»ú½»»¥Ð£×¼Á÷Á¿Êý¾Ý´¦Àí³ÌÐò*/
void Slave_Inter_Cal_FlowDataProcess(void)
{
  uint16_t time;
  /*200/500ms£¨ÊÓÇé¿ö£©»ñÈ¡Ò»´ÎÁ÷Á¿*/
  if (1) // ±ê־λ´ý¶¨
  {
    uint16_t ms_cnt = check_cal_g.work_period - 24; // Ñ­»·µÄºÁÃëÖµ
    INTER_STATUS result_code = INTER_UNKNOWN;
		/*ÏÈ´¦Àí£¬ÔÙ·¢ËÍ*/
		result_code = Slave_Result_Handler(INTER_DATA_READ, &inter_recv_para_g); // ´Ó»ú·µ»Ø½á¹û´¦Àí
		if(result_code == INTER_OK)
			cal_display_exit_data_g = temp_data_g;
		else
			cal_display_exit_data_g = 0.0f;
    Send_Read_Slave_Command(SC_RO_CAL_RESULT); // ·¢ËÍÏà¹ØÃüÁî
    /*µ±ÓÐÁ÷Á¿Ê±£¬ÖØи³Öµ£¬ÓÃÓÚÎÞÁ÷Á¿³¬Ê±Í˳ö¼ì¶¨Ä£Ê½*/
    // Ö±½Ó¸ù¾ÝÊý¾ÝÊä³ö,ÉÏÒ»´ÎµÄÊý¾Ý
    /*Êý¾Ý´úÈëÒ»¸öº¯Êý¼ÆËã±ê¿öºÍÂö³åÊä³öʱ¼ä*/
    time = led_pluse_out(temp_data_g);
		if (get_led_para_output_flag() == 0)
    {
      while (ms_cnt--)
      {
        delay_ms(1);
				if(Measure_Uart3_Rx_DMA_CH1_Check(10) == SUCCESS_0) //ºË²éÊý¾ÝÊÇ·ñ´«ÊäÍê³É
					break;
      }
    }
    else
    {
      if(time < (check_cal_g.work_period - 24))
			{
				ms_cnt = check_cal_g.work_period - 24 - time;
				while (ms_cnt--)
				{
					delay_ms(1);
					if(Measure_Uart3_Rx_DMA_CH1_Check(10) == SUCCESS_0) //ºË²éÊý¾ÝÊÇ·ñ´«ÊäÍê³É
						break;
				}
			}
			
      set_led_para_output_flag(0);
			
    }
		
  }
}

/*´Ó»ú½»»¥ÆÕͨÁ÷Á¿Êý¾Ý´¦Àí³ÌÐò*/
void Slave_Inter_Normal_FlowDataProcess(SYS_DELAY_SEC_PARA_T *sys_delay_sec_para_p)
{
//  static int temp_cnt = 0;
	static uint16_t inter_alarm_cnt = 0;
  if (sys_delay_sec_para_p->flow_data_period_para.delay_flag == SET) // ÉèÖõĻñÈ¡Á÷Á¿Êý¾ÝÖÜÆÚʱ¼äµ½
  {
    uint16_t ms_cnt = 20;
    INTER_STATUS result_code = INTER_UNKNOWN;
#ifdef NO_SLAVE_GET_FLOW_DATA_TEMP
    uint8_t get_flow_data_temp[] = {0x42, 0x3A,             // ÃüÁî + Êý¾ÝÂë
                                    0x02, 0x00, 0x00, 0x00, // ״̬×Ö1_2
                                    0x71, 0x3D, 0xD6, 0x41, // ζÈ
                                    0xA4, 0xB0, 0xCA, 0x42, // ѹÁ¦
																		0x79, 0xE9, 0xF6, 0x42, // ·ÉÐÐʱ¼äA
																		0x79, 0xE9, 0xF6, 0x42, // ·ÉÐÐʱ¼äB
																		0x79, 0xE9, 0xF6, 0x42, // ʱ¼ä²î
                                    0x99, 0x99, 0x50, 0x50, // ÐźÅÇ¿¶ÈABºÍÔöÒæAB
																		0x11, 0x22,//ÐÅÔë±ÈAB
                                    0x11, 0x11, 0x11, 0x11, // ´¥·¢ÏßAB
                                    0, 0, 0xAA, 0x43,       // ÉùËÙ
                                    0xDA, 0x0F, 0x49, 0x40, // Á÷ËÙ
                                    0x03,                   // ¹¤¿ö×éÊý
                                    0xDC, 0xBB, 0x60, 0x3B, // ˲ʱ¹¤¿ö1
                                    0x60, 0xF5, 0x74, 0x3B, // ˲ʱ¹¤¿ö2
                                    0x92, 0x97, 0x84, 0x3B, // ˲ʱ¹¤¿ö3
                                    0x51, 0x1B};            // CRCУÑé
#endif
    sys_delay_sec_para_p->flow_data_period_para.delay_flag = RESET; // Çå³ý±ê־λ
		/*ÖØÐÂÉèÖÃÖÜÆÚʱ¼ä*/
    __SYS_DELAY_SEC_TIME_SET_(flow_data_period_para, GET_FLOW_DATA_PERIOD_TIME);
		
    Send_Read_Slave_Command(SC_RO_RESULT); // ·¢ËÍÏà¹ØÃüÁî
		/*²»ÐèÒª´Ó»ú£¬×Ô¶¯»ñµÃÁ÷Á¿µÄ²âÊÔ*/
#ifdef NO_SLAVE_GET_FLOW_DATA_TEMP
    inter_recv_para_g.inter_recv_flag = SET;
    inter_recv_para_g.inter_recv_length = sizeof(get_flow_data_temp);
    memcpy(inter_recv_para_g.inter_recv_union.inter_recv_buf, get_flow_data_temp, inter_recv_para_g.inter_recv_length);
#endif
    while (ms_cnt--)
    {
      delay_ms(1);
			if(Measure_Uart3_Rx_DMA_CH1_Check(20) == SUCCESS_0) //ºË²éÊý¾ÝÊÇ·ñ´«ÊäÍê³É
				break;
    }
    result_code = Slave_Result_Handler(INTER_DATA_READ, &inter_recv_para_g); // ´Ó»ú·µ»Ø½á¹û´¦Àí
		if (result_code == INTER_OK) // »ñÈ¡Á÷Á¿Êý¾ÝÕýÈ·
    {
			inter_alarm_cnt = 0;
			__SYS_STATUS_BYTES_STATUS(measure_err,RESET,AV_MEASURE_ERR);
      State_Alarm_Bytes_TempPressDataHandler(&sys_realtime_data_g.measure_para_s);
    }else
		{
			/*½øÐг¬Ê±´¦Àí*/
      SLAVE_SYNC_CMD;
//      LOG_D("µÚ%dʱ¼ä¶ÔÆë  RTC = %02X-%02X-%02X%\r\n",temp_cnt++,calendar_g.hour,calendar_g.minute,calendar_g.second);
			inter_alarm_cnt += GET_FLOW_DATA_PERIOD_TIME;
			if(inter_alarm_cnt > 180)
			{
				inter_alarm_cnt = 0;
				__SYS_STATUS_ALARM_BYTES_SET(measure_err);
			}	
		}
  }
}
/*ÎÂѹÊý¾Ý״̬/±¨¾¯×Ö´¦Àí*/
void State_Alarm_Bytes_TempPressDataHandler(struct measure_para *sys_realtime_data_p)
{
	static uint8_t cl_have_flow_judge_cnt = 0;
	float press_temp = sys_realtime_data_p->pressure,temp_temp = sys_realtime_data_p->temperature;
	float  __attribute__ ((aligned (4))) pree_align_data = sys_realtime_data_p->pressure,temp_align_data = sys_realtime_data_p->temperature;
  // ÔÚÅжÏÁ÷Á¿Ö®Ç°ÒªÏÈÅжϷ§ÃÅ״̬
  if (__SYS_STATUS_BYTES_GET(valve_state) == VALVE_CL)
	{
		if(++cl_have_flow_judge_cnt > 3)
		{
			if(sys_realtime_data_p->instant_wc >= sys_device_flow_min_g)
				__SYS_STATUS_ALARM_BYTES_SET(cl_have_flow);
			else
				__SYS_STATUS_BYTES_STATUS(cl_have_flow, RESET, AV_CL_HAVE_FLOW);
		}
	}
  else
	{
		cl_have_flow_judge_cnt = 0;
		__SYS_STATUS_BYTES_STATUS(cl_have_flow, RESET, AV_CL_HAVE_FLOW);
	}
  /*´¦ÀíÎÂѹÊÇ·ñÒì³£*/
//  if (sys_realtime_data_p->temperature != SYS_TEMP_ERROR_VALUE) // ζÈÕý³£
//  {
//		__SYS_STATUS_BYTES_STATUS(temp_err, RESET, AV_TEMP_ERR);
//	}
//	else
//		__SYS_STATUS_ALARM_BYTES_SET(temp_err);
	if(__SYS_STATUS_BYTES_GET(temp_err) == RESET) // ζÈÕý³£
	{
		// У׼ζÈ
		if (__SYS_FUNC_CFG_BYTES_GET(temp_corrected_manage) == 0)
		{
			sys_realtime_data_p->temp_amend = LINEAR_FUNC_OF_ONE_VARIABLE(sys_temp_alarm_cfg_g.temp_correction_factor,
				sys_temp_alarm_cfg_g.temp_intercept, sys_realtime_data_p->temperature);
			temp_temp = sys_realtime_data_p->temp_amend;
		}  
		if (temp_temp < sys_temp_alarm_cfg_g.temp_up_value &&
				temp_temp > sys_temp_alarm_cfg_g.temp_down_value) // Õý³£ÎÂ¶È temp_down < temp_now < temp_up
		{
			/*ζÈÕý³£Òª°Ñ³¬ÏÞ״̬Çå³ý*/	
			__SYS_STATUS_BYTES_STATUS(temp_up, RESET, AV_TEMP_UP);
			__SYS_STATUS_BYTES_STATUS(temp_up_up, RESET,AV_TEMP_UP_UP);
			__SYS_STATUS_BYTES_STATUS(temp_down, RESET, AV_TEMP_DOWN);	
			__SYS_STATUS_BYTES_STATUS(temp_down_down, RESET,AV_TEMP_DOWN_DOWN);
		}
		else
		{
			/*ζȳ¬ÉÏÉÏÏÞ*/
			if (temp_temp >= sys_temp_alarm_cfg_g.temp_up_up_value)
			{
				__SYS_STATUS_ALARM_BYTES_SET(temp_up);
				__SYS_STATUS_ALARM_BYTES_SET(temp_up_up);
				temp_temp = sys_temp_alarm_cfg_g.temp_up_up_replace;
			}
			else if (temp_temp >= sys_temp_alarm_cfg_g.temp_up_value)
				__SYS_STATUS_ALARM_BYTES_SET(temp_up);
			/*ζȵÍÏÂÏÂÏÞ*/
			if (temp_temp <= sys_temp_alarm_cfg_g.temp_down_down_value)
			{				
				__SYS_STATUS_ALARM_BYTES_SET(temp_down);
				__SYS_STATUS_ALARM_BYTES_SET(temp_down_down);
				temp_temp = sys_temp_alarm_cfg_g.temp_down_scope;
			}
			else if (temp_temp <= sys_temp_alarm_cfg_g.temp_down_value)
				__SYS_STATUS_ALARM_BYTES_SET(temp_down);
		}
		/*¸÷ÖÖÇé¿öÅжÏÍêµÄζÈÖµ*/
		sys_realtime_data_p->temperature = temp_temp;
		// 10´ÎÕý³£Î¶ÈÇó¾ùÖµ
		if (__SYS_FUNC_CFG_BYTES_GET(temp_err_manage) == 0)
			sys_realtime_data_p->temp_avg = LowPassFilter_Ring_Average(&temp_ring, 
				&temp_align_data, 1, TEMP_RING_BUFFER_SIZE);
	}
  else
    sys_realtime_data_p->temperature = sys_realtime_data_p->temp_avg; // ¸ø¾ùÖµÏÔʾ

//  if (sys_realtime_data_p->pressure != SYS_PRESS_ERROR_VALUE) // ѹÁ¦Õý³£
//  {
//		__SYS_STATUS_BYTES_STATUS(press_err, RESET, AV_PRESS_ERR);
//	}
//	else
//		__SYS_STATUS_ALARM_BYTES_SET(press_err);
    
	if(__SYS_STATUS_BYTES_GET(press_err) == RESET)
	{
		/*ѹÁ¦ÐÞÕý¿ªÆô*/
		if (__SYS_FUNC_CFG_BYTES_GET(press_corrected_manage) == 0)
		{
			sys_realtime_data_p->press_amend = LINEAR_FUNC_OF_ONE_VARIABLE(sys_press_alarm_cfg_g.press_correction_factor,
				sys_press_alarm_cfg_g.press_intercept, sys_realtime_data_p->pressure);
			press_temp = sys_realtime_data_p->press_amend;
		}
    if (press_temp < sys_press_alarm_cfg_g.press_up_value &&
        press_temp > sys_press_alarm_cfg_g.press_down_value) // Õý³£Ñ¹Á¦ press_down < press_now < press_up
    {
      /*ѹÁ¦Õý³£Òª°Ñ³¬ÏÞ״̬Çå³ý*/
      
      __SYS_STATUS_BYTES_STATUS(press_down, RESET, AV_PRESS_DOWN);
			__SYS_STATUS_BYTES_STATUS(press_down_down, RESET,AV_PRESS_DOWN_DOWN);
      __SYS_STATUS_BYTES_STATUS(press_up, RESET, AV_PRESS_UP);
			__SYS_STATUS_BYTES_STATUS(press_up_up, RESET,AV_PRESS_UP_UP);
    }
    else
    {
      /*ѹÁ¦³¬ÉÏÉÏÏÞ*/
      if (press_temp >= sys_press_alarm_cfg_g.press_up_up_value)
      {
        __SYS_STATUS_ALARM_BYTES_SET(press_up);
				__SYS_STATUS_ALARM_BYTES_SET(press_up_up);
				press_temp = (sys_press_alarm_cfg_g.press_up_scope - BARO_PRESS) * 1.2f + BARO_PRESS;//³¬ÏÞ´úÌæ
      }
      else if (press_temp >= sys_press_alarm_cfg_g.press_up_value) //ѹÁ¦³¬ÉÏÏÞ
				__SYS_STATUS_ALARM_BYTES_SET(press_up);
      
      /*ѹÁ¦µÍÏÂÏÂÏÞ*/
      if (press_temp <= sys_press_alarm_cfg_g.press_down_down_value)
      {
        __SYS_STATUS_ALARM_BYTES_SET(press_down);
				__SYS_STATUS_ALARM_BYTES_SET(press_down_down);
      }
      else if (press_temp <= sys_press_alarm_cfg_g.press_down_value) //ѹÁ¦µÍÏÂÏÞ
        __SYS_STATUS_ALARM_BYTES_SET(press_down);
    }
		/*¸÷ÖÖÇé¿öÅжÏÍêµÄѹÁ¦Öµ*/
		sys_realtime_data_p->pressure = press_temp;
		/*ѹÁ¦¹ÊÕÏ´¦Àí¿ªÆô*/
		if (__SYS_FUNC_CFG_BYTES_GET(press_err_manage) == 0)
			sys_realtime_data_p->press_avg = LowPassFilter_Ring_Average(&press_ring, 
				&pree_align_data, 1, PRESS_RING_BUFFER_SIZE);		
	}
  else
    sys_realtime_data_p->pressure = sys_realtime_data_p->press_avg; // ¸ø¾ùÖµÏÔʾ
}


/*Á÷Á¿Êý¾Ý״̬/±¨¾¯×Ö´¦Àí*/
void State_Alarm_Bytes_FlowDataHandler(float instant_wc,struct measure_para *sys_realtime_data_p_p)
{
	if (sys_realtime_data_p_p->forward_cumulate_sc > LCD_SHOW_NUM_MAX * 0.9)
		__SYS_STATUS_ALARM_BYTES_SET(lcd_up);
	else
		__SYS_STATUS_BYTES_STATUS(lcd_up, RESET, AV_LCD_UP);
	/*˲ʱ¹¤¿öƽ¾ùÖµ*/
	sys_realtime_data_p_p->instant_wc_avg = LowPassFilter_MaxMin_Ring_Average(&flow_ring, &instant_wc, 1, FLOW_RING_BUFFER_SIZE);
	/*´¦ÀíÁ÷Á¿ÊÇ·ñÒì³£*/
	if (sys_realtime_data_p_p->instant_wc_avg < (-sys_device_flow_qt_g)) // ÄæÁ÷£¨Ò»¶Îʱ¼äÄÚµÄƽ¾ùֵСÓÚ -Qt£©
		__SYS_STATUS_ALARM_BYTES_SET(flow_direction);
	else
	{
		__SYS_STATUS_BYTES_STATUS(flow_direction, RESET, AV_FLOW_DIRECTION);
		if (sys_realtime_data_p_p->instant_wc_avg < sys_flow_alarm_cfg_g.sys_flow_up_1) // Á÷Á¿Õý³£
		{
			__SYS_STATUS_BYTES_STATUS(flow_up_1, RESET, AV_FLOW_UP_1);
			__SYS_STATUS_BYTES_STATUS(flow_up_2, RESET, AV_FLOW_UP_2);
			__SYS_STATUS_BYTES_STATUS(flow_up_3, RESET, AV_FLOW_UP_3);
		}
		else if (sys_realtime_data_p_p->instant_wc_avg < sys_flow_alarm_cfg_g.sys_flow_up_2) // flow_up_1 <= flow_now < flow_up_2
			__SYS_STATUS_ALARM_BYTES_SET(flow_up_1);
		else if (sys_realtime_data_p_p->instant_wc_avg < (sys_device_flow_max_g * SYS_FLOW_UP_3_VALUE)) // flow_up_2 <= flow_now < flow_up_3
		{
			__SYS_STATUS_ALARM_BYTES_SET(flow_up_1);
			__SYS_STATUS_ALARM_BYTES_SET(flow_up_2);
		}
		else
		{
			__SYS_STATUS_ALARM_BYTES_SET(flow_up_1);
			__SYS_STATUS_ALARM_BYTES_SET(flow_up_2);
			__SYS_STATUS_ALARM_BYTES_SET(flow_up_3);
		}	
	}
}
/******************************************
 * func: State_Alarm_Bytes_FlowMicroHandler
 * desc: ΢СÁ÷Á¿´¦Àí
 * input:  instant_sc_1000 ˲ʱ±ê¿öÁ÷Á¿·Å´ó1000±¶
 *         realtime_hour_min_bcd ʵʱʱ¼ä,ʱ·Ö
 * output: none
 * return: none
 *****************************************/
void State_Alarm_Bytes_FlowMicroHandler(uint32_t instant_sc_1000,uint16_t realtime_hour_min_bcd,MICRO_CONSTANT_FLOW_PARA_T * flow_p)
{
	static FlagStatus mirco_flow_days_flag = RESET;
	static uint8_t mirco_flow_days_cnt = 0;
	static uint32_t micro_flow_per_sec_cnt = 0;
	
	uint16_t micro_flow_time[2] = {(flow_p->micro_flow_time_start_bcd[0] << 8 | flow_p->micro_flow_time_start_bcd[1]),
		(flow_p->micro_flow_time_end_bcd[0] << 8 | flow_p->micro_flow_time_end_bcd[1])};
	if(DAILY_ZERO) 
	{
		mirco_flow_days_flag = RESET;
		micro_flow_per_sec_cnt = 0;	
	}
		
	if((realtime_hour_min_bcd >= micro_flow_time[0]) && (realtime_hour_min_bcd <= micro_flow_time[1]))
	{
		uint32_t micro_flow_once_duration_sec = flow_p->micro_flow_once_duration_min * 60;
		if(instant_sc_1000 >= (sys_device_flow_min_g * 1000) && instant_sc_1000 <= flow_p->micro_flow_threshold)
		{
			if(++micro_flow_per_sec_cnt >= micro_flow_once_duration_sec && mirco_flow_days_flag == RESET)
			{
				mirco_flow_days_flag = SET;
				if(++mirco_flow_days_cnt >= flow_p->micro_flow_duration_days)
					__SYS_STATUS_ALARM_BYTES_SET(constant_tiny_flow);
			}	
		}
		else
		{
			mirco_flow_days_cnt = 0;
			__SYS_STATUS_BYTES_STATUS(constant_tiny_flow,RESET,AV_CONSTANT_TINY_FLOW);
		}
	}else
		micro_flow_per_sec_cnt = 0;
}
/******************************************
 * func: State_Alarm_Bytes_FlowMicroHandler
 * desc: ºã¶¨Á÷Á¿´¦Àí
 * input:  instant_sc_1000 ˲ʱ±ê¿öÁ÷Á¿·Å´ó1000±¶
 *         realtime_hour_min_bcd ʵʱʱ¼ä,ʱ·Ö
 * output: none
 * return: none
 *****************************************/
#define CONSTANT_FLOW_DIFF_QT_UP 20.0f
#define CONSTANT_FLOW_DIFF_QT_DOWN 10.0f
void State_Alarm_Bytes_FlowConstantHandler(uint32_t instant_sc_1000,uint16_t realtime_hour_min_bcd,MICRO_CONSTANT_FLOW_PARA_T * flow_p)
{
	static uint32_t constant_flow_value = 0;
	static FlagStatus constant_flow_flag = SET;
	static FlagStatus constant_flow_days_flag = RESET;
	static uint8_t constant_flow_days_cnt = 0;
	static uint32_t constant_flow_per_sec_cnt = 0;
	
	uint16_t constant_flow_time[2] = {(flow_p->constant_flow_time_start_bcd[0] << 8 | flow_p->constant_flow_time_start_bcd[1]),
		(flow_p->constant_flow_time_end_bcd[0] << 8 | flow_p->constant_flow_time_end_bcd[1])};	
	if(DAILY_ZERO) 
	{
		constant_flow_days_flag = RESET;
		constant_flow_per_sec_cnt = 0;	
	}	
	
	if((realtime_hour_min_bcd >= constant_flow_time[0]) && (realtime_hour_min_bcd <= constant_flow_time[1]))
	{
		if(constant_flow_flag == SET)
		{
			constant_flow_flag = RESET;
			constant_flow_value = instant_sc_1000;
			//Ìõ¼þÇåÁãÖØÐÂÅжÏ
			constant_flow_per_sec_cnt = constant_flow_days_cnt = 0;
			__SYS_STATUS_BYTES_STATUS(constant_flow,RESET,AV_CONSTANT_FLOW);
		}
		/*Á÷Á¿ÔÚ´Ë·¶Î§ÄÚ²ÅÅжϺãÁ÷
			СÓڸ÷¶Î§ÅжÏ΢Á÷£¬´óÓڸ÷¶Î§Åжϳ¬Á÷Á¿*/
		if(constant_flow_value >= flow_p->constant_flow_threshold_down && constant_flow_value < flow_p->constant_flow_threshold_up) 
		{
			uint32_t constant_flow_once_duration_sec = flow_p->constant_flow_once_duration_min * 60;
			float diff_per = fabs(((float)constant_flow_value - (float)instant_sc_1000) / (float)constant_flow_value * 100);
			if(constant_flow_value >= (sys_device_flow_qt_g * 1000)) //´óÓÚQtʱ£¬³ÖÐøÁ÷Á¿²»³¬¹ý20%ËãºãÁ÷
			{
				if(diff_per <= CONSTANT_FLOW_DIFF_QT_UP)
				{
					if(++constant_flow_per_sec_cnt >= constant_flow_once_duration_sec && constant_flow_days_flag == RESET)
					{
						constant_flow_days_flag = SET;
						if(++constant_flow_days_cnt >= flow_p->constant_flow_duration_days)
							__SYS_STATUS_ALARM_BYTES_SET(constant_flow);
					}
				}
				else
					constant_flow_flag = SET;
			}
			else//СÓÚQtʱ£¬³ÖÐøÁ÷Á¿²»³¬¹ý10%ËãºãÁ÷
			{
				if(diff_per <= CONSTANT_FLOW_DIFF_QT_DOWN)
				{
					if(++constant_flow_per_sec_cnt >= constant_flow_once_duration_sec && constant_flow_days_flag == RESET)
					{
						constant_flow_days_flag = SET;
						if(++constant_flow_days_cnt > flow_p->constant_flow_duration_days)
							__SYS_STATUS_ALARM_BYTES_SET(constant_flow);
					}
				}
				else
					constant_flow_flag = SET;
			}
		}
		else
			constant_flow_flag = SET;
	}
}
/******************************************
 * func: ZeroDrift_Correction
 * desc: ÁãµãƯÒÆÐÞÕý
					Âß¼­Á÷³ÌΪ£¬Ã¿ÈÕ12µãʱÅж¨½ü180ÃëµÄÁ÷Á¿Êý¾Ý£¬ÆäÖÐ20ÃëµÄÊý¾ÝСÓÚ×îСÁ÷Á¿µÄÒ»°ëʱ£¬¹Ø·§ ¸øÁ÷Á¿°åУ׼ÃüÁî
						¹Ø·§ºó90ÃëÔÙ¿ª·§¡£
 * input:  instant_sc ˲ʱ±ê¿öÁ÷Á¿
 * output: none
 * return: 0 ÐèҪУ׼ÐÞÕý 1 ÎÞÐèУ׼ÐÞÕý
 *****************************************/
uint8_t zero_drift_valve_flag = 0;
uint8_t ZeroDrift_Correction(float instant_sc,ZERO_DRIFT_CORR_CFG_T * zero_drift_p)
{
	uint8_t zero_drift_seconds[1] = {11};
	static uint8_t judge_sec = 0;
	static uint8_t less_cnt = 0;
	static VALVE_STATE_T valve_temp_flag = VALVE_NONE;
	if(zero_drift_p->zero_corr_ctl == SET)
	{
		/*¸ù¾ÝÉ趨µÄʱ·Ö£¬¸ø180SµÄÅж¨Ê±¼ä*/
		if((&calendar_g)->Hour == zero_drift_p->start_hour_min_bcd[0] && (&calendar_g)->Minute == zero_drift_p->start_hour_min_bcd[1] && 
				(&calendar_g)->Second == 0)
			judge_sec = 180;
		if(judge_sec)
		{
			if((instant_sc * 2) < sys_device_flow_min_g) // ˲ʱÁ÷Á¿ * 2 < ×îСÁ÷Á¿£¨×¢Ò⣺´ËÁ÷Á¿ÒѾ­¾­¹ý¶þ¼¶ÐÞÕý ºÍ СÁ÷Á¿ÐÞÕý£©
			{
				if(less_cnt++ > 20) //180ÃëÖÐÓÐ20ÃëÒÔÉÏ¡°Ë²Ê±Á÷Á¿ * 2 < ×îСÁ÷Á¿¡±£¬Ôò.......
				{
					judge_sec = 0;
					valve_temp_flag = (VALVE_STATE_T)__SYS_STATUS_BYTES_GET(valve_state); //¼Ç¼·§ÃÅ״̬
					if((valve_temp_flag == VALVE_OP) || (valve_temp_flag == VALVE_OPENING))
					{
						less_cnt = 90;
						sys_valve_ctl_id_g = V_KEY_CL; // ¹Ø·§
						zero_drift_valve_flag = 1;
					}
					else
						less_cnt = 0;
					Send_Write_Slave_Command(CORR_RW_DELAY, zero_drift_seconds, ONE_BYTE_DATA_LENGTH); //дÃüÁî
					return 0;
				}
			}
			if(--judge_sec == 0)
				less_cnt = 0;
		}
		/*Èç¹û֮ǰÊÇ¿ª·§×´Ì¬£¬¹Ø·§ºó90ÃëÔÙ¿ª·§
			Èç¹û֮ǰÊǹط§×´Ì¬£¬Ôò²»±ä*/
		if((valve_temp_flag == VALVE_OP) || (valve_temp_flag == VALVE_OPENING))
		{
			if(__SYS_STATUS_BYTES_GET(valve_state) == VALVE_CL)
			{
				if(!(--less_cnt))
				{
					if(__SYS_STATUS_BYTES_GET(valve_lock) == SET)
						__SYS_STATUS_BYTES_STATUS(valve_lock, RESET, AV_NORMAL);
					pwr_vol_g.lith_flag  = LMS_OPEN_VALVE_BEFORE;
					zero_drift_valve_flag = 1;
					valve_temp_flag = VALVE_NONE;
				}
			}
		}
		else
			valve_temp_flag = VALVE_NONE;
	}
	return 1;
}

/*ÿÃëµÄ˲ʱ±ê¿ö¼ÆËã*/
float Per_Second_InstantScCalculate(struct measure_para *sys_realtime_data_p)
{
  float ten_seconds_ago_instant_wc = 0,ten_seconds_ago_instant_sc = 0; // NÃëÇ°µÄ¹¤/±ê¿ö
	float __attribute__ ((aligned (4))) ten_seconds_ago_instant_wc_3600 = 0,ten_seconds_ago_instant_sc_3600 = 0;
  if (ring_read_1_data(&instant_wc_ring, &ten_seconds_ago_instant_wc, INSTANT_WC_RING_BUFFER_SIZE))
  {
		/*µ¥Î»£ºNm^3 / h*/
		ten_seconds_ago_instant_wc_3600 = ten_seconds_ago_instant_wc * 3600;
		if(ten_seconds_ago_instant_wc > 0.0f)
		{
			/*³¬Á÷Á¿³Í½ä/Ìæ´ú*/
			if(ten_seconds_ago_instant_wc_3600 <= sys_flow_alarm_cfg_g.sys_flow_up_2)
			{}
			else if(ten_seconds_ago_instant_wc_3600 <= sys_device_flow_max_g * SYS_FLOW_UP_3_VALUE) 
			{
				if(__SYS_FUNC_CFG_BYTES_GET(super_flow_manage_2) == 0 && __SYS_STATUS_BYTES_GET(media_status) == GAS)
				{
					ten_seconds_ago_instant_wc_3600 = sys_flow_alarm_cfg_g.flow_up_2_replace_value;
					ten_seconds_ago_instant_wc = ten_seconds_ago_instant_wc_3600 / 3600;
				}
			}
			else if(__SYS_FUNC_CFG_BYTES_GET(super_flow_manage_3) == 0)
			{
				ten_seconds_ago_instant_wc_3600 = sys_device_flow_max_g * SYS_FLOW_UP_3_VALUE;
				ten_seconds_ago_instant_wc = ten_seconds_ago_instant_wc_3600 / 3600;
			}			
			/*Ç°NÃëµÄ˲ʱ±ê¿ö µ¥Î»£ºNm^3 / s*/
			ten_seconds_ago_instant_sc = Wc_2_Sc(ten_seconds_ago_instant_wc, sys_realtime_data_p->pressure, sys_realtime_data_p->temperature);
			/*µ¥Î»£ºNm^3 / h*/
			ten_seconds_ago_instant_sc_3600 = ten_seconds_ago_instant_sc * 3600;
			/*Ç°NÃëµÄ¹¤/±ê¿ö×ÜÁ¿*/
			sys_realtime_data_p->forward_cumulate_wc += ten_seconds_ago_instant_wc;
			sys_realtime_data_p->forward_cumulate_sc += ten_seconds_ago_instant_sc;
			/*Ç°NÃëµÄ˲ʱ¹¤/±ê¿ö µ¥Î»£ºNm^3 / h*/
			sys_realtime_data_p->instant_wc = ten_seconds_ago_instant_wc_3600;    
			sys_realtime_data_p->instant_sc = ten_seconds_ago_instant_sc_3600;
		}
		else //ÄæÁ÷ÏÔʾ
		{
			sys_realtime_data_p->instant_wc = sys_realtime_data_p->instant_sc = 0;
		}
		State_Alarm_Bytes_FlowDataHandler(ten_seconds_ago_instant_wc_3600,sys_realtime_data_p);
		State_Alarm_Bytes_FlowMicroHandler(sys_realtime_data_p->instant_sc * 1000,calendar_g.Hour << 8 | calendar_g.Minute,&micro_constant_flow_para_g);
		State_Alarm_Bytes_FlowConstantHandler(sys_realtime_data_p->instant_sc * 1000,calendar_g.Hour << 8 | calendar_g.Minute,&micro_constant_flow_para_g);
  }
	else
		sys_realtime_data_p->instant_wc = sys_realtime_data_p->instant_sc = 0;
	return ten_seconds_ago_instant_sc;
}