#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                                };

//******************************************************************************
__weak void CalibrateGasOffset(void) {}
	
	
//******************************************************************************

//******************************************************************************
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)
{
  u16 I;
  
  DataPoint = &MAPPoint1;   
  for(I=0; I<STD_MAP_MAX; I++)
  {
    *DataPoint = ReadShortParameterFromMemory(MAP_SET1 + I*REG_WORD_WIDTH, (u16)MAPDefault[I]); 
    DataPoint--;   
  }
}

//******************************************************************************
void WriteInitUseBusParameter(void)
{
  u16 I;
  
  DataPoint = &MAPPoint1;   
  for(I=0; I<STD_MAP_MAX; I++)
  {
    *DataPoint = (u16)MAPDefault[I];
    tempL.Word[0] = (u16)MAPDefault[I];
		WriteShortParameterToMemory(MAP_SET1 + I*REG_WORD_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; 
      }
    }  

    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_DCOEF_NODE1)) {
				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
	
  //----------------------------------------------------------------------------
	MBBuf.DataByte  = 0;
	MBBuf.StartAddr = 0;
  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 = (u16)(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_ADDR:
       FreeWriteWordValidDataByCom(&localAddress, SLAVER_ADDR, SLAVER_ADDR_MAX, SLAVER_ADDR_MIN);
       if(parameterState == ABORD_OPERATION) break; 
       BackupParameterToFlash();
       break;
    //case STD_COM_BPS:            break;
#endif
//------------------------------------------------------------------------------
       
    case STD_OUT_MIN_FLOW:  
      if(BusAdr[MBBuf.StartAddr+1] != STD_OUT_MIN_FLOW +1) return;
      WriteDWordValidDataByCom(&minFlowRate, OUT_MIN_FLOW, maxFlowRate>>1, 0);             
      break;
      
    case STD_OUT_MAX_FLOW:       
      if(BusAdr[MBBuf.StartAddr+1] != STD_OUT_MAX_FLOW+1) return;
      WriteDWordValidDataByCom(&maxFlowRate, OUT_MAX_FLOW, 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: 
      WriteWordValidDataByCom(&GDCFactor, GCF_B, GCF_PARAMETER_MAX, GCF_PARAMETER_MIN);
      if(parameterState == ABORD_OPERATION) break; 
      ComputeGCFFactor();
      break;
#endif  
      
      //---------------------------------------------------------------------
      //case STD_FILTER_DEPTH:       break;
    case STD_RESPONSE_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 = (u16)WriteShortParameterToMemory(RESPONSE_TIME);
      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:  WriteWordValidDataByCom(&offsetGas, GAS_OFFSET, 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: WriteWordValidDataByCom(&offsetGasA, OFFSET_A_GAS, OFFSET_A_MAX, OFFSET_A_MIN); break;  
#endif
    
    //---------------------------------------------------------------------
#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(CMDComPassword);
      break;
#endif
      
    //--------------------------------------------------------------------------      
#ifndef ENABLE_GAS_RECOGNITION 
#pragma message("[undefined] ENABLE_GAS_RECOGNITION")
#elif(ENABLE_GAS_RECOGNITION)    
    case STD_AIR_FACTOR:   WriteWordValidDataByCom(&airFactor, AIR_FACTOR, 46728, 26728); break;
    case STD_FACTOR_VTH:   WriteWordValidDataByCom(&factorVth, FACTOR_VTH, 65535, 0);     break;
#endif

    //--------------------------------------------------------------------------
#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;
      tempL.Word[0] = CMDComPassword;
      factoryUnitPerPulse = (signed int)WriteShortParameterToMemory(PULSE_UNIT); 
      lastRemaining = 0; 
      Total[MIN_BIT] = 0;
      break;
      
    case STD_PULSE_LEVEL:  WriteWordValidDataByCom(&PulseLevel, PULSE_LEVEL, 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 = (u16)WriteShortParameterToMemory(SAMPLE_PERIOD);
      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;
      WriteDWordValidDataByCom(&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: WriteWordValidDataByCom(&uartDecimalPoint, COM_DECIMAL, 4, 0); break;
    case STD_RECORD_TIME: WriteWordValidDataByCom(&recordTime, RECORD_TIME, 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: 
       FreeWriteWordValidDataByCom(&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:  WriteWordValidDataByCom(&timingTxdStart, TIMING_TXD_START, TIMING_TXD_START_MAX, TIMING_TXD_START_MIN); break;
    case STD_TIMING_TXD_LEN:    WriteWordValidDataByCom(&timingTxdLen, TIMING_TXD_LEN, TIMING_TXD_LEN_MAX, TIMING_TXD_LEN_MIN); break;
    case STD_TIMING_TXD_TIME:   WriteWordValidDataByCom(&timingTxdTime, TIMING_TXD_TIME, 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:  WriteDWordValidDataByCom(&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: WriteWordValidDataByCom(&minLeakFlowRate, MIN_LEAK_FLOW, MIN_LEAK_FLOW_WIDTH, MIN_LEAK_FLOW_MAX, MIN_LEAK_FLOW_MIN); break;
    case STD_LEAK_FR_MAX: WriteWordValidDataByCom(&maxLeakFlowRate, MAX_LEAK_FLOW, MAX_LEAK_FLOW_WIDTH, MAX_LEAK_FLOW_MAX, MAX_LEAK_FLOW_MIN); break;
    case STD_LEAK_TIMING: WriteWordValidDataByCom(&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 = (u16)WriteShortParameterToEEPROM(DENSITY_FS_PARA, DENSITY_FS_PARA_WIDTH);
        break;
      }
      // 低端校准
      if(CMDComPassword == 0x0000AA00)
      {
        tempL.Word[0]   = voltageDetected[VHPA]; 
        VHHParameterAir = (u16)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;              
      WriteWordValidDataByCom(DataPoint, MAP_SET1 + MBBuf.DataByte * REG_WORD_WIDTH, 256, 0);
      MBBuf.DataByte = 2;
      break;
      
    case STD_DCOEF_NUM:      WriteWordValidDataByCom(&dcoefNum, DCOEF_NUM, 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;
      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;
      
      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();
}