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


//##############################################################################
#ifndef ENABLE_KEY_FUNCTION 
#pragma message("[undefined] ENABLE_KEY_FUNCTION")
#elif(ENABLE_KEY_FUNCTION)
//##############################################################################
//==============================================================================
unsigned int keyDealFlag;
bool keySetPoint;                                                 // 键响应程序进入标志
unsigned int timerTar;
unsigned int keyFlag, menuIndex;                                                // 键处理标志及菜单索引
unsigned int setKeyType, setIndex;                                              // 二级菜单处理嵌套
unsigned long int PassWord;                                                          // 密码
unsigned int keyValue, keyBuff, funKeyTime, decKeyTime, incKeyTime, keyEffectiveTime;     // 键值判断
unsigned int modifyBit, keyFlashTime;                                           // 设置参数闪烁位及时间
unsigned long int setKeyBuffer;                                                 // 参数设置缓存单元
unsigned long int temp_dcoefNode[DCOEF_MAX];
unsigned int temp_dcoefNum, temp_dcoefVal[DCOEF_MAX];
unsigned char setMin[6], setMax[6];
unsigned int parameterSetError;

struct KeyGroup{
  const unsigned char *Prompt;         // 提示符
  unsigned long int Value;            // 设置参数
  unsigned int Gain;
  unsigned long int Max;              // 设置参数最大值
  unsigned long int Min;              // 设置参数最小值
  unsigned int Addr;  
  unsigned int Width;  
  unsigned long int Password;  
  unsigned int Type;  
};

struct KeyGroup KeyStruct;

/*******************************************************************************
* line 1: Key function code    (4byte)
* line 2: Key function prompt  (5byte)
* line 3: Optional key value byte number
* line 4: Optional key value 1 (5byte)
* line 5: Optional key value 2 (5byte)
*
*******************************************************************************/
const unsigned char PRTCL_Prompt[]={                // F1	通讯协议      PRTCL
  WORD_F, 1, WORD_NULL, WORD_NULL, 
  WORD_P, WORD_R, WORD_T, WORD_C, WORD_L };   // F1	通讯协议      PRTCL	

const unsigned char ADDR_Prompt[]={
  WORD_F, 2, WORD_NULL, WORD_NULL, 
  WORD_A, WORD_D, WORD_D, WORD_R, WORD_NULL};  // F2	从机地址      ADDR	

//------------------------------------------------------------------------------
// 0-4800  1-9600  2-19200  3-38400 4-57600 5-115200
const unsigned char BPS_Prompt[]={                        // F3	波特率	      BPS
  WORD_F, 3, WORD_NULL, WORD_NULL, 
  WORD_B, WORD_P, WORD_S, WORD_NULL, WORD_NULL, 
  WORD_NULL, WORD_4, WORD_8, WORD_0, WORD_0, 
  WORD_NULL, WORD_9, WORD_6, WORD_0, WORD_0, 
  WORD_1, WORD_9, WORD_2, WORD_0, WORD_0,
  WORD_3, WORD_8, WORD_4, WORD_0, WORD_0,
  WORD_5, WORD_7, WORD_6, WORD_0, WORD_0
};  

//------------------------------------------------------------------------------
// 流量类（F11-F30）			
const unsigned char OFFST_Prompt[]={
  WORD_F, 1, 1, WORD_NULL,                                // F11    校准零点      OFFST 
  WORD_O, WORD_F, WORD_F, WORD_S, WORD_T, 
  WORD_S, WORD_E, WORD_T, WORD_NULL, WORD_NULL 
};               // Prompt 提示符

const unsigned char GCF_Prompt[]={
  WORD_F, 1, 2, WORD_NULL, 
  WORD_G, WORD_C, WORD_F, WORD_NULL, WORD_NULL };         // F12	GCF	      GCF	

const unsigned char FACTR_Prompt[]={
  WORD_F, 1, 3, WORD_NULL, 
  WORD_F, WORD_A, WORD_C, WORD_T, WORD_R};                // F13	仪表系数      FACTR	

const unsigned char CORR_Prompt[]={
  WORD_F, 1, 4, WORD_NULL, 
  WORD_C, WORD_O, WORD_R, WORD_R, WORD_NULL};             // F14 	二次修正系数  CORR

const unsigned char FS_Prompt[]={
  WORD_F, 1, 5, WORD_NULL, 
  WORD_F, WORD_S, WORD_NULL, WORD_NULL, WORD_NULL };       // F15	量程设置      FS

const unsigned char RESPS_Prompt[]={                                  // F16	响应时间      RESPS	
  WORD_F, 1, 6, WORD_NULL, 
  WORD_R, WORD_E, WORD_S, WORD_P, WORD_S,
//  WORD_NULL, WORD_NULL, WORD_1, WORD_2, WORD_5,
//  WORD_NULL, WORD_NULL, WORD_2, WORD_5, WORD_0,
//  WORD_NULL, WORD_NULL, WORD_5, WORD_0, WORD_0,
//  WORD_NULL, WORD_1,    WORD_0, WORD_0, WORD_0,
//  WORD_NULL, WORD_2,    WORD_0, WORD_0, WORD_0,
//  WORD_NULL, WORD_4,    WORD_0, WORD_0, WORD_0    };
  WORD_NULL, WORD_NULL, WORD_1, WORD_2, WORD_5,
  WORD_NULL, WORD_NULL, WORD_2, WORD_5, WORD_0,
  WORD_NULL, WORD_NULL, WORD_5, WORD_0, WORD_0,
  WORD_NULL, WORD_1,    WORD_0, WORD_0, WORD_0,
  WORD_NULL, WORD_2,    WORD_0, WORD_0, WORD_0,
  WORD_NULL, WORD_4,    WORD_0, WORD_0, WORD_0    };    

//------------------------------------------------------------------------------			
const unsigned char CUTF_Prompt[]={
  WORD_F, 2, 8, WORD_NULL, 
  WORD_C, WORD_U, WORD_T, WORD_LINE, WORD_F};              // F28	小流量切除    CUT-F

const unsigned char DIAM_Prompt[]={
  WORD_F, 2, 9, WORD_NULL, 
  WORD_D, WORD_I, WORD_A, WORD_M, WORD_NULL};              // F29	管径设置      DIAM	
//------------------------------------------------------------------------------
// 显示类（F31-F40）
// for acc
const unsigned char UNTA_Prompt[]={                                  // F31	累积流量单位	UNT-A	
  WORD_F, 3, 1, WORD_NULL, 
  WORD_U, WORD_N, WORD_T, WORD_LINE, WORD_A, 
  WORD_M, WORD_L, WORD_NULL, WORD_NULL, WORD_NULL,    // ML
  WORD_S, WORD_L, WORD_NULL, WORD_NULL, WORD_NULL,    // SL
  WORD_M, WORD_3, WORD_NULL, WORD_NULL, WORD_NULL,    // NM3
  WORD_S, WORD_C, WORD_F,    WORD_NULL, WORD_NULL,    // SCF
  WORD_K, WORD_G, WORD_NULL, WORD_NULL, WORD_NULL     // KG
};       

const unsigned char UNTF_Prompt[]={                             // F32	实时流量单位	UNT-F
  WORD_F, 3, 2, WORD_NULL, 
  WORD_U, WORD_N, WORD_T, WORD_LINE, WORD_F,
  WORD_S, WORD_C, WORD_C, WORD_M, WORD_NULL,          // SCCM
  WORD_S, WORD_L, WORD_P, WORD_M, WORD_NULL,          // SLPM
  WORD_M, WORD_3, WORD_P, WORD_H, WORD_NULL,          // NM3/H,M3PH  
  WORD_S, WORD_C, WORD_F, WORD_M, WORD_NULL,          // SCFM  
  WORD_K, WORD_G, WORD_H, WORD_NULL, WORD_NULL,       // KGH
  WORD_S, WORD_C, WORD_F, WORD_H, WORD_NULL,          // SCFH 
};          

const unsigned char UNTP_Prompt[]={
  WORD_F, 3, 3, WORD_NULL, 
  WORD_U, WORD_N, WORD_T, WORD_LINE, WORD_P };            // F33	压力单位	UNT-P	

#define KEY_DISP_LIST_ALL     0
#define KEY_DISP_LIST_ACC     1
#define KEY_DISP_LIST_PRESS   2

const unsigned char DISP_Prompt[]={                                  // F38	显示模式	DISP	
  WORD_F, 3, 8, WORD_NULL, 
  WORD_D, WORD_I, WORD_S, WORD_P, WORD_NULL, 
  WORD_C,  WORD_Y,  WORD_C,  WORD_L,  WORD_E,            // CYCLE
  WORD_F,  WORD_I,  WORD_X,  WORD_E,  WORD_D,            // FIXED
};    

//------------------------------------------------------------------------------
const unsigned char LANG_Prompt[]={                                  // F39	显示语言模式	LANG	
  WORD_F, 3, 9, WORD_NULL, 
  WORD_L, WORD_A, WORD_N, WORD_G, WORD_NULL, 
  WORD_NULL,  WORD_NULL,  WORD_C,  WORD_H,  WORD_N,       // CHN  
  WORD_NULL,  WORD_NULL,  WORD_E,  WORD_N,  WORD_G,       // ENG  
  WORD_NULL,  WORD_NULL,  WORD_A,  WORD_L,  WORD_L,       // ALL
};   

//------------------------------------------------------------------------------
// 模拟接口类（F31-F40）
const unsigned char PULSE_Prompt[]={                                // F41	脉冲当量	PULSE	
  WORD_F, 4, 1, WORD_NULL, 
  WORD_P, WORD_U, WORD_L, WORD_S, WORD_E, 	
  
  //for MF52 M56 MF5000
  WORD_NULL, WORD_1,    WORD_0,    WORD_LINE, WORD_4,    // 0.0001L,            -0
  WORD_NULL, WORD_1,    WORD_0,    WORD_LINE, WORD_3,    // 0.001L,             -1
  WORD_NULL, WORD_1,    WORD_0,    WORD_LINE, WORD_2,    // 0.01L,              -2
  WORD_NULL, WORD_1,    WORD_0,    WORD_LINE, WORD_1,    // 0.1L,               -3
  WORD_NULL, WORD_NULL, WORD_NULL, WORD_NULL, WORD_1,    // 1L                  -4
  WORD_NULL, WORD_NULL, WORD_NULL, WORD_1,    WORD_0,    // 10L                 -5
  WORD_NULL, WORD_NULL, WORD_1,    WORD_0,    WORD_0,    // 100L                -6
  WORD_NULL, WORD_1,    WORD_0,    WORD_0,    WORD_0,    // 1000L               -7
};


//------------------------------------------------------------------------------
// 报警类（F41-F50）
const unsigned char ALMH_Prompt[]={
  WORD_F, 5, 1, WORD_NULL, 
  WORD_A, WORD_L, WORD_M, WORD_LINE, WORD_H   };           // F51	高流量报警	ALM-H	

const unsigned char ALML_Prompt[]={
  WORD_F, 5, 2, WORD_NULL, 
  WORD_A, WORD_L, WORD_M, WORD_LINE, WORD_L};             // F52	低流量报警	ALM-L	

const unsigned char ALMA_Prompt[]={
  WORD_F, 5, 3, WORD_NULL, 
  WORD_A, WORD_L, WORD_M, WORD_LINE, WORD_A};             // F53	总量报警上限	ALM-A	

const unsigned char ALMT_Prompt[]={
  WORD_F, 5, 4, WORD_NULL, 
  WORD_A, WORD_L, WORD_M, WORD_LINE, WORD_T};             // F54	时间报警	ALM-T	

//------------------------------------------------------------------------------
// 无线类（F71-F90） 
const unsigned char LRID_Prompt[]={
  WORD_F, 7, 1, WORD_NULL, 
  WORD_L, WORD_R, WORD_LINE, WORD_I, WORD_D};             // F71     LORA本机地址    LR-ID

const unsigned char NETID_Prompt[]={
  WORD_F, 7, 2, WORD_NULL, 
  WORD_N, WORD_E, WORD_T, WORD_I, WORD_D   };             // F72     LORA上级地址    NETID

const unsigned char LRCH_Prompt[]={
  WORD_F, 7, 3, WORD_NULL, 
  WORD_L, WORD_R, WORD_LINE, WORD_C, WORD_H  };           // F73     LORA信道        LR_CH  

//------------------------------------------------------------------------------
// 操作类（F91-F98）
const unsigned char PASS_Prompt[]={
  WORD_F, 9, 1, WORD_NULL, 
  WORD_P, WORD_A, WORD_S, WORD_S, WORD_NULL};           // F91	设置密码	PASS	

const unsigned char CLRA_Prompt[]={                                // F92	清除总流量	CLR-A	
  WORD_F, 9, 2, WORD_NULL, 
  WORD_C, WORD_L, WORD_R, WORD_LINE, WORD_A,
  WORD_C, WORD_L, WORD_R, WORD_NULL,
};         

const unsigned char CLRT_Prompt[]={
  WORD_F, 9, 3, WORD_NULL, 
  WORD_C, WORD_L, WORD_R, WORD_LINE, WORD_T};           // F93	清除时间	CLR-T

const unsigned char RS2ND_Prompt[]={                               // F94	恢复二次修正	RS2ND	
  WORD_F, 9, 4, WORD_NULL, 
  WORD_R, WORD_S, WORD_2, WORD_N, WORD_D,
  WORD_R, WORD_S, WORD_T, WORD_NULL,
};
//------------------------------------------------------------------------------
const unsigned char QUIT_Prompt[]={
  WORD_F, 9, 9, WORD_NULL, 
  WORD_Q, WORD_U, WORD_I, WORD_T, WORD_NULL  };           // F99	退出设置	QUIT	

//------------------------------------------------------------------------------
const unsigned char SAVE_Prompt[]={
  WORD_S, WORD_A, WORD_V, WORD_E, 
  WORD_Y, WORD_E, WORD_S, WORD_NULL, WORD_NULL,
};

const unsigned char PassWord_Prompt[]={
  WORD_P, WORD_A, WORD_S, WORD_S, 
  WORD_0, WORD_0, WORD_0, WORD_0, WORD_0   };  
//==============================================================================
// for key value
const unsigned char YESNO_VALUE[]={
  WORD_N, WORD_O, WORD_NULL, WORD_NULL, WORD_NULL, 
  WORD_Y, WORD_E, WORD_S,    WORD_NULL, WORD_NULL   };

//const unsigned charRS2ND_VALUE[]={
//  WORD_R, WORD_T, WORD_N, WORD_NULL, WORD_NULL, 
//  WORD_R, WORD_E, WORD_S, WORD_E,    WORD_T    };
/******************************************************************************/ 
// for display buffer
const unsigned char DisOffset[] = {FUN_BUF_PROMPT1, FUN_BUF_PROMPT2, FUN_BUF_PROMPT3, FUN_BUF_PROMPT4, FUN_BUF_PROMPT5, FUN_BUF_DECIMAL};

/******************************************************************************/  
void DisplayForKeyOperation(void)
{
   display_data[FUN_BUF_PROMPT1] = CodeACC[Dis1[FUN_PROMPT1]];
   display_data[FUN_BUF_PROMPT2] = CodeACC[Dis1[FUN_PROMPT2]];
   display_data[FUN_BUF_PROMPT3] = CodeACC[Dis1[FUN_PROMPT3]];
   display_data[FUN_BUF_PROMPT4] = CodeACC[Dis1[FUN_PROMPT4]];
   display_data[FUN_BUF_PROMPT5] = CodeACC[Dis1[FUN_PROMPT5]];
   display_data[FUN_BUF_DECIMAL] = CodeACC[Dis1[FUN_DECIMAL]];
   
   display_data[FUN_BUF_CODE1] = CodeFlowRate[Dis1[FUN_CODE_1]];
   display_data[FUN_BUF_CODE2] = CodeFlowRate[Dis1[FUN_CODE_2]];
   display_data[FUN_BUF_CODE3] = CodeFlowRate[Dis1[FUN_CODE_3]];
   display_data[FUN_BUF_CODE4] = CodeFlowRate[Dis1[FUN_CODE_4]];
   
   if(keySetPoint) display_data[KEYSET_DOT] |= KEYSET_DOT_BIT;
   
   LcdWriteDisplay();
}

/******************************************************************************/ 
#pragma vector = KEY_VECTOR
__interrupt void KeyInterrupt_isr(void)
{
   intVector = KEY_IV;
   // intVector &= M_KEY_VECTOR + INC_KEY_VECTOR + DEC_KEY_VECTOR;
   
   if(intVector != 0) 
   {
      HWState.KeyPressed = 1;
      systemProcessing |= KEY_HANDLE;
      LPM1_EXIT; 
   }
}

/******************************************************************************/ 
void KeyReturn(void)
{
  keyFlag = DIS_SET_OFF;
  keyBuff = 0;
  HWState.KeyPressed = 0; 
  keyValue = 0;
  menuIndex = 0;  
}

/******************************************************************************/ 
void KeyReset(void)
{
   KEY_INPUT();
   //keyFlag = DIS_PARA_INT;
   keyFlag = DIS_SET_OFF;
   HWState.KeyPressed = 0; 
   keyValue = 0;
   menuIndex = 0;
   setKeyType = 0;
   setIndex = 0;
   PassWord = 0;
   timerTar = 0;
   keyDealFlag = 0;
   
   systemProcessing &= ~KEY_HANDLE;
}

/******************************************************************************/ 
void DisableKeyInterrupt(void)
{
   KEY_IE  &= ~KEY_PIN; 
   KEY_IFG &= ~KEY_PIN;                             //清零中断标志
}

/******************************************************************************/
void EnableKeyInterrupt(void)
{
   KEY_IES |=  KEY_PIN;  
   KEY_IFG &= ~KEY_PIN;                             //清零中断标志
   KEY_IE  |=  KEY_PIN;         
}

/******************************************************************************/
void KeyEditInit(void)
{ 
   // key intput interrupt 
   KEY_INPUT();
}

/******************************************************************************/
void FlashBitForSetup(void)
{  
//   unsigned char tempT, I;
//   
//   if(keyFlag != FLASH_BIT) return;
//   if(keyFlashTime == RTCSEC) return;
//   
//   keyFlashTime = RTCSEC;
//   I = DisOffset[modifyBit];
//   
//   tempT  = display_data[I];
//   tempT &= ~BIT0;
//   if(tempT == 0) display_data[I] |= CodeACC[Dis1[modifyBit]];
//   //else           display_data[I] &= (unsigned char)BIT0;
//   else           display_data[I] = 0;
//   //LcdWriteDisplayFirst();
//   LcdWriteDisplay();
  
  unsigned char tempT, I;
  
  keyFlashTime++;
  if(keyFlag != FLASH_BIT) return;
  if(keyFlashTime < FLASH_500mS) return;
  
  keyFlashTime = 0;
  I = DisOffset[modifyBit];
  
  tempT  = display_data[I];
  tempT &= ~BIT0;
  if(tempT == 0) display_data[I] |= CodeACC[Dis1[modifyBit]];
  else           display_data[I] = 0;

  LcdWriteDisplay();
}

/******************************************************************************/
//void ComputeTime(void)
//{
//   unsigned int timerTemp;
//   
//   // main timer: 1s = 16384
//   // 50ms: 820
//   timerTemp = MAINTAR;
//   if(timerTar == 0) timerTar = timerTemp;
//   else
//   {
//      if(timerTar == 65535) return;
//      if(timerTar < timerTemp) timerTemp -= timerTar;    
//      else timerTemp += 65535 - timerTar;
//   
//      if(timerTemp >= KEY_RESPONSE_TIME)  timerTar = 65535;    //timerTar = KEY_RESPONSE_TIME;
//   }
//}

/******************************************************************************/
bool ReadFunKey(void)
{
   KEY_PULLUP();
   KEY_INPUT();
   SET_KEY();
   
   if((KEY_IN & M_KEY) == M_KEY) return 1;
   else                          return 0;
}

/******************************************************************************/
bool ReadDecKey(void)
{
   KEY_PULLUP();
   KEY_INPUT();
   SET_KEY();
   
   if((KEY_IN & DEC_KEY) == DEC_KEY) return 1;
   else                              return 0;
}

/******************************************************************************/
bool ReadIncKey(void)
{
   KEY_PULLUP();
   KEY_INPUT();
   SET_KEY();
   
   if((KEY_IN & INC_KEY) == INC_KEY) return 1;
   else                              return 0;
}

/******************************************************************************/
void ReadKeyValue(void)
{ 
  unsigned int keyInput = 0;
  
  //============================================================================
  if(!ReadFunKey())
  {
    keyInput |= M_KEY;
    funKeyTime++;
    if(funKeyTime >= KEY_MAX_TIME) funKeyTime = KEY_MAX_TIME;
  }
  
  if(!ReadDecKey())
  {
    keyInput |= DEC_KEY;
    decKeyTime++;
    if(decKeyTime >= KEY_MAX_TIME) decKeyTime = KEY_MAX_TIME;
  }
  
  if(!ReadIncKey())
  {
    keyInput |= INC_KEY;   
    incKeyTime++;
    if(incKeyTime >= KEY_MAX_TIME) incKeyTime = KEY_MAX_TIME;
  }
  
  //============================================================================
  switch(keyInput)
  {
  case 0:
    keyBuff = 0;
    if((funKeyTime > KEY_RESPONSE_TIME) && (funKeyTime < KEY_MAX_TIME)) keyBuff |= M_KEY;   
    if((decKeyTime > KEY_RESPONSE_TIME) && (decKeyTime < KEY_MAX_TIME)) keyBuff |= DEC_KEY;   
    if((incKeyTime > KEY_RESPONSE_TIME) && (incKeyTime < KEY_MAX_TIME)) keyBuff |= INC_KEY;   
    
    keyValue = 0;
    // 判断按键时间及键值判断
    switch(keyBuff)
    {
    case M_KEY:     // 判断按键时间及键值判断
      if(funKeyTime < LONG_KEY_TIME) keyValue = M_KEY; 
      else                           keyValue = LONG_M_KEY; 
      break;
      
    case INC_KEY: keyValue = INC_KEY; break;
    case DEC_KEY: keyValue = DEC_KEY; break;
    default:
      keyValue = 0;
      if(keyFlag == DIS_SET_OFF)  KeyReset();
      break;
    }
    keyBuff = 0;
    funKeyTime = 0;  
    decKeyTime = 0;     
    incKeyTime = 0;  
    break;
    
  case M_KEY:
    if(funKeyTime == KEY_MAX_TIME) return;
    if(funKeyTime < LONG_KEY_TIME) return;
    keyValue = LONG_M_KEY;
    funKeyTime = KEY_MAX_TIME;
    break;
    
  case DEC_KEY:
    if(keyFlag != DIS_SET_OFF) return;
    if(decKeyTime == KEY_MAX_TIME) return;
    if(decKeyTime < LONG_KEY_TIME) return;
    keyValue = LONG_DEC_KEY;
    decKeyTime = KEY_MAX_TIME;
    break;
    
  case INC_KEY:
    if(keyFlag != DIS_SET_OFF) return;
    if(incKeyTime == KEY_MAX_TIME) return;
    if(incKeyTime < LONG_KEY_TIME) return;
    keyValue = LONG_INC_KEY;
    incKeyTime = KEY_MAX_TIME;
    break;
    
  case COMBO_KEY:
    if(incKeyTime == KEY_MAX_TIME) return;
    else if(decKeyTime == KEY_MAX_TIME) return;
    if(incKeyTime < LONG_KEY_TIME) return;
    if(decKeyTime < LONG_KEY_TIME) return;
    
    if(keyFlag != DIS_SET_OFF) return;
    keyValue = COMBO_KEY;
    incKeyTime = KEY_MAX_TIME;
    decKeyTime = KEY_MAX_TIME;
    break;
  }
}
  

/******************************************************************************/
unsigned long int ComputeSumOfFiveDigits(unsigned int modifyFirstBit, unsigned int modifyLastBit)
{
   unsigned long int computeSum = 0;
   
   for(; modifyFirstBit <= modifyLastBit; modifyFirstBit++)
   {
      computeSum *= (unsigned long int)10;
      computeSum += (unsigned long int)Dis1[modifyFirstBit];      
   }
   
   return computeSum;
}
      
/******************************************************************************/
void JudgeKeySetMax(unsigned int setBit, unsigned int endBit)
{
  unsigned int I;
  
  for(I = 0; setBit <= endBit; setBit++, I++)
  {
    if(Dis1[setBit] < setMax[I]) return;
    else if(Dis1[setBit] > setMax[I])
    { 
      Dis1[setBit] = setMax[I];
      parameterSetError = 1;
    }
  }
}

/******************************************************************************/
void JudgeKeySetMin(unsigned int setBit, unsigned int endBit)
{
  unsigned int I;
  
  for(I = 0; setBit <= endBit; setBit++, I++)
  {
    if(Dis1[setBit] > setMin[I]) return;
    else if(Dis1[setBit] < setMin[I])
    {
      Dis1[setBit] = setMin[I]; 
      parameterSetError = 1;
    }
  }
}

/******************************************************************************/
// 设置按键提示符
void SettingKeyPrompt(const unsigned char *Prompt)
{
  unsigned int I;
  
  for(I = FUN_CODE_1; I <= FUN_CODE_4; I++)  Dis1[I] = *Prompt++;
  for(I = FUN_PROMPT1; I <= FUN_PROMPT5; I++)  Dis1[I] = *Prompt++;
  Dis1[FUN_DECIMAL] = WORD_NULL;
  
  keyValue    = 0;
  keySetPoint = 0;
  SetDisplayArray(0);
}

/******************************************************************************/
void InitOfSettingArea(unsigned long int setValue, unsigned int startBit, unsigned int setLen)   
{
  unsigned int I;
  
  for(I = FUN_PROMPT1; I<=FUN_DECIMAL; I++)  Dis1[I] = WORD_NULL;   
  
  modifyBit = startBit;
  keyValue = 0;
  keyFlag  = FLASH_BIT;
  
  setKeyBuffer = setValue;
  ConvertHEXToBCDArray(setValue, &Dis1[startBit], setLen, HIGH_FIRST);
} 

/******************************************************************************/
void InitOfSettingPrompt(const unsigned char *PromptF, const unsigned char *Prompt)    
{
  unsigned int I;
  
  for(I = FUN_CODE_1; I <= FUN_CODE_4; I++)  Dis1[I] = *PromptF++;
  for(I = FUN_PROMPT1; I <= FUN_PROMPT5; I++)  Dis1[I] = *Prompt++;
  Dis1[FUN_DECIMAL] = WORD_NULL;
  
  setKeyBuffer = 0;
  modifyBit = FUN_PROMPT1;
  keyValue = 0;
  keyFlag  = FLASH_BIT;
}     

/******************************************************************************/
void ReturnKeySetup(void)
{
  menuIndex = STD_RETURN;                                                      // 长按键退出
  keyFlag   = DIS_PARA_INT;
  keyValue  = 0xff;
}

/******************************************************************************/
bool KeyValueOperation(unsigned int modifyFirstBit, unsigned int modifyLastBit)
{
  switch(keyValue)
  {
  case LONG_M_KEY:  
    keyFlag = 0xff; 
    keyDealFlag = STD_RETURN;                                              // 退出按键设置
    // 菜单状态直接退出
    // 参数设置直接跳至保存页面
    parameterSetError = 0;
    JudgeKeySetMax(modifyFirstBit, modifyLastBit);
    JudgeKeySetMin(modifyFirstBit, modifyLastBit);   
    setKeyBuffer = (unsigned long int)ComputeSumOfFiveDigits(modifyFirstBit, modifyLastBit);
    return 1;  
    
  case M_KEY:
    modifyBit++;
    keyValue = 0;    
    keyDealFlag = 0;
    
    if((modifyBit <= modifyLastBit) &&  (modifyBit >= modifyFirstBit)) break;
    
    parameterSetError = 0;
    JudgeKeySetMax(modifyFirstBit, modifyLastBit);
    JudgeKeySetMin(modifyFirstBit, modifyLastBit); 
    setKeyBuffer = (unsigned long int)ComputeSumOfFiveDigits(modifyFirstBit, modifyLastBit);
    
    return 1; 
    
  case INC_KEY:
    if(Dis1[modifyBit] >= 9) Dis1[modifyBit] = 0;
    else Dis1[modifyBit]++;   
    break;
    
  case DEC_KEY:
    if(Dis1[modifyBit] == 0) Dis1[modifyBit] = 9;
    else Dis1[modifyBit]--;  
    break;
    
  default:
    keyValue = 0;
    return 0;
  }
  
  JudgeKeySetMax(modifyFirstBit, modifyBit);
  JudgeKeySetMin(modifyFirstBit, modifyBit);
  keyValue = 0;
  return 0;
}

/******************************************************************************/
bool KeyValueOperateForPrompt(const unsigned char *Prompt, unsigned int selectMax, unsigned int selectMin)
{
  unsigned int I;
  
  //selectMax--;
  switch(keyValue)
  {
  case LONG_M_KEY: keyDealFlag = STD_RETURN; 
  case M_KEY:
    keyFlag  = DIS_PARA_INT;
    return 1;
    
  case INC_KEY:
    if(setKeyBuffer < (unsigned long int)selectMax)  setKeyBuffer++;
    else setKeyBuffer = (unsigned long int)selectMin;
    
    Prompt += setKeyBuffer*5;
    for(I = FUN_PROMPT1; I <= FUN_PROMPT5; I++) Dis1[I] = *Prompt++;
    break;
    
  case DEC_KEY:
    if(setKeyBuffer > selectMin) setKeyBuffer--;
    else                         setKeyBuffer = selectMax; 
    
    
    Prompt += setKeyBuffer*5;
    for(I = FUN_PROMPT1; I <= FUN_PROMPT5; I++) Dis1[I] = *Prompt++;
    break;
  } 
  
  keyValue = 0;
  return 0;
}

/******************************************************************************/
bool KeyValueOperateForArray(unsigned char *Prompt, unsigned int selectMax)
{
  unsigned int I;
  
  selectMax--;
  switch(keyValue)
  {
  case LONG_M_KEY: keyDealFlag = STD_RETURN; 
  case M_KEY:
    keyFlag  = DIS_PARA_INT;
    return 1;
    
  case INC_KEY:
    
    if(setKeyBuffer < (unsigned long int)selectMax) setKeyBuffer++;
    else     setKeyBuffer = 0;
    
    for(I = FUN_PROMPT1; I <= FUN_PROMPT5; I++) Dis1[I] = *Prompt++;
    break;
    
  case DEC_KEY:
    if(setKeyBuffer > 0) setKeyBuffer--;    
    else setKeyBuffer = (unsigned long int)selectMax;
    
    for(I = FUN_PROMPT1; I <= FUN_PROMPT5; I++) Dis1[I] = *Prompt++;
    break;
  } 
  
  keyValue = 0;
  return 0;
}

/******************************************************************************/
void DisplaySetIndex(void)
{
  if(keyFlag != DISPLAY_MENU) return;
  
  setKeyType = 0;
  switch(keyValue)
  {
  case LONG_M_KEY:
    keyFlag = 0xff;
    menuIndex = STD_RETURN;                                              // 退出按键设置
    break;
    
  case M_KEY:
    keyFlag = DIS_PARA_INT;
    keyValue = 0;
    break;
    
  case DEC_KEY:
    if(menuIndex > 1) menuIndex--;
    else              menuIndex = STD_KEY_QUIT;         
    
    break;
    
  case INC_KEY:  
    menuIndex++;
    if(menuIndex > STD_KEY_QUIT) menuIndex = 1;
    break;    
    
  } 
}

/******************************************************************************/
unsigned int SaveModifyValue(void)
{    
  if(keyFlag == DIS_PARA_INT)
  {
    modifyBit = FUN_PROMPT1;
    //keyFlag  = FLASH_BIT;
    keyFlag  = NO_FLASH_BIT;
    SettingKeyPrompt(&SAVE_Prompt[0]);
  }
  
  switch(keyValue)
  {
  case LONG_M_KEY:
  case M_KEY:
    keyValue = 0;
    if( Dis1[FUN_PROMPT1] == WORD_Y ) return SAVE; 
    return NO;
    
  case INC_KEY:  
  case DEC_KEY:
    if(Dis1[FUN_PROMPT1] == WORD_N)
    {
      Dis1[FUN_PROMPT1] = WORD_Y;
      Dis1[FUN_PROMPT2] = WORD_E;
      Dis1[FUN_PROMPT3] = WORD_S;
    }
    else
    {
      Dis1[FUN_PROMPT1] = WORD_N;
      Dis1[FUN_PROMPT2] = WORD_O;
      Dis1[FUN_PROMPT3] = WORD_NULL;
    }
    break;
    
  default: 
    break;          
  }
  
  keyValue = 0;
  return NEXT;
}

/******************************************************************************/
void ExitKeyOperation(void)
{    
  if(keyFlag == DISPLAY_MENU)
  {
    SettingKeyPrompt(&QUIT_Prompt[0]);
    return; 
  }
  else if(keyFlag == DIS_PARA_INT)
  {
    InitOfSettingPrompt(QUIT_Prompt, YESNO_VALUE);
    setKeyBuffer = 0;
  }
  
  if(KeyValueOperateForPrompt(YESNO_VALUE, 1, 0))
  {        
    keyValue = 0xFF;
    if(setKeyBuffer == 1) menuIndex = STD_RETURN;
    else                  keyFlag   = DISPLAY_MENU; 
  }
}

/******************************************************************************/
void JudgeSaveAndReturn(unsigned long int judgeValue, unsigned int setGain)
{
  setKeyBuffer *= (unsigned long int)setGain;
  
  // 如果为退出标志，且参数未被修改直接退出
  if(keyDealFlag == STD_RETURN)
  {
    if((parameterSetError != 0) || (setKeyBuffer == judgeValue)) 
    {
      ReturnKeySetup();
      return;      
    }
  }
  else if(parameterSetError == 1) 
  {
    setKeyType = 0;
    keyFlag    = DISPLAY_MENU;
    return;
  }
  
  keyFlag  = DIS_PARA_INT;
  setKeyType = 3;
}

/******************************************************************************/
bool KeyPasswordInput(void)
{
  if(keyFlag == DIS_PARA_INT)
  {
    SetDisplayArray(0);
    
    modifyBit = FUN_PROMPT1;
    keyFlag  = FLASH_BIT;
    
    ClearDisplay();      
    SettingKeyPrompt(&PassWord_Prompt[0]);       
    ConvertHEXToBCDArray((unsigned long int)99999, &setMax[0], 5, HIGH_FIRST);
    ConvertHEXToBCDArray((unsigned long int)0, &setMin[0], 5, HIGH_FIRST); 
  }
  
  keyFlag = FLASH_BIT;
  if(KeyValueOperation(FUN_PROMPT1, FUN_PROMPT5))
  {   
    PassWord = (unsigned long int)setKeyBuffer;
    return 1;
  }
  else return 0;
}

/******************************************************************************/
void JudgePasswordInput(unsigned long int activePassword)
{
  if(PassWord == activePassword) 
  {
    setKeyType++;
    keyFlag = DIS_PARA_INT;
    return;
  }
  else if(!KeyPasswordInput()) return;    
  
  if(keyDealFlag == STD_RETURN)
  { 
    keyFlag = 0xff; 
    menuIndex = STD_RETURN;         // 退出按键设置
    // 菜单状态直接退出
    // 参数设置直接跳至保存页面
  }   
  else if(PassWord == activePassword) 
  {
    setKeyType++;
    keyFlag = DIS_PARA_INT;    
  }
  else
  {
    keyFlag = DISPLAY_MENU; 
    setKeyType = 0;
    keyValue = 0xff;
  }
}

/******************************************************************************/
bool ExitCurrentSetup(void)
{
  unsigned int I;
  
  I = SaveModifyValue();
  keyValue = 0;
  if(I == NEXT) return 0;               // 继续选择是否保存？
  
  PassWord   = 0;
  setKeyType = 0;
  keyFlag    = DISPLAY_MENU;
  keyValue   = 0xff;
  
  if(keyDealFlag == STD_RETURN)  menuIndex = STD_RETURN;
  if(I != SAVE)                  return 0;                                     // 执行保存或放弃保存操作，并返还菜单
  
  return 1;
}

/******************************************************************************/
// 设置仪表系数
bool ParameterSetup(void)
{   
  // display key function code
  if(setKeyType == 0)
  { 
    if(keyFlag == DISPLAY_MENU)     
    {
      SettingKeyPrompt(KeyStruct.Prompt);	
      setKeyBuffer = 0;  
      return 0; 
    }
    else if(keyFlag == DIS_PARA_INT) setKeyType = 1;
  }
  
  // display password
  if(setKeyType == 1)
  { 
    if((KeyStruct.Type & NEED_PASSWORD) == NEED_PASSWORD) JudgePasswordInput(KeyStruct.Password);
    else setKeyType = 2;                             
  }
  
  // setup key value
  if(setKeyType == 2) 
  {
    //列表参数初始化
    if((KeyStruct.Type & PARM_LIST_SEL) == PARM_LIST_SEL)
    {
      if(keyFlag == DIS_PARA_INT)
      {
        InitOfSettingPrompt(KeyStruct.Prompt, KeyStruct.Prompt+LIST_VALUE_BASE + KeyStruct.Value*5);
        keyFlag = NO_FLASH_BIT;
        setKeyBuffer = KeyStruct.Value;  
      }
      else if(KeyValueOperateForPrompt(KeyStruct.Prompt+LIST_VALUE_BASE, KeyStruct.Max, KeyStruct.Min)) setKeyType = 3;
    }
    // 操作类设置
    else if((KeyStruct.Type & OPERATION_CLASS) == OPERATION_CLASS)
    {
      if(keyFlag == DIS_PARA_INT)
      {
        InitOfSettingPrompt(KeyStruct.Prompt + LIST_PROMPT_BASE, YESNO_VALUE + KeyStruct.Value*5);
        keyFlag = NO_FLASH_BIT;
        setKeyBuffer = KeyStruct.Value;  
      }
      else if(KeyValueOperateForPrompt(YESNO_VALUE, KeyStruct.Max, KeyStruct.Min))
      {
        KeyStruct.Value = setKeyBuffer;
        PassWord   = 0;
        setKeyType = 0;
        keyFlag    = DISPLAY_MENU;
        keyValue   = 0xff;
        if(keyDealFlag == STD_RETURN) ReturnKeySetup();
        return 1;
      }
    } 
    // 参数可任意设置类
    else
    {
      unsigned int startPrompt;
      
      startPrompt = FUN_PROMPT5 - (KeyStruct.Type & 0x000f) + 1;
      if(keyFlag == DIS_PARA_INT)
      {
        ConvertHEXToBCDArray(KeyStruct.Max, &setMax[0], KeyStruct.Type, HIGH_FIRST);
        ConvertHEXToBCDArray(KeyStruct.Min, &setMin[0], KeyStruct.Type, HIGH_FIRST); 
        InitOfSettingArea(KeyStruct.Value/KeyStruct.Gain, startPrompt, KeyStruct.Type); // 初始化参数设置区域              
      }
      else if(KeyValueOperation(startPrompt, FUN_PROMPT5)) JudgeSaveAndReturn(KeyStruct.Value, KeyStruct.Gain); 
    }
  }
  
  //===========================================================================
  // 保存设置参数
  if(setKeyType != 3) return 0;
  if(!ExitCurrentSetup()) return 0;
  
  KeyStruct.Value = setKeyBuffer;  
  if((KeyStruct.Type & NO_SAVE) == NO_SAVE) return 1;
  
  tempDev.DWord[0] = (unsigned long int)setKeyBuffer;
  KeyStruct.Value = WriteLongParameterToEEPROM(KeyStruct.Addr, KeyStruct.Width);
  return 1;
}

/******************************************************************************/
//修改二次修正点数
void SelectDcoefNode(void)
{
  if(keyFlag == DIS_PARA_INT)
  {
    SetDisplayArray(0);
    modifyBit = FUN_PROMPT5;
    keyValue = 0;
    keySetPoint = 0;
    keyFlag  = FLASH_BIT;
    
    //STD_KEY_CORR                           14  // F14	二次修正系数  CORR
    Dis1[FUN_CODE_1]  = WORD_F;
    Dis1[FUN_CODE_2]  = 1;
    Dis1[FUN_CODE_3]  = 4;
    Dis1[FUN_CODE_4]  = WORD_NULL;  
    
    Dis1[FUN_PROMPT1] = WORD_C;    
    Dis1[FUN_PROMPT2] = WORD_O;
    Dis1[FUN_PROMPT3] = WORD_R;
    Dis1[FUN_PROMPT4] = WORD_LINE;
    Dis1[FUN_PROMPT5] = setIndex+1;
    Dis1[FUN_DECIMAL] = WORD_NULL;
    
    setMax[0] = 9;
    setMin[0] = 1;
    //ConvertHEXToBCDArray((unsigned long int)METER_PARAMETER_MAX, &setMax[0], 5, HIGH_FIRST);
    //ConvertHEXToBCDArray((unsigned long int)METER_PARAMETER_MIN, &setMin[0], 5, HIGH_FIRST); 
  }
  
  if(KeyValueOperation(FUN_PROMPT5, FUN_PROMPT5))
  {
    if(keyDealFlag == STD_RETURN)  ReturnKeySetup();
    else
    {
      if(Dis1[FUN_PROMPT5] > dcoefNum)
      {
        //Dis1[FUN_PROMPT5] = dcoefNum; 
        setKeyType = 0;
        keyValue = 0xff;
        keyFlag = DISPLAY_MENU;
        return;
      }
      setIndex = Dis1[FUN_PROMPT5]-1;
      keyFlag  = DIS_PARA_INT;
      setKeyType++;
      
      temp_dcoefNode[setIndex] = dcoefNode[setIndex];
      temp_dcoefVal[setIndex]  = dcoefVal[setIndex];
    }
  }
  
  if(Dis1[FUN_PROMPT5] > dcoefNum)
  {
    //Dis1[FUN_PROMPT5] = dcoefNum; 
    setKeyType = 0;
    keyValue = 0xff;
    keyFlag = DISPLAY_MENU;
  }
}

/******************************************************************************/
void ModifyDcoefNode(void)
{
  //unsigned long inttemp;
  
  if(keyFlag == DIS_PARA_INT)
  {
    SetDisplayArray(0);
    
    keyValue  = 0;
    keyFlag   = FLASH_BIT;
    
    Dis1[FUN_CODE_1] = WORD_P;      
    Dis1[FUN_CODE_2] = setIndex+1;      
    Dis1[FUN_CODE_3] = WORD_LINE;
    Dis1[FUN_CODE_4] = WORD_F;
    
    //键值处理
#ifndef ENABLE_LED_DISPLAY 
#pragma message("[undefined] ENABLE_LED_DISPLAY")
#elif(ENABLE_LED_DISPLAY)
    modifyBit = FUN_PROMPT1;
    ConvertHEXToBCDArray(dcoefNode[setIndex]/100, &Dis1[FUN_PROMPT1], 5, HIGH_FIRST);
#else
    Dis1[FUN_PROMPT1] = WORD_NULL;
    modifyBit = FUN_PROMPT2;
    ConvertHEXToBCDArray(dcoefNode[setIndex]/100, &Dis1[FUN_PROMPT2], 5, HIGH_FIRST);
#endif
    ConvertHEXToBCDArray((unsigned long int)99999, &setMax[0], 5, HIGH_FIRST);
    ConvertHEXToBCDArray((unsigned long int)0, &setMin[0], 5, HIGH_FIRST);  
    
    keySetPoint = 1;
  }
  
  //键值处理
#ifndef ENABLE_LED_DISPLAY 
#pragma message("[undefined] ENABLE_LED_DISPLAY")
#elif(ENABLE_LED_DISPLAY)
    if(KeyValueOperation(FUN_PROMPT1, FUN_PROMPT5))
#else
    if(KeyValueOperation(FUN_PROMPT2, FUN_DECIMAL))
#endif
    {         
      temp_dcoefNode[setIndex] = setKeyBuffer * 100;
      
      if(keyDealFlag == STD_RETURN) setKeyType = 5;
      else                          setKeyType++;
      keyFlag = DIS_PARA_INT;
    }
  
  keyValue = 0;
}

/******************************************************************************/
void ModifyDcoefVal(void)
{ 
  if(keyFlag == DIS_PARA_INT)
  {
    SetDisplayArray(0);
    
    modifyBit = FUN_PROMPT1;
    keyValue  = 0;
    keyFlag   = FLASH_BIT;
    keySetPoint = 0;
    
    Dis1[FUN_CODE_1] = WORD_P;      
    Dis1[FUN_CODE_2] = setIndex+1;      
    Dis1[FUN_CODE_3] = WORD_LINE;
    Dis1[FUN_CODE_4] = WORD_V;
    
    Dis1[FUN_PROMPT1] = WORD_NULL;
    Dis1[FUN_DECIMAL] = WORD_NULL;
    
    ConvertHEXToBCDArray(dcoefVal[setIndex], &Dis1[FUN_PROMPT1], 5, HIGH_FIRST);
    ConvertHEXToBCDArray((unsigned long int)METER_PARAMETER_MAX, &setMax[0], 5, HIGH_FIRST);
    ConvertHEXToBCDArray((unsigned long int)METER_PARAMETER_MIN, &setMin[0], 5, HIGH_FIRST); 
  }
  
  //键值处理
  if(KeyValueOperation(FUN_PROMPT1, FUN_PROMPT5))
  {
    temp_dcoefVal[setIndex] = (unsigned int)setKeyBuffer;
    
    //if(menuIndex == STD_RETURN)  setKeyType = 5;
    if(keyDealFlag == STD_RETURN) setKeyType = 5;
    else                          setKeyType++;
    keyFlag = DIS_PARA_INT;
  }
}

/******************************************************************************/
void ModifyDcoefNodeAndValue(void)
{
  if(setKeyType == 0)
  {
    if(keyFlag == DISPLAY_MENU)
    {
      //STD_KEY_CORR             14  // F14	二次修正系数  CORR
      SettingKeyPrompt(&CORR_Prompt[0]);
      setIndex = 0;
      return;
    }
    else if(keyFlag == DIS_PARA_INT) setKeyType = 1;
  }
  
  if(setKeyType == 1) JudgePasswordInput(LEVEL_2_PASSWORD);                    //2222
  if(setKeyType == 2) SelectDcoefNode();        
  if(setKeyType == 3) ModifyDcoefNode();               
  if(setKeyType == 4) ModifyDcoefVal();
  
  //===========================================================================
  // 保存设置参数
  if(setKeyType != 5) return;
  unsigned int keyState;
  
  if(keyDealFlag == STD_RETURN)
  {
    if((dcoefNode[setIndex] == temp_dcoefNode[setIndex]) && (dcoefVal[setIndex] == temp_dcoefVal[setIndex])) 
    {
      ReturnKeySetup();
      return;
    } 
  }
  
  keyState = SaveModifyValue();
  keyValue = 0;
  if(keyState == NEXT) return;                           // 继续选择是否保存？
  if(keyDealFlag == STD_RETURN) menuIndex = STD_RETURN;  // 长按键退出
  
  setKeyType = 2;
  keyFlag    = DIS_PARA_INT;
  keyValue   = 0xff;
  if(keyState != SAVE) return;                           // 执行保存或放弃保存操作，并返还菜单
  
  // 存储二次修正系数
  dcoefNode[setIndex] = temp_dcoefNode[setIndex];
  dcoefVal[setIndex]  = temp_dcoefVal[setIndex];
  StoreDevCoefNodeAndValue(setIndex);
  // RetriveDevCoef();
}

/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
void KeyInputProcessing(void)
{ 
  FlashBitForSetup();
  ReadKeyValue();
  
  while(keyValue != 0)
  {
    IDvalidTime = 0;
    DisplaySetIndex();
    switch(menuIndex)
    {
    case STD_INIT_PASSWORD:                                                // input password
      if(keyFlag == DIS_SET_OFF)
      {
        switch(keyValue)
        {
        case LONG_M_KEY: keyFlag = DIS_PARA_INT; break;
        //====================================================================
        #ifndef ENABLE_ALTERNATE_DISPLAY 
        #pragma message("[undefined] ENABLE_ALTERNATE_DISPLAY")
        #elif(ENABLE_ALTERNATE_DISPLAY)
        case M_KEY: 
          displayNow++;
          displayCNT = 0;
          if(displayNow > (unsigned int)DISPLAY_MAX) displayNow = 0;
          if(displayType == (u8)DISPLAY_FIXED)
          {
            tempDev.DWord[0] = (unsigned long int)displayNow;
            displayNow = (u8)WriteParameterToEEPROM(DIS_MOD, DIS_MOD_WIDTH);
          }
          menuIndex = STD_RETURN;
          continue;
        #endif
                    
        //====================================================================
       #ifndef ENABLE_LEAK_DETECT
       #pragma message("[undefined] ENABLE_LEAK_DETECT")
       #elif(ENABLE_LEAK_DETECT)
        case LONG_INC_KEY:
          keyValue = 0;
          alarmState1 &= ~LEAK_ALARM;
          alarmState1 &= ~VALVE_OFF_ALARM;   // TURN ON 
          leakDetectCounter = 0;
          DisplayValveState();
          IDvalidTime = COUNTDOWN_3S;
          return;
          
        case LONG_DEC_KEY:
          keyValue = 0;
          alarmState1 &= ~LEAK_ALARM;
          alarmState1 |= VALVE_OFF_ALARM;   // TURN OFF
          leakDetectCounter = 0;
          DisplayValveState();
          IDvalidTime = COUNTDOWN_3S;
          return;
        #endif
          
        //====================================================================
        #ifndef ENABLE_KEY_FOR_FAST_OFFSET 
        #pragma message("[undefined] ENABLE_KEY_FOR_FAST_OFFSET")
        #elif(ENABLE_KEY_FOR_FAST_OFFSET) 
        case COMBO_KEY:
          keyValue = 0;          
          if(flowRate > (maxFlowRate>>4)) continue;
          tempDev.Word[0] = (unsigned int)voltageDetected[NIDX];
          offsetGas = (unsigned int)WriteLongParameterToEEPROM(OFFSET_GAS, OFFSET_GAS_WIDTH); 
          FullScreenFlashing();
          IDvalidTime = COUNTDOWN_3S;
          return;
         #endif
          
         //===================================================================
        default:
          KeyReturn(); 
          return;
        }
      }
      
      if(!KeyPasswordInput()) break;
      keyValue = 0xff;
      keyFlag  = DISPLAY_MENU;   
      if((PassWord != LEVEL_1_PASSWORD) && (PassWord != keyPassWord)) menuIndex = STD_RETURN;
      else                                                            menuIndex = STD_KEY_ADDR; 
      continue;
      
      //=====================================================================
      // 接口类（F1-F9）	
      //case STD_KEY_PRTCL                                                // F1	通讯协议      PRTCL	
    case STD_KEY_ADDR:                                                    // F2	从机地址      ADDR
      KeyStruct.Prompt = ADDR_Prompt;
      KeyStruct.Value  = (unsigned long int)localAddress;
      KeyStruct.Type   = 3;
      KeyStruct.Gain   = 1;
      KeyStruct.Max    = (unsigned long int)SLAVER_ADDR_MAX;
      KeyStruct.Min    = (unsigned long int)SLAVER_ADDR_MIN;
      KeyStruct.Addr   = (unsigned int)SLAVER_ADDR;
      KeyStruct.Width  = (unsigned int)SLAVER_ADDR_WIDTH;
      ParameterSetup();
      localAddress = (unsigned int)KeyStruct.Value;  
      break;   
      
      //=====================================================================
    #ifndef ENABLE_KEY_FOR_BPS 
    #pragma message("[undefined] ENABLE_KEY_FOR_BPS")
    #elif(ENABLE_KEY_FOR_BPS)
    case STD_KEY_BPS:                                                     // F3	波特率	      BPS	
      KeyStruct.Prompt = BPS_Prompt;     
      KeyStruct.Value  = (unsigned long int)baudRate;    
      KeyStruct.Max    = 4;   
      KeyStruct.Min    = 0;   
      KeyStruct.Type   = PARM_LIST_SEL;  
      KeyStruct.Addr   = (unsigned int)BAUD_RATE;
      KeyStruct.Width  = (unsigned int)BAUD_RATE_WIDTH;      
      ParameterSetup();
      if(baudRate != (unsigned int)KeyStruct.Value)
      {
        baudRate = (unsigned int)KeyStruct.Value;
        RS485UartInit(BPS[baudRate]);
      }
      break;
    #endif
      
      //=====================================================================
      // 流量类（F11-F30）	
    #ifndef ENABLE_KEY_FOR_OFFSET 
    #pragma message("[undefined] ENABLE_KEY_FOR_OFFSET")
    #elif(ENABLE_KEY_FOR_OFFSET)
    case STD_KEY_OFFST:   //CalibrateOffsetC();        break;                   // F11	校准零点      OFFST (0520)
      KeyStruct.Prompt = OFFST_Prompt;     
      KeyStruct.Value  = NO;    
      KeyStruct.Max    = YES;   
      KeyStruct.Min    = NO;   

      #if(ENABLE_KEY_FOR_OFFSET_NEED_PASSWORD)
      KeyStruct.Password = 520;  
      KeyStruct.Type   = OPERATION_CLASS | NO_SAVE | NEED_PASSWORD;        
      #else
      KeyStruct.Type   = OPERATION_CLASS | NO_SAVE;  
      #endif
      
      ParameterSetup();
      if(KeyStruct.Value == YES)
      {
        tempDev.Word[0] = (unsigned int)voltageDetected[NIDX];
        offsetGas = (unsigned int)WriteLongParameterToEEPROM(OFFSET_GAS, OFFSET_GAS_WIDTH); 
      }
      break;
    #endif
      
      //=====================================================================
    #ifndef ENABLE_KEY_FOR_GCF 
    #pragma message("[undefined] ENABLE_KEY_FOR_GCF")
    #elif(ENABLE_KEY_FOR_GCF)
    case STD_KEY_GCF:                                                           // F12	GCF	      GCF	
      KeyStruct.Prompt = GCF_Prompt;
      KeyStruct.Value  = (unsigned long int)GDCFactor;
      KeyStruct.Type   = 4;
      KeyStruct.Gain   = 1;
      KeyStruct.Max    = (unsigned int)GCF_PARAMETER_MAX;
      KeyStruct.Min    = (unsigned int)GCF_PARAMETER_MIN;
      KeyStruct.Addr   = (unsigned int)GCF_B;
      KeyStruct.Width  = (unsigned int)GCF_B_WIDTH;
      ParameterSetup();
      GDCFactor = (unsigned int)KeyStruct.Value;  
      break;      
    #endif
      
      //=====================================================================
    #ifndef ENABLE_KEY_FOR_METERFACTOR 
    #pragma message("[undefined] ENABLE_KEY_FOR_METERFACTOR")
    #elif(ENABLE_KEY_FOR_METERFACTOR)
    case STD_KEY_FACTR:                                                    // F13	仪表系数      FACTR
      KeyStruct.Prompt = FACTR_Prompt;
      KeyStruct.Value  = (unsigned long int)MeterFactor;
      KeyStruct.Type   = 5;
      KeyStruct.Gain   = 1;
      KeyStruct.Max    = (unsigned int)METER_PARAMETER_MAX;
      KeyStruct.Min    = (unsigned int)METER_PARAMETER_MIN;
      KeyStruct.Addr   = (unsigned int)METER_FACTOR;
      KeyStruct.Width  = (unsigned int)METER_FACTOR_WIDTH;
      ParameterSetup();
      MeterFactor = (unsigned int)KeyStruct.Value;           
      break;             
    #endif
      
      //=====================================================================
    #ifndef ENABLE_KEY_FOR_DCOEF 
    #pragma message("[undefined] ENABLE_KEY_FOR_DCOEF")
    #elif(ENABLE_KEY_FOR_DCOEF)
    case STD_KEY_CORR:    ModifyDcoefNodeAndValue(); break;                // F14	二次修正系数  CORR
    #endif
    
    //=====================================================================
    #ifndef ENABLE_KEY_FOR_MAXFLOWRATE 
    #pragma message("[undefined] ENABLE_KEY_FOR_MAXFLOWRATE")
    #elif(ENABLE_KEY_FOR_MAXFLOWRATE)
    case STD_KEY_FS:                                                       // F15	量程设置      FS
      KeyStruct.Prompt = FS_Prompt;
      KeyStruct.Value  = maxFlowRate;
      KeyStruct.Type   = 5;
      KeyStruct.Gain   = 1000;
      KeyStruct.Max    = 99999;
      KeyStruct.Min    = 0;
      KeyStruct.Addr   = MAX_FLOW;
      KeyStruct.Width  = MAX_FLOW_WIDTH;
      ParameterSetup();
      maxFlowRate = KeyStruct.Value;
      break;     
    #endif
      
      //=====================================================================
    #ifndef ENABLE_KEY_FOR_RESPONSE 
    #pragma message("[undefined] ENABLE_KEY_FOR_RESPONSE")
    #elif(ENABLE_KEY_FOR_RESPONSE)
    case STD_KEY_RESPS:                                                         // F16	响应时间      RESPS	
      KeyStruct.Prompt   = RESPS_Prompt;    
      KeyStruct.Value    = responseTimeIndex; //factoryInterval;  SetupResponseTime(responseTime)
      KeyStruct.Type     = PARM_LIST_SEL;
      KeyStruct.Max      = 5;    
      KeyStruct.Min      = 0;  
      KeyStruct.Addr     = SAMPLE_PERIOD;  
      KeyStruct.Width    = SAMPLE_PERIOD_WIDTH;
      ParameterSetup();
      //factoryInterval = KeyStruct.Value;
      //responseTime = Timing[KeyStruct.Value];
      
      responseTimeIndex = KeyStruct.Value;
      responseTime = SetupResponseTime(responseTimeIndex, RESPONSE_TIME_DEFAULT);
      break;
      #endif
      
      //=====================================================================
      //case STD_KEY_CUT_F                                                      // F28	小流量切除    CUT-F	
      //=====================================================================
    #if(ENABLE_KEY_FOR_PLUG_IN_FLOWRATE)
    case STD_KEY_DIAM:                                                          // F29	管径设置      DIAM
      KeyStruct.Prompt = DIAM_Prompt;    
      KeyStruct.Value  = workDiameter;
      KeyStruct.Type   = 5;
      KeyStruct.Gain   = 1;
      KeyStruct.Max    = 5000;
      KeyStruct.Min    = 25;
      KeyStruct.Addr   = WORK_DIAMETER;
      KeyStruct.Width  = WORK_DIAMETER_WIDTH;
      ParameterSetup();
      workDiameter = KeyStruct.Value;
      break;
    #endif
      
      //=======================================================================
      // 显示类（F31-F40）
    #ifndef ENABLE_KEY_FOR_ACC_UNIT 
    #pragma message("[undefined] ENABLE_KEY_FOR_ACC_UNIT")
    #elif(ENABLE_KEY_FOR_ACC_UNIT)
    case STD_KEY_UNT_A:                                                         // F31	累积流量单位	UNT-A	
      KeyStruct.Prompt = UNTA_Prompt;     
      KeyStruct.Value  = (unsigned long int)AccDisUnit;    
      KeyStruct.Max    = KG;    
      KeyStruct.Min    = ML;              
      KeyStruct.Type   = PARM_LIST_SEL | NO_SAVE;  
//      if(ParameterSetup())
//      {
//        AccUnit = (unsigned int)KeyStruct.Value;
//        CombinedUnit();
//        tempDev.Word[0] = (unsigned int)flowUnit;
//        flowUnit = (unsigned int)WriteParameterToEEPROM(WORK_UNIT, WORK_UNIT_WIDTH); 
//        JudgeFlowRateUnit(flowUnit);
//      }
      if(ParameterSetup())
      {
        AccDisUnit = (u16)KeyStruct.Value;
        CombinedUnitByACC();
        ConvertAllFlowRateAndSave(flowUnit);
        break;
      }
      
      if(setKeyType != 2) break;
      if(JudgeflowAccUnit(setKeyBuffer)) break;
      keyValue = keyLastValue;
      continue;
      break;   
    #endif
      
      //=======================================================================
    #ifndef ENABLE_KEY_FOR_FLOWRATE_UNIT 
    #pragma message("[undefined] ENABLE_KEY_FOR_FLOWRATE_UNIT")
    #elif(ENABLE_KEY_FOR_FLOWRATE_UNIT)
    case STD_KEY_UNT_F:                                                         // F32	实时流量单位	UNT-F
      KeyStruct.Prompt = UNTF_Prompt;     
      KeyStruct.Value  = (unsigned long int)flowDisUnit;    
      KeyStruct.Max    = SCFH; //NCMH;    
      KeyStruct.Min    = SLPM; 
      KeyStruct.Type   = PARM_LIST_SEL | NO_SAVE;  
//      if(ParameterSetup())
//      {
//        flowDisUnit = (unsigned int)KeyStruct.Value;
//        CombinedUnit();
//        tempDev.Word[0] = (unsigned int)flowUnit;
//        flowUnit = (unsigned int)WriteParameterToEEPROM(WORK_UNIT, WORK_UNIT_WIDTH); 
//        JudgeFlowRateUnit(flowUnit);
//      }
      
      if(ParameterSetup())
      {
        flowDisUnit = (u16)KeyStruct.Value;
        CombinedUnitByFlowRate();
        ConvertAllFlowRateAndSave(flowUnit);
        break;
      }
      
      if(setKeyType != 2) break;
      if(JudgeflowUserUnit(setKeyBuffer)) break;
      keyValue = keyLastValue;
      continue;
      break;  
    #endif
      
    //case STD_KEY_UNT_P                                                      // F33	压力单位	UNT-P	
    //=======================================================================
    #ifndef ENABLE_ALTERNATE_DISPLAY 
    #pragma message("[undefined] ENABLE_ALTERNATE_DISPLAY")
    #elif(ENABLE_ALTERNATE_DISPLAY)
    case STD_KEY_DISP:                                                          // F38	显示模式	DISP	
      if(SysPressure == 0) continue;
      
      KeyStruct.Prompt = DISP_Prompt; 
      KeyStruct.Type   = PARM_LIST_SEL;
      KeyStruct.Value  = (unsigned long int)displayType;
      KeyStruct.Max    = 1;    
      KeyStruct.Min    = 0;  
      KeyStruct.Addr   = DIS_MOD;  
      KeyStruct.Width  = DIS_MOD_WIDTH;      
      ParameterSetup();
      displayType = (unsigned char)KeyStruct.Value;
      break;
    #endif
      
    //=======================================================================
    #ifndef ENABLE_KEY_FOR_LANGUAGE 
    #pragma message("[undefined] ENABLE_KEY_FOR_LANGUAGE")
    #elif(ENABLE_KEY_FOR_LANGUAGE)
    case STD_KEY_DIS_LANGUAGE:                                                  // F39	显示语言模式	LANG	
      KeyStruct.Prompt   = LANG_Prompt; 
      KeyStruct.Type     = PARM_LIST_SEL;
      KeyStruct.Max      = 2;    
      KeyStruct.Min      = 0;  
      KeyStruct.Value    = (unsigned long int)language;
      KeyStruct.Addr     = DIS_LANGUAGE;  
      KeyStruct.Width    = DIS_LANGUAGE_WIDTH;      
      ParameterSetup();
      language = (unsigned char)KeyStruct.Value;
      break;
    #endif
      
    //=======================================================================
    // 模拟接口类（F31-F40）
    #ifndef ENABLE_KEY_FOR_PULSE 
    #pragma message("[undefined] ENABLE_KEY_FOR_PULSE")
    #elif(ENABLE_KEY_FOR_PULSE)
    case STD_KEY_PULSE:                                                         // F41	脉冲当量	PULSE
      //------------------------------------------------------------------------
      #ifndef ENABLE_PULSE_USE_CALIB_SETUP 
      #pragma message("[undefined] ENABLE_PULSE_USE_CALIB_SETUP")
      #elif(ENABLE_PULSE_USE_CALIB_SETUP)
      KeyStruct.Prompt = PULSE_Prompt;
      KeyStruct.Value  = maxFlowRate;
      KeyStruct.Type   = 5;
      KeyStruct.Gain   = 1;
      KeyStruct.Max    = 10000;
      KeyStruct.Min    = 100;
      KeyStruct.Addr   = PULSE_UNIT;
      KeyStruct.Width  = PULSE_UNIT_WIDTH;
      ParameterSetup();
      maxFlowRate = KeyStruct.Value;
      //------------------------------------------------------------------------
      #else
      //------------------------------------------------------------------------
      KeyStruct.Prompt   = PULSE_Prompt;    
      KeyStruct.Type     = PARM_LIST_SEL | NO_SAVE;
      KeyStruct.Value    = (unsigned long int)(factoryUnitPerPulse-PULSE_MIN_UNIT);
      KeyStruct.Max      = (unsigned long int)PULSE_UNIT_INDEX_MAX;   
      KeyStruct.Min      = (unsigned long int)PULSE_UNIT_INDEX_MIN;
      if(ParameterSetup())
      {
        factoryUnitPerPulse  = KeyStruct.Value;
        factoryUnitPerPulse += PULSE_MIN_UNIT;
        //InitPulseUnit();
        tempDev.DWord[0] = (unsigned long int)factoryUnitPerPulse;
        factoryUnitPerPulse = WriteLongParameterToEEPROM(PULSE_UNIT, PULSE_UNIT_WIDTH);
      }
      #endif
      //------------------------------------------------------------------------
      break;
      #endif
      
    //=======================================================================
    // 报警类（F41-F50）
    //=======================================================================
    #ifndef ENABLE_KEY_FOR_ALARM_FR 
    #pragma message("[undefined] ENABLE_KEY_FOR_ALARM_FR")
    #elif(ENABLE_KEY_FOR_ALARM_FR)
      // 报警类（F41-F50）
    case STD_KEY_ALM_H:                                                         // F51	高流量报警	ALM-H	
      KeyStruct.Prompt = ALMH_Prompt;
      KeyStruct.Value  = alarmUpperFlowRate;
      KeyStruct.Type   = 5;
      KeyStruct.Gain   = 1000;
      KeyStruct.Max    = 99999;
      KeyStruct.Min    = 0;
      KeyStruct.Addr   = HIGH_FLOW_ALARM;
      KeyStruct.Width  = HIGH_FLOW_ALARM_WIDTH;
      ParameterSetup();
      alarmUpperFlowRate = KeyStruct.Value;
      break;    
      
      //=======================================================================
    case STD_KEY_ALM_L:                                                         // F52	低流量报警	ALM-L	
      KeyStruct.Prompt = ALML_Prompt;
      KeyStruct.Value  = alarmLowerFlowRate;
      KeyStruct.Type   = 5;
      KeyStruct.Gain   = 1000;
      KeyStruct.Max    = 99999;
      KeyStruct.Min    = 0;
      KeyStruct.Addr   = LOW_FLOW_ALARM;
      KeyStruct.Width  = LOW_FLOW_ALARM_WIDTH;
      ParameterSetup();
      alarmLowerFlowRate = KeyStruct.Value;
      break;   
    #endif
      
      //case STD_KEY_ALM_A                                                // F53     总量报警上限	ALM-A	
      //case STD_KEY_ALM_T                                                // F54     时间报警	ALM-T
      //=======================================================================
      //case STD_KEY_LORA_ADDR:                                           // F71     LORA本机地址    LR-ID
      //case STD_KEY_LORA_ID:                                             // F72     LORA上级地址    NETID
      //case STD_KEY_LORA_CHAN:                                           // F73     LORA信道        LR_CH         
      
      //=======================================================================
      // 操作类（F91-F98）
    #ifndef ENABLE_KEY_FOR_PASSWORD 
    #pragma message("[undefined] ENABLE_KEY_FOR_PASSWORD")
    #elif(ENABLE_KEY_FOR_PASSWORD)
    case STD_KEY_PASS:                                                   // F91	设置密码	PASS	
      KeyStruct.Prompt = PASS_Prompt;
      KeyStruct.Value  = keyPassWord;
      KeyStruct.Type   = 5;
      KeyStruct.Gain   = 1;
      KeyStruct.Max    = 99999;
      KeyStruct.Min    = 0;
      KeyStruct.Addr   = KEY_PASSWORD;
      KeyStruct.Width  = KEY_PASSWORD_WIDTH;
      ParameterSetup();
      keyPassWord = KeyStruct.Value;
      break;
     #endif
    //=====================================================================
    #ifndef ENABLE_KEY_FOR_CLR_ACC 
    #pragma message("[undefined] ENABLE_KEY_FOR_CLR_ACC")
    #elif(ENABLE_KEY_FOR_CLR_ACC)
    case STD_KEY_CLR_A:                                                 // F92	清除总流量	CLR-A	
      KeyStruct.Prompt = CLRA_Prompt;     
      KeyStruct.Value  = NO;    
      KeyStruct.Max    = YES;    
      KeyStruct.Min    = NO;    
      KeyStruct.Type   = OPERATION_CLASS | NO_SAVE| NEED_PASSWORD;          
      KeyStruct.Password = 22222;  
      if(ParameterSetup() && (KeyStruct.Value == YES)) ClearACC();
      break;
     #endif
     //=====================================================================
     //case STD_KEY_CLR_T                                                // F93	清除时间	CLR-T	
     //=====================================================================
    #ifndef ENABLE_KEY_FOR_RESET_DCOEF 
    #pragma message("[undefined] ENABLE_KEY_FOR_RESET_DCOEF")
    #elif(ENABLE_KEY_FOR_RESET_DCOEF)
    case STD_KEY_RESET_DCOEF:                                             // F94	恢复二次修正	RS2ND	
      KeyStruct.Prompt = RS2ND_Prompt;     
      KeyStruct.Value  = NO;    
      KeyStruct.Max    = YES;   
      KeyStruct.Min    = NO;       
      KeyStruct.Type   = OPERATION_CLASS | NO_SAVE | NEED_PASSWORD;          
      KeyStruct.Password = 22222;  
      //ParameterSetup();
      if(ParameterSetup() && (KeyStruct.Value == YES)) DefaultDevCoef();
      break;  
     #endif
      //========================================================================
      // 退出
    case STD_KEY_QUIT: ExitKeyOperation(); break;                        // F99	退出设置	QUIT	
    case STD_RETURN:
      KeyReset();
      //DisableKeyInterrupt();
      NumericPrepForOutputAndDisplay();  
      return;
      
    default: continue;
    }  
    
    DisplayForKeyOperation();
  }
}

//##############################################################################
#endif
//##############################################################################