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

//##############################################################################
#if(ENABLE_KEY_FUNCTION)
//##############################################################################
//==============================================================================
unsigned int keyDealFlag;
bool isKeyPressed, keySetPoint;               // 键响应程序进入标志
unsigned int timerTar;
unsigned int keyFlag, menuIndex;               // 键处理标志及菜单索引
unsigned int setKeyType, setIndex;             // 二级菜单处理嵌套
unsigned int PassWord;                         // 密码
unsigned int keyValue, keyBuff, totalTime;     // 键值判断
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;

/******************************************************************************/  
const unsigned char PRTCL_Prompt[]={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	
const unsigned char BPS_Prompt[]={WORD_F, 3, WORD_NULL, WORD_NULL, WORD_B, WORD_P, WORD_S, WORD_NULL, WORD_NULL};  // F3	波特率	      BPS	
//------------------------------------------------------------------------------
// 流量类（F11-F30）			
const unsigned char OFFST_Prompt[]={WORD_F, 1, 1, WORD_NULL, WORD_O, WORD_F, WORD_F, WORD_S, WORD_T};              // F11	校准零点      OFFST	
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[]={WORD_F, 1, 6, WORD_NULL, WORD_R, WORD_E, WORD_S, WORD_P, WORD_S};              // F16	响应时间      RESPS	
//------------------------------------------------------------------------------			
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）
const unsigned char UNTA_Prompt[]={WORD_F, 3, 1, WORD_NULL, WORD_U, WORD_N, WORD_T, WORD_LINE, WORD_A};            // F31	累积流量单位	UNT-A	
const unsigned char UNTF_Prompt[]={WORD_F, 3, 2, WORD_NULL, WORD_U, WORD_N, WORD_T, WORD_LINE, WORD_F};            // F32	实时流量单位	UNT-F	
const unsigned char UNTP_Prompt[]={WORD_F, 3, 3, WORD_NULL, WORD_U, WORD_N, WORD_T, WORD_LINE, WORD_P};            // F33	压力单位	UNT-P	
			
const unsigned char DISP_Prompt[]={WORD_F, 3, 9, WORD_NULL, WORD_D, WORD_I, WORD_S, WORD_P, WORD_NULL};            // F39	显示模式	DISP	
//------------------------------------------------------------------------------
// 模拟接口类（F31-F40）
const unsigned char PULSE_Prompt[]={WORD_F, 4, 1, WORD_NULL, WORD_P, WORD_U, WORD_L, WORD_S, WORD_E};              // F41	脉冲当量	PULSE	

//------------------------------------------------------------------------------
// 报警类（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[]={WORD_F, 9, 2, WORD_NULL, WORD_C, WORD_L, WORD_R, WORD_LINE, WORD_A};           // F92	清除总流量	CLR-A	
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[]={WORD_F, 9, 4, WORD_NULL, WORD_R, WORD_S, WORD_2, WORD_N, WORD_D};             // F94	恢复二次修正	RS2ND	

//------------------------------------------------------------------------------
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_NULL, 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 char RS2ND_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) 
   {
      isKeyPressed = 1;
      systemProcessing |= KEY_HANDLE;
      LPM1_EXIT; 
   }
}

/******************************************************************************/ 
void KeyReset(void)
{
   KEY_INPUT();
   keyFlag = DIS_PARA_INT;
   isKeyPressed = 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;
   
   //LcdWriteDisplayFirst();
   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;
   }
}

/******************************************************************************/
void ReadKeyValue(void)
{ 
   KeyEditInit();
   keyValue = READ_KEY_VALUE();
   if(keyValue != KEY_PIN) 
   {
      // 按键初始化
      if(keyBuff != keyValue)
      {
         timerTar  = MAINTAR;
         keyBuff   = keyValue;  
         totalTime = RTCSEC;
      }
      else ComputeTime();
      keyValue = 0;
   }
   else  // 按键释放，判断按键
   {
      keyValue = 0;
      DisableKeyInterrupt();
      if((keyBuff == 0) || (keyBuff == KEY_PIN))
      {
         keyBuff = KEY_PIN;
         if(IDvalidTime >= EXIT_30S) KeyReset();
         EnableKeyInterrupt();
         return;
      }
 
      // 判断按键时间及键值判断
      // ComputeTime();
      // if(totalTime > KEY_RESPONSE_TIME)
      if(timerTar == 65535)
      {
         keyBuff  = ~keyBuff;
         keyBuff &=  KEY_PIN;        
         if(keyBuff == M_KEY)  
         {
            keyValue = RTCSEC;
            if(totalTime > keyValue) totalTime = keyValue + 60 - totalTime;
            else                     totalTime = keyValue - totalTime;
         
            if(totalTime > 1) keyValue = LONG_M_KEY;
            else              keyValue = M_KEY;
                                       
            //if(totalTime < KEY_HOLD_TIME) keyValue = M_KEY;
            //else                          keyValue = LONG_M_KEY;
         }
         else if(keyBuff == INC_KEY)   keyValue = INC_KEY;
         else if(keyBuff == DEC_KEY)   keyValue = DEC_KEY;
         else                          keyValue = 0;
      }
      
      totalTime = 0;
      keyBuff = KEY_PIN;
   }
}

/******************************************************************************/
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) break;
         Dis1[modifyBit]++;   
         break;
        
      case DEC_KEY:
         if(Dis1[modifyBit] == 0) break;
         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 I;
   
   switch(keyValue)
   {
      case LONG_M_KEY: keyDealFlag = STD_RETURN; 
      case M_KEY:
         keyFlag  = DIS_PARA_INT;
         //setKeyType = 3;
         return 1;
          
      case INC_KEY:
         Prompt += 5;
         for(I = FUN_PROMPT1; I <= FUN_PROMPT5; I++) Dis1[I] = *Prompt++;
         setKeyBuffer = 1;
         break;
        
      case DEC_KEY:
         for(I = FUN_PROMPT1; I <= FUN_PROMPT5; I++) Dis1[I] = *Prompt++;
         setKeyBuffer = 0;
         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;
      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[0], &YESNO_VALUE[0]);
      setKeyBuffer = 0;
   }
   
   if(KeyValueOperateForPrompt(&YESNO_VALUE[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 = 1;
}

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

/******************************************************************************/
void JudgePasswordInput(unsigned 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;
}

/******************************************************************************/
// 设置仪表系数
void ModifyMeterFactor(void)
{   
   if(setKeyType == 0)
   { 
      // 键功能提示符
      // F13	仪表系数      FACTR
      if(keyFlag == DISPLAY_MENU)       
      {
         SettingKeyPrompt(&FACTR_Prompt[0]); 
         return; 

      }
      else if(keyFlag == DIS_PARA_INT)   // 键参数初始化
      {
         InitOfSettingArea((unsigned long int)MeterFactor, FUN_PROMPT1, 5);      // 初始化参数设置区域                 
         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)) JudgeSaveAndReturn((unsigned long int)MeterFactor, 1);
   }
   
   //===========================================================================
   // 保存设置参数
   if(setKeyType != 1) return;
   if(!ExitCurrentSetup()) return; 
   if(MeterFactor == setKeyBuffer) return;
   
   tempL.DWord = (unsigned long int)setKeyBuffer;
   MeterFactor = WriteShortParameterToEEPROM(METER_FACTOR, METER_FACTOR_WIDTH);
}

/******************************************************************************/
//修改二次修正点数
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 int temp;
      
   if(keyFlag == DIS_PARA_INT)
   {
      SetDisplayArray(0);
      
      modifyBit = FUN_PROMPT2;
      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_LINE;
       
      Dis1[FUN_PROMPT1] = WORD_NULL;
      ConvertHEXToBCDArray(dcoefNode[setIndex]/100, &Dis1[FUN_PROMPT2], 5, HIGH_FIRST);
      ConvertHEXToBCDArray((unsigned long int)99999, &setMax[0], 5, HIGH_FIRST);
      ConvertHEXToBCDArray((unsigned long int)0, &setMin[0], 5, HIGH_FIRST); 

      keySetPoint = 1;
   }
   
   //键值处理
   if(KeyValueOperation(FUN_PROMPT2, FUN_DECIMAL))
   {         
      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_LINE;
      
      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 ModifyMaxFlowRate(void)
{
 if(setKeyType == 0)
   { 
      if(keyFlag == DISPLAY_MENU)       // 键功能提示符
      {
         // STD_KEY_ADDR             2   // F15      FS
         SettingKeyPrompt(&FS_Prompt[0]);
         return;  
      }
      else if(keyFlag == DIS_PARA_INT)
      {
         InitOfSettingArea((unsigned long int)maxFlowRate/100, FUN_PROMPT2, 5);      // 初始化参数设置区域  
         ConvertHEXToBCDArray((unsigned long int)99999, &setMax[0], 5, HIGH_FIRST);
         ConvertHEXToBCDArray((unsigned long int)0, &setMin[0], 5, HIGH_FIRST); 
         
         display_data[ACC_POINT] |= (unsigned char)ACC_POINT_BIT;
      }
              
      // 键值处理
      if(KeyValueOperation(FUN_PROMPT2, FUN_DECIMAL)) JudgeSaveAndReturn((unsigned long int)maxFlowRate, 100);
   }
   
   //===========================================================================
   // 保存设置参数
   if(setKeyType != 1) return;
   if(!ExitCurrentSetup()) return; 
   if(maxFlowRate == setKeyBuffer) return;
   tempDev.DWord[0] = (unsigned long int)setKeyBuffer;
   maxFlowRate = WriteLongParameterToEEPROM(MAX_FLOW, MAX_FLOW_WIDTH);
}

/******************************************************************************/
void ModifyWorkDiameter(void)
{
 if(setKeyType == 0)
   { 
      if(keyFlag == DISPLAY_MENU)       // 键功能提示符
      {
         // F29	    DIAM
         SettingKeyPrompt(&DIAM_Prompt[0]);
         return; 
      }
      else if(keyFlag == DIS_PARA_INT)
      {
         InitOfSettingArea((unsigned long int)workDiameter, FUN_PROMPT2, 4);      // 初始化参数设置区域    
         ConvertHEXToBCDArray((unsigned long int)1500, &setMax[0], 4, HIGH_FIRST);
         ConvertHEXToBCDArray((unsigned long int)25, &setMin[0], 4, HIGH_FIRST); 
      }
        
      // 键值处理
      if(KeyValueOperation(FUN_PROMPT2, FUN_PROMPT5)) JudgeSaveAndReturn((unsigned long int)workDiameter, 1);
   }
   
   //===========================================================================
   // 保存设置参数
   if(setKeyType != 1) return;
   if(!ExitCurrentSetup()) return; 
   if(workDiameter == setKeyBuffer) return;
   tempL.DWord  = (unsigned int)setKeyBuffer;
   workDiameter = WriteShortParameterToEEPROM(WORK_DIAMETER, WORK_DIAMETER_WIDTH);
}

/******************************************************************************/
void ModifySamplingInterval(void)
{
 if(setKeyType == 0)
   { 
      if(keyFlag == DISPLAY_MENU)       // 键功能提示符
      {
         //F16	响应时间    RESPS
         SettingKeyPrompt(&RESPS_Prompt[0]);
         return;   
      }
      else if(keyFlag == DIS_PARA_INT)
      {
         InitOfSettingArea((unsigned long int)factoryInterval, FUN_PROMPT5, 1);      // 初始化参数设置区域  
         setMax[0] = SAMPLE_PERIOD_MAX;
         setMin[0] = SAMPLE_PERIOD_MIN;          
      }
        
      // 键值处理
     if(KeyValueOperation(FUN_PROMPT5, FUN_PROMPT5)) JudgeSaveAndReturn((unsigned long int)factoryInterval, 1);
   }
   
   //===========================================================================
   // 保存设置参数
   if(setKeyType != 1) return;
   if(!ExitCurrentSetup()) return; 
   if(factoryInterval == setKeyBuffer) return;
   tempL.DWord     = (unsigned int)setKeyBuffer;
   factoryInterval = WriteShortParameterToEEPROM(SAMPLE_PERIOD, SAMPLE_PERIOD_WIDTH);
}

/*******************************************************************************
按键操作校准小传感器的燃气零点。
通过按键校准小传感器零点，操作者必须注意以下几个条件是否满足：
1、管道内气流静止；
2、在气流静止的情况下，流量计至少稳定工作1min
如以上条件任意一个不成立，有可能对校零的结果造成影响。

通过密码执行校零操作后，显示面板将显示校零操作前后的小传感器气体零点值，按下 SET按键后，退出校零状态。
如操作者认为校零结果不满意，可重复执行此操作。
在退出菜单操作之前，如用户选择不存储修改值，则“键盘校零”操作结果无效。
*******************************************************************************/
void CalibrateOffsetC(void)
{ 
   if(setKeyType == 0)
   {
      if(keyFlag == DISPLAY_MENU)
      {
         //STD_KEY_OFFST            11  // F11	校准零点      OFFST
         SettingKeyPrompt(&OFFST_Prompt[0]);
         return;    
      }
      else if(keyFlag == DIS_PARA_INT) setKeyType++;
   }
 
   if(setKeyType == 1) JudgePasswordInput(LEVEL_3_PASSWORD);                    // 0520
   if(setKeyType == 2)
   {
      if(keyFlag == DIS_PARA_INT)
      {
         modifyBit = FUN_PROMPT5;
         keyValue = INC_KEY;
         keyFlag  = FLASH_BIT;
      }
    
      //键值处理
      switch(keyValue)
      {
         case LONG_M_KEY: 
            if(offsetGas == setIndex)
            {
               keyValue = 0xff;
               menuIndex = STD_RETURN;
               return;
            }
            keyDealFlag = STD_RETURN; 
            
         case M_KEY:
            keyValue = 0;
            setKeyType++;
            keyFlag = DIS_PARA_INT;
            break;   
           
         case INC_KEY:
            Dis1[FUN_CODE_1]  = WORD_C;
            Dis1[FUN_CODE_2]  = WORD_U;
            Dis1[FUN_CODE_3]  = WORD_R;
            Dis1[FUN_CODE_4]  = WORD_NULL;  
            
            setKeyBuffer      = voltageDetected[NIDX]; //ReadDataFromMovingAverage(NIDX);
            ConvertHEXToBCDArray((unsigned long int)setKeyBuffer, &Dis1[FUN_PROMPT1], 5, HIGH_FIRST);
            break;  
              
         case DEC_KEY:
            Dis1[FUN_CODE_1]  = WORD_O;
            Dis1[FUN_CODE_2]  = WORD_L;
            Dis1[FUN_CODE_3]  = WORD_D;
            Dis1[FUN_CODE_4]  = WORD_NULL;  
            
            ConvertHEXToBCDArray((unsigned long int)offsetGas, &Dis1[FUN_PROMPT1], 5, HIGH_FIRST);
            break; 
          
         default: break;
      } 
      keyValue = 0;
   }
  
   if(setKeyType != 3) return;
   if(!ExitCurrentSetup()) return; 
   //if(offsetGas == (unsigned long int)setKeyBuffer)
   
   tempL.DWord = (unsigned long int)setKeyBuffer;
   offsetGas = WriteShortParameterToEEPROM(OFFSET_GAS, OFFSET_GAS_WIDTH);
   
#if(ENABLE_A_TYPE_FLOWRATE)
   tempL.DWord = (unsigned long int)ReadDataFromMovingAverage(SDT);
   offsetGasA = WriteShortParameterToEEPROM(OFFSET_A, OFFSET_A_WIDTH); 
#endif
}

/*********************************************************************************/ 
//修改脉冲当量
void ModifyLPFactoryLiterPerPulse(void)
{ 
   if(setKeyType == 0)
   {
      if(keyFlag == DISPLAY_MENU)
      {
         // STD_KEY_PULSE                     41  // F41	脉冲当量	PULSE
         SettingKeyPrompt(&PULSE_Prompt[0]);
         return;  
      }
      else if(keyFlag == DIS_PARA_INT)
      {
         InitOfSettingArea((unsigned long int)factoryUnitPerPulse, FUN_PROMPT2, 5); // 初始化参数设置区域
         ConvertHEXToBCDArray((unsigned long int)10000, &setMax[0], 5, HIGH_FIRST); // 参数最大值
         ConvertHEXToBCDArray((unsigned long int)100, &setMin[0], 5, HIGH_FIRST);   // 参数最小值 
       }
            
      display_data[ACC_POINT] |= (unsigned char)ACC_POINT_BIT; 
      if(KeyValueOperation(FUN_PROMPT2, FUN_DECIMAL)) JudgeSaveAndReturn((unsigned long int)factoryUnitPerPulse, 1);
   }
    
   //===========================================================================
   // 保存设置参数
   if(setKeyType != 1) return;
   if(!ExitCurrentSetup()) return;     
   if(factoryUnitPerPulse == (unsigned int)setKeyBuffer) return;
   
   lastRemaining = 0;
   tempL.DWord = (unsigned long int)setKeyBuffer;
   factoryUnitPerPulse = WriteShortParameterToEEPROM(PULSE_UNIT, PULSE_UNIT_WIDTH);
}

/******************************************************************************/
void ModifyModBusAdr(void)
{
   if(setKeyType == 0)
   { 
      if(keyFlag == DISPLAY_MENU)       // 键功能提示符
      {
         // STD_KEY_ADDR             2   // F2	从机地址      ADDR
         SettingKeyPrompt(&ADDR_Prompt[0]);
         return;        
      }
      else if(keyFlag == DIS_PARA_INT)
      {
         InitOfSettingArea((unsigned long int)localAddress, FUN_PROMPT3, 3);      // 初始化参数设置区域
         ConvertHEXToBCDArray((unsigned long int)247, &setMax[0], 3, HIGH_FIRST); // 参数最大值
         ConvertHEXToBCDArray((unsigned long int)1, &setMin[0], 3, HIGH_FIRST);   // 参数最小值     
      }
   
      // 键值处理
      if(KeyValueOperation(FUN_PROMPT3, FUN_PROMPT5)) JudgeSaveAndReturn((unsigned long int)localAddress, 1);
   }
   
   //===========================================================================
   // 保存设置参数
   if(setKeyType != 1) return;
   if(!ExitCurrentSetup()) return;   
       
   if(localAddress == (unsigned int)setKeyBuffer) return;
   tempL.DWord = (unsigned long int)setKeyBuffer;
   localAddress = WriteShortParameterToEEPROM(SLAVER_ADDR, SLAVER_ADDR_WIDTH);
}

/******************************************************************************/
//void ModifyDisplayMod(voiod)
//{
// if(setKeyType == 0)
//   { 
//      if(keyFlag == DISPLAY_MENU)       // 键功能提示符
//      {
//         // STD_KEY_ADDR             2   // F2	从机地址      ADDR
//         SettingKeyPrompt(&DISMod_Prompt[0]);
//         return;        
//      }
//      else if(keyFlag == DIS_PARA_INT)
//      {
//         InitOfSettingArea((unsigned long int)SysLcd, FUN_PROMPT3, 3);      // 初始化参数设置区域
//         ConvertHEXToBCDArray((unsigned long int)247, &setMax[0], 3, HIGH_FIRST); // 参数最大值
//         ConvertHEXToBCDArray((unsigned long int)1, &setMin[0], 3, HIGH_FIRST);   // 参数最小值     
//      }
//   
//      // 键值处理
//      if(KeyValueOperation(FUN_PROMPT3, FUN_PROMPT5)) JudgeSaveAndReturn((unsigned long int)localAddress, 1);
//   }
//   
//   //===========================================================================
//   // 保存设置参数
//   if(setKeyType != 1) return;
//   if(!ExitCurrentSetup()) return;   
//       
//   if(localAddress == (unsigned int)setKeyBuffer) return;
//   tempL.DWord = (unsigned long int)setKeyBuffer;
//   localAddress = WriteShortParameterToEEPROM(SLAVER_ADDR, SLAVER_ADDR_WIDTH);
//}

/******************************************************************************/
void ModifyUartDecimalPoint(void)
{
//   if(setKeyType == 0)
//   { 
//      if(keyFlag == DISPLAY_MENU)       // 键功能提示符
//      {
//         // STD_UART_Decimal             2   // F2	从机地址      ADDR
//         SettingKeyPrompt(&DECI_Prompt[0]);
//         return; 
//      }
//      else if(keyFlag == DIS_PARA_INT)
//      {
//         modifyBit = FUN_PROMPT5;
//         keyValue = 0;
//         keyFlag  = FLASH_BIT;
//         
//         setKeyBuffer = uartDecimalPoint;
//         Dis1[FUN_PROMPT1] = WORD_NULL;    
//         Dis1[FUN_PROMPT2] = WORD_NULL;
//         Dis1[FUN_PROMPT3] = WORD_NULL;
//         Dis1[FUN_PROMPT4] = WORD_NULL;
//         Dis1[FUN_PROMPT5] = (unsigned char)setKeyBuffer;
//         Dis1[FUN_DECIMAL] = WORD_NULL;
//         setMax[0] = 4;
//         setMin[0] = 3;    
//      }
//   
//      if(KeyValueOperation(FUN_PROMPT5, FUN_PROMPT5)) JudgeSaveAndReturn((unsigned long int)uartDecimalPoint, 1);
//   }
//   
//   //===========================================================================
//   // 保存设置参数
//   if(setKeyType != 1) return;
//   if(!ExitCurrentSetup()) return;   
//   
//   if(uartDecimalPoint == (unsigned int)setKeyBuffer) return;
//   tempL.DWord = (unsigned long int)setKeyBuffer;   
//   uartDecimalPoint = WriteShortParameterToEEPROM(COM_DECIMAL_POINT, COM_DECIMAL_POINT_WIDTH);
}

/******************************************************************************/
void ResetDcoefNodeAndValue(void)
{
  if(setKeyType == 0)
   { 
      if(keyFlag == DISPLAY_MENU)       // 键功能提示符
      {
         // F94 RS2ND
         SettingKeyPrompt(&RS2ND_Prompt[0]);	
         return; 
      }
      else if(keyFlag == DIS_PARA_INT) setKeyType = 1;
   }
      
   if(setKeyType == 1) JudgePasswordInput(LEVEL_2_PASSWORD);                    //2222
   if(setKeyType == 2) 
   {
      if(keyFlag == DIS_PARA_INT)
      {
         InitOfSettingPrompt(&RS2ND_Prompt[0], &RS2ND_VALUE[0]);
         setKeyBuffer = 0;
      }
   
      if(KeyValueOperateForPrompt(&RS2ND_VALUE[0])) setKeyType = 3;
   }
   
   //===========================================================================
   // 保存设置参数
   if(setKeyType != 3) return;
   if(!ExitCurrentSetup()) return;      
   if(setKeyBuffer == 0) return;
   DefaultDevCoef();
}

/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
/******************************************************************************/
void KeyInputProcessing(void)
{ 
   FlashBitForSetup();
   ReadKeyValue();
   while(keyValue != 0)
   {
      IDvalidTime = 0;
      DisplaySetIndex();
      switch(menuIndex)
      {
         case STD_INIT_PASSWORD:                                                // input password
            if(keyFlag == DIS_PARA_INT) 
            {
              if(keyValue == SHIFT_KEY) { KeyReset(); return; }
              if(keyValue == UPPER_KEY) { KeyReset(); return; }
            }
              
            if(!KeyPasswordInput()) break;
            keyValue = 0xff;
            keyFlag  = DISPLAY_MENU;   
            if(PassWord != LEVEL_1_PASSWORD) menuIndex = STD_RETURN;
            else                             menuIndex = STD_KEY_ADDR; 
            continue;

         //=====================================================================
         // 接口类（F1-F9）	
         //case STD_KEY_PRTCL                                                // F1	通讯协议      PRTCL	
         case STD_KEY_ADDR:    ModifyModBusAdr();  break;                    // F2	从机地址      ADDR	
         //case STD_KEY_BPS                                                  // F3	波特率	      BPS	
         //=====================================================================
         // 流量类（F11-F30）			
         case STD_KEY_OFFST:   CalibrateOffsetC(); break;                    // F11	校准零点      OFFST (0520)
         //-----------------------------------------------------------------------
         // case STD_KEY_GCF:                                                // F12	GCF	      GCF	
         case STD_KEY_FACTR:   ModifyMeterFactor();        break;            // F13	仪表系数      FACTR
         case STD_KEY_CORR:    ModifyDcoefNodeAndValue();  break;            // F14	二次修正系数  CORR
         //-----------------------------------------------------------------------
         case STD_KEY_FS:      ModifyMaxFlowRate();  break;                  // F15	量程设置      FS	
         case STD_KEY_RESPS:   ModifySamplingInterval();  break;             // F16	响应时间      RESPS	
         //case STD_KEY_CUT_F                                                // F28	小流量切除    CUT-F	
         
         //=====================================================================
         #if(ENABLE_PLUG_IN_FLOWRATE)
         case STD_KEY_DIAM:    ModifyWorkDiameter(); break;                  // F29	管径设置      DIAM
         #endif
         //=======================================================================
         // 显示类（F31-F40）
         //case STD_KEY_UNT_A                                                // F31	累积流量单位	UNT-A	
         //case STD_KEY_UNT_F                                                // F32	实时流量单位	UNT-F	
         //case STD_KEY_UNT_P                                                // F33	压力单位	UNT-P	
         //case STD_KEY_DISP:    ModifyDisplayMod();  break;                   // F39	显示模式	DISP	
           
         //=======================================================================
         // 模拟接口类（F31-F40）
         case STD_KEY_PULSE: ModifyLPFactoryLiterPerPulse(); break;          // F41	脉冲当量	PULSE	
         //=======================================================================
         // 报警类（F41-F50）
         //case STD_KEY_ALM_H                                                // F51	高流量报警	ALM-H	
         //case STD_KEY_ALM_L                                                // F52	低流量报警	ALM-L	
         //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）
         //case STD_KEY_PASS                                                 // F91	设置密码	PASS	
         //case STD_KEY_CLR_A                                                // F92	清除总流量	CLR-A	
         //case STD_KEY_CLR_T                                                // F93	清除时间	CLR-T	
         case STD_KEY_RESET_DCOEF: ResetDcoefNodeAndValue(); break;          // F94	恢复二次修正	RS2ND	
         //=======================================================================
         
         // 退出
         case STD_KEY_QUIT: ExitKeyOperation(); break;                       // F99	退出设置	QUIT	
         case STD_RETURN:
           KeyReset();
           DisableKeyInterrupt();
           NumericPrepForOutputAndDisplay();  
           return;
           
         default: continue;
      }  
      
      DisplayForKeyOperation();
   }
}

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