#include "../main/SystemInclude.h"

u16 MBReg[USER_INX_MAX];
static u16 *DataPoint;//

const u8 MAPDefault[] = {
  MAP1_DEFAULT,  MAP2_DEFAULT,  MAP3_DEFAULT,  MAP4_DEFAULT,  MAP5_DEFAULT,
  MAP6_DEFAULT,  MAP7_DEFAULT,  MAP8_DEFAULT,  MAP9_DEFAULT,  MAP10_DEFAULT,
  MAP11_DEFAULT, MAP12_DEFAULT, MAP13_DEFAULT, MAP14_DEFAULT, MAP15_DEFAULT,
  MAP16_DEFAULT, MAP17_DEFAULT, MAP18_DEFAULT, MAP19_DEFAULT, MAP20_DEFAULT,
  MAP21_DEFAULT, MAP22_DEFAULT, MAP23_DEFAULT, MAP24_DEFAULT, MAP25_DEFAULT,
  MAP26_DEFAULT, MAP27_DEFAULT, MAP28_DEFAULT, MAP29_DEFAULT, MAP30_DEFAULT,
  MAP31_DEFAULT, MAP32_DEFAULT, MAP33_DEFAULT, MAP34_DEFAULT, MAP35_DEFAULT,
  MAP36_DEFAULT, MAP37_DEFAULT, MAP38_DEFAULT, MAP39_DEFAULT, MAP40_DEFAULT,
  MAP41_DEFAULT, MAP42_DEFAULT, MAP43_DEFAULT, MAP44_DEFAULT, MAP45_DEFAULT,
  MAP46_DEFAULT, MAP47_DEFAULT, MAP48_DEFAULT                                };
/*
//------------------------------------------------------------------------------
//const unsigned char BusRegLen[] = {
//  STD_30_LEN, STD_31_LEN, STD_32_LEN, STD_33_LEN, STD_34_LEN, STD_35_LEN, STD_36_LEN, STD_37_LEN,
//  STD_38_LEN, STD_39_LEN, STD_3A_LEN, STD_3B_LEN, STD_3C_LEN, STD_3D_LEN, STD_3E_LEN, STD_3F_LEN,
//  
//  STD_40_LEN, STD_41_LEN, STD_42_LEN, STD_43_LEN, STD_44_LEN, STD_45_LEN, STD_46_LEN, STD_47_LEN,
//  STD_48_LEN, STD_49_LEN, STD_4A_LEN, STD_4B_LEN, STD_4C_LEN, STD_4D_LEN, STD_4E_LEN, STD_4F_LEN,
//  
//  STD_50_LEN, STD_51_LEN, STD_52_LEN, STD_53_LEN, STD_54_LEN, STD_55_LEN, STD_56_LEN, STD_57_LEN,
//  STD_58_LEN, STD_59_LEN, STD_5A_LEN, STD_5B_LEN, STD_5C_LEN, STD_5D_LEN, STD_5E_LEN, STD_5F_LEN,
//  
//  STD_60_LEN, STD_61_LEN, STD_62_LEN, STD_63_LEN, STD_64_LEN, STD_65_LEN, STD_66_LEN, STD_67_LEN,
//  STD_68_LEN, STD_69_LEN, STD_6A_LEN, STD_6B_LEN, STD_6C_LEN, STD_6D_LEN, STD_6E_LEN, STD_6F_LEN,
//  
//  STD_70_LEN, STD_71_LEN, STD_72_LEN, STD_73_LEN, STD_74_LEN, STD_75_LEN, STD_76_LEN, STD_77_LEN,
//  STD_78_LEN, STD_79_LEN, STD_7A_LEN, STD_7B_LEN, STD_7C_LEN, STD_7D_LEN, STD_7E_LEN, STD_7F_LEN,
//  
//  STD_80_LEN, STD_81_LEN, STD_82_LEN, STD_83_LEN, STD_84_LEN, STD_85_LEN, STD_86_LEN, STD_87_LEN,
//  STD_88_LEN, STD_89_LEN, STD_8A_LEN, STD_8B_LEN, STD_8C_LEN, STD_8D_LEN, STD_8E_LEN, STD_8F_LEN,
//  
//  STD_90_LEN, STD_91_LEN, STD_92_LEN, STD_93_LEN, STD_94_LEN, STD_95_LEN, STD_96_LEN, STD_97_LEN,
//  STD_98_LEN, STD_99_LEN, STD_9A_LEN, STD_9B_LEN, STD_9C_LEN, STD_9D_LEN, STD_9E_LEN, STD_9F_LEN,
//  
//  STD_A0_LEN, STD_A1_LEN, STD_A2_LEN, STD_A3_LEN, STD_A4_LEN, STD_A5_LEN, STD_A6_LEN, STD_A7_LEN,
//  STD_A8_LEN, STD_A9_LEN, STD_AA_LEN, STD_AB_LEN, STD_AC_LEN, STD_AD_LEN, STD_AE_LEN, STD_AF_LEN,
//  
//  STD_B0_LEN, STD_B1_LEN, STD_B2_LEN, STD_B3_LEN, STD_B4_LEN, STD_B5_LEN, STD_B6_LEN, STD_B7_LEN,
//  STD_B8_LEN, STD_B9_LEN, STD_BA_LEN, STD_BB_LEN, STD_BC_LEN, STD_BD_LEN, STD_BE_LEN, STD_BF_LEN,
//  
//  STD_C0_LEN, STD_C1_LEN, STD_C2_LEN, STD_C3_LEN, STD_C4_LEN, STD_C5_LEN, STD_C6_LEN, STD_C7_LEN,
//  STD_C8_LEN, STD_C9_LEN, STD_CA_LEN, STD_CB_LEN, STD_CC_LEN, STD_CD_LEN, STD_CE_LEN, STD_CF_LEN,
//  
//  STD_D0_LEN, STD_D1_LEN, STD_D2_LEN, STD_D3_LEN, STD_D4_LEN, STD_D5_LEN, STD_D6_LEN, STD_D7_LEN,
//  STD_D8_LEN, STD_D9_LEN, STD_DA_LEN, STD_DB_LEN, STD_DC_LEN, STD_DD_LEN, STD_DE_LEN, STD_DF_LEN,
//  
//  STD_E0_LEN, STD_E1_LEN, STD_E2_LEN, STD_E3_LEN, STD_E4_LEN, STD_E5_LEN, STD_E6_LEN, STD_E7_LEN,
//  STD_E8_LEN, STD_E9_LEN, STD_EA_LEN, STD_EB_LEN, STD_EC_LEN, STD_ED_LEN, STD_EE_LEN, STD_EF_LEN,
//  
//  STD_F0_LEN, STD_F1_LEN, STD_F2_LEN, STD_F3_LEN, STD_F4_LEN, STD_F5_LEN, STD_F6_LEN, STD_F7_LEN,
//  STD_F8_LEN, STD_F9_LEN, STD_FA_LEN, STD_FB_LEN, STD_FC_LEN, STD_FD_LEN, STD_FE_LEN, STD_FF_LEN,
//};
*/

//******************************************************************************
u16 SetupResponseTimeIndex(u16 response, u16 responseDefalt)
{
	for(u16 I=0; I<RESP_MAX; I++) {
		if(response == Timing[I]) {
			 return I;
		}	
	}
	
  parameterState = ABORD_OPERATION;
  return responseDefalt;
}


//******************************************************************************
u16 SetupResponseTime(u16 response, u16 responseDefalt)
{
  if(response < RESP_MAX) {
    return Timing[response];
  }
	
  parameterState = ABORD_OPERATION;
  return Timing[responseDefalt]; 
}

//******************************************************************************
void InitUseBusParameter(void)
{
  unsigned int I;
  
  DataPoint = &MAPPoint1;   
  for(I=0; I<STD_MAP_MAX; I++)
  {
    *DataPoint = ReadParameterFromMemory(MAP_SET1 + I*MAP_SET_WIDTH, MAP_SET_WIDTH, (unsigned int)MAPDefault[I]); 
    DataPoint--;   
  }
}

//******************************************************************************
void WriteInitUseBusParameter(void)
{
  unsigned int I;
  
  DataPoint = &MAPPoint1;   
  for(I=0; I<STD_MAP_MAX; I++)
  {
    *DataPoint = (unsigned int)MAPDefault[I];
    tempL.Word[0] = (unsigned int)MAPDefault[I];
    WriteParameterToEEPROM(MAP_SET1 + I*MAP_SET_WIDTH, MAP_SET_WIDTH); 
    DataPoint--;   
  }
}


//******************************************************************************
void UserReadDataProtocol(void)
{
  u16 I;	

  DataPoint = &MBReg[INX_030];   
  // Read continuous address register
  while(MBBuf.StartAddr < STD_DCOEF_NODE1)
  {
    if(MBBuf.ByteNumber < 2) return;
    if(MBBuf.StartAddr < STD_REG_START)
    {
			//小于0x30未定义数组位置
      MBBuf.DataByte = DataPoint[MBBuf.StartAddr + STD_MAP_SET1];
      if(MBBuf.DataByte < STD_REG_START)	      tempL.Word[0] = 0;
			else if(MBBuf.DataByte < STD_DCOEF_NODE1) tempL.Word[0] = DataPoint[MBBuf.DataByte - STD_REG_START];
			else tempL.Word[0] = 0;
    }
		else tempL.Word[0] = DataPoint[MBBuf.StartAddr - STD_REG_START];
    
    MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[1];
    MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[0];
    
    MBBuf.StartAddr++;
    MBBuf.ByteNumber -= 2;
		MBBuf.DataByte = 2;
  }
  
  // read record data
  while(MBBuf.ByteNumber > 1)
  {
    MBBuf.DataByte = 2;
    switch(MBBuf.StartAddr)
    //switch(BusAdr[MBBuf.StartAddr])
    {
		case STD_DCOEF_NUM:  tempL.Word[0] = dcoefNum; break;
    case STD_DCOEF_NODE1:    
    case STD_DCOEF_NODE2:   
    case STD_DCOEF_NODE3: 
    case STD_DCOEF_NODE4: 
    case STD_DCOEF_NODE5:  
    case STD_DCOEF_NODE6: 
    case STD_DCOEF_NODE7:   
    case STD_DCOEF_NODE8:   
    case STD_DCOEF_NODE9:   
    case STD_DCOEF_NODE10:  
    case STD_DCOEF_NODE11: 
    case STD_DCOEF_NODE12: 
    case STD_DCOEF_NODE13: 
    case STD_DCOEF_NODE14:  
    case STD_DCOEF_NODE15: 
    case STD_DCOEF_NODE16: 
    case STD_DCOEF_NODE17:  
    case STD_DCOEF_NODE18:  
    case STD_DCOEF_NODE19:  
    case STD_DCOEF_NODE20: 
      MBBuf.DataByte = 4;
      I  = MBBuf.StartAddr - STD_DCOEF_NODE1;
      I /= 3;
      if(I >= dcoefNum) tempL.DWord = 0;
      tempL.DWord = dcoefNode[I];
      break;
      
    case STD_DCOEF_VALUE1:    
    case STD_DCOEF_VALUE2:   
    case STD_DCOEF_VALUE3: 
    case STD_DCOEF_VALUE4: 
    case STD_DCOEF_VALUE5:  
    case STD_DCOEF_VALUE6: 
    case STD_DCOEF_VALUE7:   
    case STD_DCOEF_VALUE8:   
    case STD_DCOEF_VALUE9:   
    case STD_DCOEF_VALUE10:  
    case STD_DCOEF_VALUE11: 
    case STD_DCOEF_VALUE12: 
    case STD_DCOEF_VALUE13: 
    case STD_DCOEF_VALUE14:  
    case STD_DCOEF_VALUE15: 
    case STD_DCOEF_VALUE16: 
    case STD_DCOEF_VALUE17:  
    case STD_DCOEF_VALUE18:  
    case STD_DCOEF_VALUE19:  
    case STD_DCOEF_VALUE20:
      I  = MBBuf.StartAddr - STD_DCOEF_VALUE1;
      I /= 3;
      if(I >= dcoefNum) tempL.Word[0] = 0;
      tempL.Word[0] = dcoefVal[I];
      break;
      
    case STD_ALARM_DEPTH:    tempL.Word[0] = ALARM_DEPTH;   break;
    case STD_ALARM_WIDTH:    tempL.Word[0] = ALARM_WIDTH;   break;
    case STD_HISTORY_DEPTH:  tempL.Word[0] = HISTORY_DEPTH; break;
    case STD_HISTORY_WIDTH:  tempL.Word[0] = HISTORY_WIDTH; break;
    case STD_DATE_DEPTH:     tempL.Word[0] = DATE_DEPTH;    break;
    case STD_DATE_WIDTH:     tempL.Word[0] = DATE_WIDTH;    break;
    default: 
      MBBuf.DataByte  = MBBuf.StartAddr & 0xf000;
      MBBuf.StartAddr &= 0x0fff;
      switch(MBBuf.DataByte)
      {
      case STD_ALARM:  
        MBBuf.StartAddr *= ALARM_WIDTH;
        MBBuf.StartAddr += ALARM_BASE;
        ReadRecordToComBuf();
        MBBuf.ByteNumber = 0;
        return;
        
      case STD_HISTORY:  
        MBBuf.StartAddr *= HISTORY_WIDTH;
        MBBuf.StartAddr += HISTORY_BASE;
        ReadRecordToComBuf();
        MBBuf.ByteNumber = 0;
        return;
        
      case STD_DATE_ACC:
        MBBuf.StartAddr *= DATE_WIDTH;
        MBBuf.StartAddr += DATE_BASE;  
        ReadRecordToComBuf();               
        MBBuf.ByteNumber = 0;
        return;
        
      default: return; 
      }
    }  
    
    //      MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[1];
    //      MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[0];
    //      ModbusVariablePointerDec();    
    
    for(I=1; I<=MBBuf.DataByte; I++) MBBuf.RxPointer[MBBuf.Index++] = tempL.Byte[MBBuf.DataByte-I];
    ModbusVariablePointerDec();
  }
}

//******************************************************************************
void UserWriteDataProtocol(void)
{ 
  u16 I=0;
	u16 BusAdr[50];
  
  if(MBBuf.EndAddr > STD_DEFINE_MAX)
  { 
    MBBuf.BusError = ILLEGAL_DATA_ADDRESS; 
    return;
  }
  
  //----------------------------------------------------------------------------
  while(MBBuf.StartAddr < MBBuf.EndAddr)  
  {
    if(MBBuf.StartAddr < STD_REG_START)
    {
			// 小于0x30未定义数组位置
      MBBuf.DataByte = DataPoint[MBBuf.StartAddr + STD_MAP_SET1];
      if((MBBuf.DataByte < STD_REG_START) || (MBBuf.DataByte > STD_REG_START)){
				MBBuf.BusError = ILLEGAL_DATA_ADDRESS; 
				return;
			}			
      BusAdr[I++] = MBBuf.DataByte;
    }
		else BusAdr[I++] = MBBuf.StartAddr;
    
    MBBuf.StartAddr++;
    if(I > 50) break;
  }
		
  //----------------------------------------------------------------------------
#ifndef ENABLE_USER_WP 
#pragma message("[undefined] ENABLE_USER_WP")
#elif(ENABLE_USER_WP)
  if(isOldProtocol)  securityID = 0x0000AA55;
#else
  securityID = 0x0000AA55;
#endif
	
  //----------------------------------------------------------------------------
  while(1) 
  { 
    if(MBBuf.BusError != 0) return;                                                // V2004
    if(ModbusVariablePointerProcess()) return;
    switch(BusAdr[MBBuf.StartAddr])
    {          
#ifndef ENABLE_USER_WRITE_ACC 
#pragma message("[undefined] ENABLE_USER_WRITE_ACC")
#elif(ENABLE_USER_WRITE_ACC)
    case STD_ACC_INT: 
      if(MBBuf.ByteNumber < 4) return;
      if(BusAdr[MBBuf.StartAddr+1] != STD_ACC_INT+1) return;
      SetDWordCmdByCom(&tmpLA);    
      if(parameterState == ABORD_OPERATION) break;
      if(tmpLA > 99999999) break;  
      
      ReleaseTotalToDisArray();  
      ConvertHEXToBCDArray(tmpLA, &Dis1[ACC_INT1], 8, HIGH_FIRST); 
      Dis2[ACC_INT1] = 0;
      Dis2[ACC_INT2] = 0;
      Dis2[ACC_INT3] = 0;
      
      tmpLB = ReturnStartUnitBit(ACC_INT1);
      for(I=ACC_INT1; I<ACC_DOT1; I++, tmpLB++) Dis2[tmpLB] = Dis1[I];

      SetupACCArray();
      ReleaseToIntAndDecimalBufForUart();
      break;
      
    case STD_ACC_DOT: 
      SetWordCmdByCom(&CMDComPassword); 
      if(parameterState == ABORD_OPERATION) break;
      if(CMDComPassword > 999) break;

      ReleaseTotalToDisArray();   
      Dis2[ACC_DOT4] = 0;
      Dis2[ACC_DOT5] = 0;
      Dis2[ACC_DOT6] = 0;

      ConvertHEXToBCDArray(CMDComPassword, &Dis1[ACC_DOT1], 3, HIGH_FIRST);   
      tmpLB = ReturnStartUnitBit(ACC_DOT1);
      for(I=ACC_DOT1; I<ACC_DOT4; I++, tmpLB++) Dis2[tmpLB] = Dis1[I];
     
      SetupACCArray();
      ReleaseToIntAndDecimalBufForUart();
      break;
      
    case STD_ALARM_2: SetWordCmdByCom(&alarmState1);  break;
      
    case STD_HEX_ACC:
      if(MBBuf.ByteNumber < 8) return;
      if(BusAdr[MBBuf.StartAddr+1] != STD_HEX_ACC+1) return;
      if(BusAdr[MBBuf.StartAddr+2] != STD_HEX_ACC+2) return;
      if(BusAdr[MBBuf.StartAddr+3] != STD_HEX_ACC+3) return;

      SetDWordCmdByCom(&tmpLA); 
      SetDWordCmdByCom(&tmpLB); 
      MBBuf.DataByte = 8;
      if(parameterState == ABORD_OPERATION) break;
            
      unsigned long long int tmPDA;
      tmPDA   = (unsigned long long int)tmpLA;
      tmPDA <<= 32;
      tmPDA  |= (unsigned long long int)tmpLB;

      if(tmPDA > 99999999999) break;
      flowAccumulationInteger = (unsigned long int)(tmPDA/1000);
      flowAccumulationDecimal = (unsigned int)(tmPDA-(unsigned long long int)flowAccumulationInteger*1000);
      ConvertHEXToBCDArray(flowAccumulationInteger, &Dis1[ACC_INT1], 8, HIGH_FIRST); 
      ConvertHEXToBCDArray(flowAccumulationDecimal, &Dis1[ACC_DOT1], 3, HIGH_FIRST);   
      tmpLB = ReturnStartUnitBit(ACC_INT1);
      Dis2[ACC_DOT4] = 0;
      Dis2[ACC_DOT5] = 0;
      Dis2[ACC_DOT6] = 0;
      for(I=ACC_INT1; I<ACC_DOT4; I++, tmpLB++) Dis2[tmpLB] = Dis1[I];
      
      SetupACCArray();
      ReleaseToIntAndDecimalBufForUart();
      break;
#endif
//------------------------------------------------------------------------------
      
      //******************************************************************************
      // 0x80~0xf0: read and write
      //case STD_PROTOCOL:           break;      
#ifndef ENABLE_USER_UART
#pragma message("[undefined] ENABLE_USER_UART")
#elif(ENABLE_USER_UART)
    case STD_SLAVER_ID:
       FreeWriteWordByCom(&localAddress, SLAVER_ADDR, SLAVER_ADDR_WIDTH, SLAVER_ADDR_MAX, SLAVER_ADDR_MIN);
       if(parameterState == ABORD_OPERATION) break; 
       BackupParameterToFlash();
       break;
    //case STD_COM_BPS:            break;
#endif
//------------------------------------------------------------------------------
       
    case STD_OUT_FR_MIN:  
      if(BusAdr[MBBuf.StartAddr+1] != STD_OUT_FR_MIN+1) return;
      WriteDWordByCom(&minFlowRate, MIN_FLOW, MIN_FLOW_WIDTH, maxFlowRate>>1, 0);             
      break;
      
    case STD_OUT_FR_MAX:       
      if(BusAdr[MBBuf.StartAddr+1] != STD_OUT_FR_MAX+1) return;
      WriteDWordByCom(&maxFlowRate, MAX_FLOW, MAX_FLOW_WIDTH, 0x7fffffff, 0);             
      break;
      
      //case STD_OUT_ANALOG_MIN:     break;
      //case STD_OUT_ANALOG_MAX:     break;
      //---------------------------------------------------------------------  
#ifndef ENABLE_USER_GCF 
#pragma message("[undefined] ENABLE_USER_GCF")
#elif(ENABLE_USER_GCF)
    case STD_GCF: 
      WriteWordByCom(&GDCFactor, GCF_B, GCF_B_WIDTH, GCF_PARAMETER_MAX, GCF_PARAMETER_MIN);
      if(parameterState == ABORD_OPERATION) break; 
      ComputeGCFFactor();
      break;
#endif  
      
      //---------------------------------------------------------------------
      //case STD_FILTER_DEPTH:       break;
    case STD_REPONSE_TIME:  //WriteWordByCom(&factoryInterval, SAMPLE_PERIOD, SAMPLE_PERIOD_WIDTH, SAMPLE_PERIOD_MAX, SAMPLE_PERIOD_MIN); break;  
      SetWordCmdByCom(&CMDComPassword);
      if(parameterState == ABORD_OPERATION) break;
      
      CMDComPassword = SetupResponseTimeIndex(CMDComPassword, RESPONSE_TIME_DEFAULT);
      if(parameterState == ABORD_OPERATION) break;
      
      tempL.Word[0] = CMDComPassword;
      responseTimeIndex = (unsigned int)WriteShortParameterToEEPROM(RESPONSE_TIME, RESPONSE_TIME_WIDTH);
      responseTime = SetupResponseTime(responseTimeIndex, RESPONSE_TIME_DEFAULT); 
      break;
    
    //-------------------------------------------------------------------------
#ifndef ENABLE_USER_OFFSET 
#pragma message("[undefined] ENABLE_USER_OFFSET")
#elif(ENABLE_USER_OFFSET)
    case STD_GAS_OFFSET_C:  WriteWordByCom(&offsetGas, OFFSET_GAS, OFFSET_GAS_WIDTH, OFFSET_MAX, OFFSET_MIN);  break;  
#endif  
    
    //---------------------------------------------------------------------
#ifndef ENABLE_A_TYPE_FLOWRATE 
#pragma message("[undefined] ENABLE_A_TYPE_FLOWRATE")
#elif(ENABLE_A_TYPE_FLOWRATE)
    case STD_GAS_OFFSET_A: WriteWordByCom(&offsetGasA, OFFSET_A_GAS, OFFSET_A_GAS_WIDTH, OFFSET_A_MAX, OFFSET_A_MIN); break;  
#endif
    
    //---------------------------------------------------------------------
    // V2004 
#ifndef ENABLE_USER_SET_UNIT 
#pragma message("[undefined] ENABLE_USER_SET_UNIT")
#elif(ENABLE_USER_SET_UNIT)
    case STD_UNIT:              
//      SetWordCmdByCom(&CMDComPassword);
//      if(parameterState == ABORD_OPERATION) break;
//      if(CMDComPassword == flowUnit) break;
//      ConvertAllFlowRateAndSave(tempL.Word[0]); 
//      break;
      
      SetWordCmdByCom(&CMDComPassword);
      if(parameterState == ABORD_OPERATION) break;
      if(CMDComPassword == flowUnit) break;
      ConvertAllFlowRateAndSave(CMDComPassword);
      break;
#endif
      
    //--------------------------------------------------------------------------      
    case STD_AIR_FACTOR:   WriteWordByCom(&VHHParameterAir, VHH_AIR_PARA, VHH_AIR_PARA_WIDTH, 46728, 26728);      break;
    case STD_FACTOR_VTH:   WriteWordByCom(&VHHParameterScale, VHH_PARA_SCALE, VHH_PARA_SCALE_WIDTH, 65535, 0);    break;
    
    //--------------------------------------------------------------------------
#ifndef ENABLE_ACCPULSE 
#pragma message("[undefined] ENABLE_ACCPULSE")
#elif(ENABLE_ACCPULSE)  
    case STD_PULSE_UNIT:          
      //WriteWordByCom(&factoryUnitPerPulse, PULSE_UNIT, PULSE_UNIT_WIDTH, PULSE_UNIT_MAX, 1); 
      SetWordCmdByCom(&CMDComPassword);
      if(parameterState == ABORD_OPERATION) break;
      if((signed int)CMDComPassword > PULSE_UNIT_MAX) break;
      if((signed int)CMDComPassword < PULSE_UNIT_MIN) break;
      tempDev.Word[0] = CMDComPassword;
      factoryUnitPerPulse = (signed int)WriteParameterToEEPROM(PULSE_UNIT, PULSE_UNIT_WIDTH); 
      lastRemaining = 0; 
      Total[MIN_BIT] = 0;
      break;
      
    case STD_IO_OUTPUT_LEVEL:  WriteWordByCom(&PulseLevel, PULSE_LEVEL, PULSE_LEVEL_WIDTH, 1, 0); break;
#endif
    
    //--------------------------------------------------------------------------
#ifndef ENABLE_LOWPOWER_MODE 
#pragma message("[undefined] ENABLE_LOWPOWER_MODE")
#elif(ENABLE_LOWPOWER_MODE)  
    case STD_SAMPLE_PERIOD:                                                     // 0x95   // 
      SetWordCmdByCom(&CMDComPassword);
      if(parameterState == ABORD_OPERATION) break;
      
      CMDComPassword = SetupResponseTimeIndex(CMDComPassword, SAMPLE_PERIOD_DEFAULT);
      if(parameterState == ABORD_OPERATION) break;
      
      tempL.Word[0] = CMDComPassword;
      factoryInterval = (unsigned int)WriteShortParameterToEEPROM(SAMPLE_PERIOD, SAMPLE_PERIOD_WIDTH);
      samplingTiming = SetupResponseTime(factoryInterval, SAMPLE_PERIOD_DEFAULT); 
      break;
#endif
      
    //--------------------------------------------------------------------------
#ifndef ENABLE_ALARM_ACC 
#pragma message("[undefined] ENABLE_ALARM_ACC")
#elif(ENABLE_ALARM_ACC)
    case STD_ALARM_ACC:                                                         // 0x96   // 报警总流量
      if(BusAdr[MBBuf.StartAddr+1] != STD_ALARM_ACC+1) return;
      WriteDWordByCom(&alarmAcc, ALARM_ACC, ALARM_ACC_WIDTH, ALARM_ACC_MAX, ALARM_ACC_MIN);  
      break;
#endif
 //--------------------------------------------------------------------------

    //case STD_ALARM_UPPER_FLOW     0x98                                          // 流量开关上限流量
    //case STD_ALARM_LOWER_FLOW     0x9A                                          // 流量开关下限流量
    //case STD_ALARM_FUN            0x9C                                          // 流量开关报警功能
    //case STD_ALARM_OUT_DELAY      0x9D                                          // 流量开关报警输出延时 (单位：s)
    case STD_COM_DECIMAL:          WriteWordByCom(&uartDecimalPoint, COM_DECIMAL_POINT, COM_DECIMAL_POINT_WIDTH, 4, 0); break;
    case STD_RECORD_TIME:          WriteWordByCom(&historyPeriod, HISTORY_PERIOD, HISTORY_PERIOD_WIDTH, 720, 0); break;
    //case STD_REVERSE_FR_MIN:  break;
    //case STD_REVERSE_FR_MAX:  break;

 //--------------------------------------------------------------------------
#ifndef ENABLE_USER_I2C 
#pragma message("[undefined] ENABLE_USER_I2C")
#elif(ENABLE_USER_I2C)
    case STD_I2C_ADDR: 
       FreeWriteWordByCom(&localAddress, SLAVER_ADDR, SLAVER_ADDR_WIDTH, SLAVER_ADDR_MAX, SLAVER_ADDR_MIN);
       I2CAddr = localAddress;
       if(parameterState == ABORD_OPERATION) break; 
       BackupParameterToFlash();
      // HWI2C_Init();
			I2C_Slave_Init(100000 , 0x02);

       break;
#endif
 //--------------------------------------------------------------------------
  
    //case STD_I2C_CRC_MOD:  break;
    case STD_TIMING_TXD_START:  WriteWordByCom(&timingTxdStart, TIMING_TXD_START, TIMING_TXD_START_WIDTH, TIMING_TXD_START_MAX, TIMING_TXD_START_MIN); break;
    case STD_TIMING_TXD_LEN:    WriteWordByCom(&timingTxdLen, TIMING_TXD_LEN, TIMING_TXD_LEN_WIDTH, TIMING_TXD_LEN_MAX, TIMING_TXD_LEN_MIN); break;
    case STD_TIMING_TXD_TIME:   WriteWordByCom(&timingTxdTime, TIMING_TXD_TIME, TIMING_TXD_TIME_WIDTH, TIMING_TXD_TIME_MAX, 0); break;
    //case STD_PRESSURE_OFFSET      0xA9                                          // 压力传感器零点
    //case STD_LORA_ADR             0xAA                                          // LORA 地址
    //case STD_LORA_NETID           0xAB                                          // LORA网路id
    //case STD_LORA_CH              0xAC                                          // LORA信道
    //case STD_LORA_STATE           0xAD                                          // LORA模块工作状态

    //---------------------------------------------------------------------
#ifndef ENABLE_KEY_FUNCTION 
#pragma message("[undefined] ENABLE_KEY_FUNCTION")
#elif(ENABLE_KEY_FUNCTION)
    case STD_KEY_PASSWORD:  WriteDWordByCom(&keyPassWord, KEY_PASSWORD, KEY_PASSWORD_WIDTH, 99999, 0); break;   // 0xAE 设置按键密码
#endif
    
    //---------------------------------------------------------------------
#ifndef ENABLE_LEAK_DETECT
#pragma message("[undefined] ENABLE_LEAK_DETECT")
#elif(ENABLE_LEAK_DETECT)
    case STD_LEAK_FR_MIN: WriteWordByCom(&minLeakFlowRate, MIN_LEAK_FLOW, MIN_LEAK_FLOW_WIDTH, MIN_LEAK_FLOW_MAX, MIN_LEAK_FLOW_MIN); break;
    case STD_LEAK_FR_MAX: WriteWordByCom(&maxLeakFlowRate, MAX_LEAK_FLOW, MAX_LEAK_FLOW_WIDTH, MAX_LEAK_FLOW_MAX, MAX_LEAK_FLOW_MIN); break;
    case STD_LEAK_TIMING: WriteWordByCom(&leakDetectTime, LEAK_TIME, LEAK_TIME_WIDTH, LEAK_TIME_MAX, 0); break;
#endif

    //**************************************************************************
    // 0XF0~0XFF: write only (功能码)
    //---------------------------------------------------------------------
    case STD_CAL_OFFSET_CMD:  
      SetWordCmdByCom(&CMDComPassword);
      #ifndef ENABLE_USER_OFFSET 
      #pragma message("[undefined] ENABLE_USER_OFFSET")
      #elif(ENABLE_USER_OFFSET)
      if(CMDComPassword == 0x0000AA55) CalibrateGasOffset();
      #endif 
      break;

      
      //---------------------------------------------------------------------
#ifndef ENABLE_USER_WRITE_ACC 
#pragma message("[undefined] ENABLE_USER_WRITE_ACC")
#elif(ENABLE_USER_WRITE_ACC)
    case STD_CLR_RECORD: 
      SetWordCmdByCom(&CMDComPassword);
      if(parameterState == ABORD_OPERATION) break;
      if(CMDComPassword == 0x0001) ClearACC();
      break;
#endif
      
      //------------------------------------------------------------------------
    case STD_RESET_DEFAULT:
      SetWordCmdByCom(&CMDComPassword);
      if(parameterState == ABORD_OPERATION) break;
      if(CMDComPassword == 0x01)      WriteInitUseBusParameter();
      #if(ENABLE_USER_RESET_CORR)
      else if(CMDComPassword == 0x02) DefaultDevCoef();  
      #endif
      break;
      
      //------------------------------------------------------------------------
    case STD_CAL_FULL_RANGE_CMD:  
      SetWordCmdByCom(&CMDComPassword);
      #ifndef ENABLE_DENSITY_DETECT 
      #pragma message("[undefined] ENABLE_DENSITY_DETECT")
      #elif(ENABLE_DENSITY_DETECT)
      // 满量程校准
      if(CMDComPassword == 0x0000AAFF)
      {
        tempL.Word[0]   = voltageDetected[VHPA]; 
        densityFSParameter = (unsigned int)WriteShortParameterToEEPROM(DENSITY_FS_PARA, DENSITY_FS_PARA_WIDTH);
        break;
      }
      // 低端校准
      if(CMDComPassword == 0x0000AA00)
      {
        tempL.Word[0]   = voltageDetected[VHPA]; 
        VHHParameterAir = (unsigned int)WriteShortParameterToEEPROM(VHH_AIR_PARA, VHH_AIR_PARA_WIDTH);
        break;
      }
      #endif   
      break;
      //---------------------------------------------------------------------
      // V2004 
#ifndef ENABLE_USER_WP 
#pragma message("[undefined] ENABLE_USER_WP")
#elif(ENABLE_USER_WP)
    case STD_PASSWORD_CMD: 
      FreeSetWordCmdByCom(&CMDComPassword);
      if(CMDComPassword != 0x0000AA55) break;
      securityID = 0x0000AA55;
      IDvalidTime = 0;
      break;
#endif
      //************************************************************************            
      // map config
    case STD_MAP_SET1:
    case STD_MAP_SET2: 
    case STD_MAP_SET3:
    case STD_MAP_SET4: 
    case STD_MAP_SET5: 
    case STD_MAP_SET6: 
    case STD_MAP_SET7:  
    case STD_MAP_SET8:  
    case STD_MAP_SET9:  
    case STD_MAP_SET10:  
    case STD_MAP_SET11:  
    case STD_MAP_SET12:  
    case STD_MAP_SET13:  
    case STD_MAP_SET14:  
    case STD_MAP_SET15:  
    case STD_MAP_SET16:  
    case STD_MAP_SET17:  
    case STD_MAP_SET18:  
    case STD_MAP_SET19:  
    case STD_MAP_SET20:  
    case STD_MAP_SET21:  
    case STD_MAP_SET22:  
    case STD_MAP_SET23:  
    case STD_MAP_SET24:  
    case STD_MAP_SET25:  
    case STD_MAP_SET26:  
    case STD_MAP_SET27:   
    case STD_MAP_SET28:  
    case STD_MAP_SET29:  
    case STD_MAP_SET30:  
    case STD_MAP_SET31:  
    case STD_MAP_SET32:  
    case STD_MAP_SET33:   
    case STD_MAP_SET34:  
    case STD_MAP_SET35:  
    case STD_MAP_SET36:  
    case STD_MAP_SET37:  
    case STD_MAP_SET38:  
    case STD_MAP_SET39:  
    case STD_MAP_SET40:  
    case STD_MAP_SET41:  
    case STD_MAP_SET42:  
    case STD_MAP_SET43:  
    case STD_MAP_SET44:  
    case STD_MAP_SET45:  
    case STD_MAP_SET46:  
    case STD_MAP_SET47:  
    case STD_MAP_SET48:            
      DataPoint  = &MAPPoint1;
      MBBuf.DataByte   = BusAdr[MBBuf.StartAddr] - STD_MAP_SET1;
      DataPoint -= MBBuf.DataByte;              
      WriteWordByCom(DataPoint, MAP_SET1 + MBBuf.DataByte * MAP_SET_WIDTH, MAP_SET_WIDTH, 256, 0);
      MBBuf.DataByte = 2;
      break;
      
    case STD_DCOEF_NUM:      WriteWordByCom(&dcoefNum, DCOEF_NUM, DCOEF_NUM_WIDTH, 20, 3);  break; 
    case STD_DCOEF_NODE1:    
    case STD_DCOEF_NODE2:   
    case STD_DCOEF_NODE3: 
    case STD_DCOEF_NODE4: 
    case STD_DCOEF_NODE5:  
    case STD_DCOEF_NODE6: 
    case STD_DCOEF_NODE7:   
    case STD_DCOEF_NODE8:   
    case STD_DCOEF_NODE9:   
    case STD_DCOEF_NODE10:  
    case STD_DCOEF_NODE11: 
    case STD_DCOEF_NODE12: 
    case STD_DCOEF_NODE13: 
    case STD_DCOEF_NODE14:  
    case STD_DCOEF_NODE15: 
    case STD_DCOEF_NODE16: 
    case STD_DCOEF_NODE17:  
    case STD_DCOEF_NODE18:  
    case STD_DCOEF_NODE19:  
    case STD_DCOEF_NODE20:
      I  = BusAdr[MBBuf.StartAddr] - STD_DCOEF_NODE1;
      I /= 3;
      if(I >= dcoefNum) return;
      SetDWordCmdByCom(&tmpLA);
      if(parameterState == ABORD_OPERATION) return;
      
      dcoefNode[I] = tmpLA;
      IDvalidTime = 0;
      HWState.EnableCheckCorr = 0;    
      StoreDevCoefNodeAndValue(I);
      break;
      
    case STD_DCOEF_VALUE1:    
    case STD_DCOEF_VALUE2:   
    case STD_DCOEF_VALUE3: 
    case STD_DCOEF_VALUE4: 
    case STD_DCOEF_VALUE5:  
    case STD_DCOEF_VALUE6: 
    case STD_DCOEF_VALUE7:   
    case STD_DCOEF_VALUE8:   
    case STD_DCOEF_VALUE9:   
    case STD_DCOEF_VALUE10:  
    case STD_DCOEF_VALUE11: 
    case STD_DCOEF_VALUE12: 
    case STD_DCOEF_VALUE13: 
    case STD_DCOEF_VALUE14:  
    case STD_DCOEF_VALUE15: 
    case STD_DCOEF_VALUE16: 
    case STD_DCOEF_VALUE17:  
    case STD_DCOEF_VALUE18:  
    case STD_DCOEF_VALUE19:  
    case STD_DCOEF_VALUE20:
      I  = BusAdr[MBBuf.StartAddr] - STD_DCOEF_VALUE1;
      I /= 3;
      if(I >= dcoefNum) return;
      SetWordCmdByCom(&tempL.Word[0]);
      if(parameterState == ABORD_OPERATION)   return;
      if(tempL.Word[0] > METER_PARAMETER_MAX) return;
      if(tempL.Word[0] < METER_PARAMETER_MIN) return;
      
      IDvalidTime = 0;
      dcoefVal[I] = tempL.Word[0];
      StoreDevCoefNodeAndValue(I);
      HWState.EnableCheckCorr = 0;
      break;
      
    default: 
      tempL.Word[0] = 0;
      MBBuf.DataByte = 2;
      break;
    }
  }
}

/******************************************************************************/
void AutoTransmitData(void)
{
//   if(comState.Sending) return;
//   
//   comState.ReceivedData = 0;
//   autoTxdCounter = 0;
//   comState.EnableAutoTxdData = 0;
//    
//   MBBuf.RxPointer[0] = (unsigned char)localAddress;
//   MBBuf.RxPointer[1] = (unsigned char)READ_HOLDING_REGISTERS;
//   MBBuf.ByteNumber = timingTxdLen*2;
//   if(MBBuf.ByteNumber > 100) MBBuf.ByteNumber = 100;
//   MBBuf.RxPointer[2] = MBBuf.ByteNumber;
//   
//   MBBuf.StartAddr  = timingTxdStart;  
//   MBBuf.TxdLen   = MBBuf.ByteNumber;
//   MBBuf.TxdLen  += 4;
//   Index = 3;
//   UserReadDataProtocol();
//   ComputeCRCForTransmitData();
//   StartDMAForTxdData();
}