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

unsigned int setKeyType, setIndex;
unsigned int keyDealFlag;
    
extern unsigned char display0_data[];
extern unsigned char display1_data[];
extern unsigned char Code_AFED_BGC[];
extern unsigned char Code_BGC_AFED[]; 
extern unsigned char Code_EGFA_DCB[];   

bool isKeyPressed;
unsigned int keyFlag, PassWord, keyTime, keyValue, keyBuff, menuIndex, modifyBit, keyFlashTime;
unsigned      int setKeyBuffer;
unsigned long int temp_dcoefNode[DCOEF_MAX];
unsigned      int temp_dcoefNum, temp_dcoefVal[DCOEF_MAX];

#define DIS_PARA_INT    0
#define DISPLAY_MENU    1
#define FLASH_BIT       2

#define NEXT   0 
#define SAVE   1
#define NO     2
/******************************************************************************/ 
void KeyReset(void)
{
   KEY_INPUT();
   keyFlag = DIS_PARA_INT;
   isKeyPressed = 0; 
   keyValue = 0;
   menuIndex = 0;
   setKeyType = 0;
   setIndex = 0;
   PassWord = 0;
}

/******************************************************************************/ 
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;
   
   if(keyFlag != FLASH_BIT) return;
   if(keyFlashTime == RTCSEC) return;
   keyFlashTime = RTCSEC;
   tempT  = display1_data[ACC_1 + modifyBit -1];
   tempT &= ~BIT0;
   if(tempT == 0) display1_data[ACC_1 + modifyBit -1] |= Code_EGFA_DCB[Dis1[modifyBit]];
   else           display1_data[ACC_1 + modifyBit -1] &= (unsigned char)BIT0;
   LcdWriteDisplayFirst(); 
}

/*********************************************************************************/
void ReadKeyValue(void)
{
   unsigned int temp;
   
   KeyEditInit();
   temp = READ_KEY_VALUE();
   if(temp == KEY_PIN)   
   {
      keyValue = 0;
      EnableKeyInterrupt();
      if((keyBuff == 0) || (keyBuff == KEY_PIN))
      {
         keyBuff = KEY_PIN;
         if(IDvalidTime >= 30) KeyReset();
         //{
         //   keyFlag = DIS_PARA_INT;
         //   menuIndex = 0; 
         //   isKeyPressed = 0;
         //}
         return;
      }
 
      timerTar = MAINTAR;
      if(timerTar < keyTime) timerTar = 1600;
      else                   timerTar -= keyTime;
      
      if(timerTar < 1600) { keyValue = 0; return; }
      
      keyBuff  = ~keyBuff;
      keyBuff &=  KEY_PIN;
           if(keyBuff == FUN_KEY)   keyValue = FUN_KEY;
      else if(keyBuff == UPPER_KEY) keyValue = UPPER_KEY;
      else if(keyBuff == SHIFT_KEY) keyValue = SHIFT_KEY;
      else                          keyValue = 0;
      keyBuff = KEY_PIN;
   }
   else
   {
      if(keyBuff == temp) return;
      keyBuff = temp;
      keyTime  = MAINTAR;
   }
}

/********************************************************************************************* */
unsigned int SaveModifyValue(void)
{    
   if(keyFlag == DIS_PARA_INT)
   {
      modifyBit = 5;
      keyValue = 0;
      keyFlag  = FLASH_BIT;
      ClearDisplay();
       
      Dis1[1]  = WORD_S;
      Dis1[2]  = WORD_A;
      Dis1[3]  = WORD_V;
      Dis1[4]  = WORD_E;
    
      Dis1[5]  = WORD_LINE;
      Dis1[6] =  WORD_N;
      
      Dis1[7]  = WORD_NULL;  
      Dis1[8]  = WORD_NULL;      
      Dis1[9]  = WORD_NULL;      
      Dis1[10] = WORD_NULL;
      Dis1[11] = WORD_NULL;
      Dis1[12] = WORD_NULL;
      Dis1[13] = WORD_NULL;
   }
   
   switch(keyValue)
   {
      case FUN_KEY:
         keyValue = 0;
         if( Dis1[6] == WORD_Y ) return SAVE; 
         return NO;
          
       case UPPER_KEY:  
       case SHIFT_KEY:
         if(Dis1[6] == WORD_N)   Dis1[6] = WORD_Y;
         else                    Dis1[6] = WORD_N;   
         break;
          
       default: 
         break;          
   }
   
   keyValue = 0;
   return NEXT;
}

bool ReturnKeySetSub(void)
{    
   if(keyFlag == DIS_PARA_INT)
   {
      modifyBit = 5;
      keyValue = 0;
      keyFlag  = FLASH_BIT;
      ClearDisplay();
       
      Dis1[1]  = WORD_O;
      Dis1[2]  = WORD_F;
      Dis1[3]  = WORD_F;
      Dis1[4]  = WORD_NULL;
    
      Dis1[5]  = WORD_LINE;
      Dis1[6] =  WORD_Y;
      
      Dis1[7]  = WORD_NULL;  
      Dis1[8]  = WORD_NULL;      
      Dis1[10] = WORD_NULL;
      Dis1[11] = WORD_NULL;
      Dis1[12] = WORD_NULL;
      Dis1[13] = WORD_NULL;
   }
   
   switch(keyValue)
   {
      case FUN_KEY:
         if( Dis1[6] == WORD_Y ) return 1; 
         return 0;
          
       case UPPER_KEY:  
       case SHIFT_KEY:
         if(Dis1[6] == WORD_N)   Dis1[6] = WORD_Y;
         else                    Dis1[6] = WORD_N;   
         break;
          
       default: 
         break;          
   }
   return 0;
}

unsigned int DisplaySetIndex(void)
{
   switch(keyValue)
   {
      case FUN_KEY:
           keyFlag = DIS_PARA_INT;
           keyValue = 0;
           return 1;
          
      case UPPER_KEY:  
           return 2; 
         
      case SHIFT_KEY:  
           menuIndex++;
           if(menuIndex >= KEY_SET_RETURN) menuIndex = KEY_SET_METERFACTOR;
           break;
   } 
     
   Dis1[1]  = WORD_S;
   Dis1[2]  = WORD_E;
   Dis1[3]  = WORD_T;
   Dis1[4]  = WORD_LINE;
   Dis1[9]  = WORD_NULL; 
   Dis1[10] = WORD_NULL;
   Dis1[11] = WORD_NULL;
   Dis1[12] = WORD_NULL;
   Dis1[13] = WORD_NULL; 
   
   Dis1[5]  = WORD_F;
   Dis1[6]  = menuIndex;  
   Dis1[7]  = WORD_NULL;
   Dis1[8]  = WORD_NULL;  
   
   if(menuIndex == KEY_SET_METERFACTOR)
   {
      display0_data[FLOW_1] = Code_AFED_BGC[WORD_F];
      display0_data[FLOW_2] = Code_AFED_BGC[WORD_a];
      display0_data[FLOW_3] = Code_AFED_BGC[WORD_c];
      display0_data[FLOW_4] = Code_AFED_BGC[WORD_t];
      display0_data[FLOW_5] = Code_AFED_BGC[WORD_o];
      display0_data[FLOW_6] = Code_AFED_BGC[WORD_r];
      display0_data[FLOW_7] = Code_AFED_BGC[WORD_NULL];
   }
   else if(menuIndex == KEY_SET_COEFFIC)
   {
      display0_data[FLOW_1] = Code_AFED_BGC[WORD_C];
      display0_data[FLOW_2] = Code_AFED_BGC[WORD_O];
      display0_data[FLOW_3] = Code_AFED_BGC[WORD_E];
      display0_data[FLOW_4] = Code_AFED_BGC[WORD_F];
      display0_data[FLOW_5] = Code_AFED_BGC[WORD_F];
      display0_data[FLOW_6] = Code_AFED_BGC[WORD_I];
      display0_data[FLOW_7] = Code_AFED_BGC[WORD_C];
   }
   else if(menuIndex == KEY_CALIB_OFFSETC)
   {
      display0_data[FLOW_1] = Code_AFED_BGC[WORD_O];
      display0_data[FLOW_2] = Code_AFED_BGC[WORD_F];
      display0_data[FLOW_3] = Code_AFED_BGC[WORD_F];
      display0_data[FLOW_4] = Code_AFED_BGC[WORD_S];
      display0_data[FLOW_5] = Code_AFED_BGC[WORD_E];
      display0_data[FLOW_6] = Code_AFED_BGC[WORD_T];
      display0_data[FLOW_7] = Code_AFED_BGC[WORD_NULL];
   }
   else if(menuIndex == KEY_SET_PULSE)
   {
      display0_data[FLOW_1] = Code_AFED_BGC[WORD_P];
      display0_data[FLOW_2] = Code_AFED_BGC[WORD_U];
      display0_data[FLOW_3] = Code_AFED_BGC[WORD_L];
      display0_data[FLOW_4] = Code_AFED_BGC[WORD_S];
      display0_data[FLOW_5] = Code_AFED_BGC[WORD_E];
      display0_data[FLOW_6] = Code_AFED_BGC[WORD_NULL];
      display0_data[FLOW_7] = Code_AFED_BGC[WORD_NULL];
   }
   else if(menuIndex == KEY_SET_ADDR)
   {
      display0_data[FLOW_1] = Code_AFED_BGC[WORD_A];
      display0_data[FLOW_2] = Code_AFED_BGC[WORD_d];
      display0_data[FLOW_3] = Code_AFED_BGC[WORD_d];
      display0_data[FLOW_4] = Code_AFED_BGC[WORD_r];
      display0_data[FLOW_5] = Code_AFED_BGC[WORD_NULL];
      display0_data[FLOW_6] = Code_AFED_BGC[WORD_NULL];
      display0_data[FLOW_7] = Code_AFED_BGC[WORD_NULL];
   }
   else if(menuIndex == KEY_SET_DECIMAL_POINT)
   {
      display0_data[FLOW_1] = Code_AFED_BGC[WORD_D];
      display0_data[FLOW_2] = Code_AFED_BGC[WORD_E];
      display0_data[FLOW_3] = Code_AFED_BGC[WORD_C];
      display0_data[FLOW_4] = Code_AFED_BGC[WORD_I];
      display0_data[FLOW_5] = Code_AFED_BGC[WORD_NULL];
      display0_data[FLOW_6] = Code_AFED_BGC[WORD_NULL];
      display0_data[FLOW_7] = Code_AFED_BGC[WORD_NULL];   
   }
   
   LcdWriteDisplaySecond();
   keyValue = 0;
   return 0;
}

/******************************************************************************/
bool KeyPasswordInput(void)
{
   if(keyFlag == DIS_PARA_INT)
   {
      modifyBit = 5;
      keyValue = 0;
      keyFlag  = FLASH_BIT;
      ClearDisplay();
       
      Dis1[1]  = WORD_P;
      Dis1[2]  = WORD_A;
      Dis1[3]  = WORD_S;
      Dis1[4]  = WORD_LINE;   
      Dis1[5]  = 0;    
      Dis1[6]  = 0;
      Dis1[7]  = 0;
      Dis1[8]  = 0;
      Dis1[9]  = WORD_NULL;  
      Dis1[10] = WORD_NULL;  
      Dis1[11] = WORD_NULL;  
      Dis1[12] = WORD_NULL;  
      Dis1[13] = WORD_NULL;
   }
   
   keyFlag = FLASH_BIT;
   switch(keyValue)
   {
      case FUN_KEY:
         keyValue = 0;
         return 1;
        
      case UPPER_KEY:
         if(Dis1[modifyBit] >= 9) Dis1[modifyBit] = 0;
         else                     Dis1[modifyBit]++;       
         break;
        
      case SHIFT_KEY:
         if(modifyBit >= 8)  modifyBit = 5;
         else                modifyBit++;  
         break;
    }
   
    keyValue = 0;
    return 0;
}

void ComputPassWordToArray(void)
{
   PassWord  = (unsigned int)Dis1[5]*1000;
   PassWord += (unsigned int)Dis1[6]*100;
   PassWord += (unsigned int)Dis1[7]*10;
   PassWord += (unsigned int)Dis1[8];
}

/******************************************************************************/
// 设置仪表系数
void ModifyMeterFactor(void)
{   
   if(keyFlag == DIS_PARA_INT)
   {
      modifyBit = 5;
      keyValue = 0;
      keyFlag  = FLASH_BIT;
      ClearDisplay();
       
      Dis1[1]  = WORD_F;
      Dis1[2]  = 1;
      Dis1[3]  = WORD_LINE;
      Dis1[4]  = WORD_LINE;
      Dis1[9]  = WORD_NULL;    
      Dis1[10] = WORD_NULL;
      Dis1[11] = WORD_NULL;
      Dis1[12] = WORD_NULL;
      Dis1[13] = WORD_NULL; 
   
      //display  meter factor----TotalFlowRateDisplay
      setKeyBuffer = MeterFactor;
      Dis1[5]      = (unsigned char)(setKeyBuffer / (unsigned int)1000);
      setKeyBuffer = setKeyBuffer - (unsigned int)Dis1[5] * 1000;
      Dis1[6]      = (unsigned char)(setKeyBuffer / 100);
      setKeyBuffer = setKeyBuffer - (unsigned int)Dis1[6] * 100;
      Dis1[7]      = (unsigned char)(setKeyBuffer / 10);
      setKeyBuffer = setKeyBuffer - (unsigned int)Dis1[7] * 10;
      Dis1[8]      = (unsigned char)setKeyBuffer;
   }
    
   switch(keyValue)
   {
      case FUN_KEY:
         setKeyBuffer  = (unsigned int)Dis1[5]*1000;
         setKeyBuffer += (unsigned int)Dis1[6]*100;
         setKeyBuffer += (unsigned int)Dis1[7]*10;
         setKeyBuffer += (unsigned int)Dis1[8];
         keyFlag  = DIS_PARA_INT;
         setKeyType = 1;
         keyValue =0;
         return;
          
      case UPPER_KEY:
         if(Dis1[modifyBit] >= 9) Dis1[modifyBit] = 0;
         else                     Dis1[modifyBit]++;       
         break;
        
      case SHIFT_KEY:
         if(modifyBit >= 8)  modifyBit = 5;
         else                modifyBit++;  
         break;
   } 
    
   keyValue = 0;
}

/******************************************************************************/
//修改二次修正点数
void ModifyDcoefNum(void)
{
   if(keyFlag == DIS_PARA_INT)
   {
      modifyBit = 5;
      keyValue = 0;
      keyFlag  = FLASH_BIT;
      ClearDisplay();
    
      Dis1[1]  = WORD_P;       
      Dis1[2]  = WORD_N;    
      Dis1[3] =  WORD_LINE;
      Dis1[4] =  WORD_LINE;
    
      Dis1[6]  = WORD_NULL;  Dis1[7]  = WORD_NULL;  Dis1[8]  = WORD_NULL;       
      Dis1[9]  = WORD_NULL;  Dis1[10] = WORD_NULL;  Dis1[11] = WORD_NULL;
      Dis1[12] = WORD_NULL;  Dis1[13] = WORD_NULL; 
       
      Dis1[5] = dcoefNum;
   }
    
   switch(keyValue)
   {
      case FUN_KEY:
         temp_dcoefNum = Dis1[5];
         keyFlag       = DIS_PARA_INT;
         keyValue      = 0;
         setKeyType    = 1;
         setIndex      = 0;
         return;    
          
      case UPPER_KEY:  
         if(Dis1[modifyBit] >= 7)  Dis1[modifyBit] = 0;
         else                      Dis1[modifyBit]++;     
         break;
          
      default: 
         break;
   }
   keyValue = 0;
}

/**************************************************************************************/
void ModifyDcoefNode(void)
{
   unsigned long int temp;
      
   if(keyFlag == DIS_PARA_INT)
   {
      modifyBit = 5;
      keyValue  = 0;
      keyFlag   = FLASH_BIT;
      ClearDisplay();
       
      Dis1[1] = WORD_P;      
      Dis1[2] = setIndex+1;      
      Dis1[3] = WORD_LINE;
      Dis1[4] = WORD_LINE;
       
      temp = dcoefNode[setIndex];
      temp /= 100;
      Dis1[5] = (unsigned char)(temp / (unsigned long int)10000);
      temp    = temp - (unsigned long int)Dis1[5] * 10000;
      Dis1[6] = (unsigned char)(temp / (unsigned long int)1000);
      temp    = temp - (unsigned long int)Dis1[6] * 1000;
      Dis1[7] = (unsigned char)(temp / 100);
      temp    = temp - (unsigned long int)Dis1[7] * 100;
      Dis1[8] = (unsigned char)(temp / 10);
      temp    = temp - (unsigned long int)Dis1[8] * 10;
      Dis1[9] = (unsigned char)temp;
       
      display1_data[ACC_POINT] |= (unsigned char)ACC_POINT_BIT; 
      display1_data[ACC_NM3]   |= (unsigned char)ACC_NM3_BIT; 
   }
   
   //键值处理
   switch(keyValue)
   {
      case FUN_KEY:
         temp_dcoefNode[setIndex]  = (unsigned long int)Dis1[5] * 1000000;
         temp_dcoefNode[setIndex] += (unsigned long int)Dis1[6] * 100000;
         temp_dcoefNode[setIndex] += (unsigned long int)Dis1[7] * 10000;
         temp_dcoefNode[setIndex] += (unsigned long int)Dis1[8] * 1000;
         temp_dcoefNode[setIndex] += (unsigned long int)Dis1[9] * 100; 
         setKeyType = 2;
         keyFlag = DIS_PARA_INT;
         keyValue  = 0;
         return;
          
      case UPPER_KEY:
         Dis1[modifyBit]++;      
         if(Dis1[modifyBit] > 9)  Dis1[modifyBit] = 0;
         break;  
          
      case SHIFT_KEY:
         modifyBit++;
         if(modifyBit > 9) modifyBit = 5;           
         break;
          
      default: 
         break;
   }
   
   display1_data[ACC_POINT] |= (unsigned char)ACC_POINT_BIT; 
   display1_data[ACC_NM3]   |= (unsigned char)ACC_NM3_BIT; 
   keyValue = 0;
}

bool ModifyDcoefVal(void)
{
   unsigned int temp;
   
   if(keyFlag == DIS_PARA_INT)
   {
       modifyBit = 5;
       keyValue = 0;
       keyFlag  = FLASH_BIT;
       ClearDisplay();
       
       Dis1[4]  = WORD_LINE;
       
       Dis1[9]  = WORD_NULL;
       Dis1[10] = WORD_NULL;          
       Dis1[11] = WORD_NULL;
       Dis1[12] = WORD_NULL;  
       
       temp = dcoefVal[setIndex];
       Dis1[5] = (unsigned char)(temp / (unsigned int)1000);
       temp    = temp - (unsigned int)Dis1[5] * 1000;
       Dis1[6] = (unsigned char)(temp / 100);
       temp    = temp - (unsigned int)Dis1[6] * 100;
       Dis1[7] = (unsigned char)(temp / 10);
       temp    = temp - (unsigned int)Dis1[7] * 10;
       Dis1[8] = (unsigned char)temp;
    }
   
    switch(keyValue)
    {
       case FUN_KEY:
          temp_dcoefVal[setIndex]  = (unsigned long int)Dis1[5] * 1000;
          temp_dcoefVal[setIndex] += (unsigned long int)Dis1[6] * 100;
          temp_dcoefVal[setIndex] += (unsigned long int)Dis1[7] * 10;
          temp_dcoefVal[setIndex] += (unsigned long int)Dis1[8]; 
          keyValue = 0;
          return 1;
          
       case UPPER_KEY:
          if(Dis1[modifyBit] >= 9) Dis1[modifyBit] = 0;
          else                     Dis1[modifyBit]++;               
          break;  
          
       case  SHIFT_KEY:
          if(modifyBit >= 8) modifyBit = 5;
          else               modifyBit++;            
          break;
          
       default: 
          break;
   }
   
   keyValue = 0;
   return 0;
}

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

通过密码执行校零操作后，显示面板将显示校零操作前后的小传感器气体零点值，按下 SET按键后，退出校零状态。
如操作者认为校零结果不满意，可重复执行此操作。
在退出菜单操作之前，如用户选择不存储修改值，则“键盘校零”操作结果无效。
******************************************************************************* */
void CalibrateOffsetC(void)
{ 
   if(keyFlag == DIS_PARA_INT)
   {
      modifyBit = 4;
      keyValue = 0;
      keyFlag  = FLASH_BIT;
      ClearDisplay();
    
      //在瞬时流量显示区显示当前使用的小传感器气体零点
      Dis1[1]  = WORD_O;
      Dis1[2]  = WORD_L;
      Dis1[3]  = WORD_D;
      Dis1[4]  = WORD_NULL;
      Dis1[5]  = WORD_NULL;
      Dis1[6]  = WORD_NULL;
       
      setKeyBuffer = offsetGas;
      Dis1[7]      = (unsigned char)(setKeyBuffer / (unsigned int)10000);
      setKeyBuffer = setKeyBuffer - (unsigned int)Dis1[7] * 10000;
    
      Dis1[8]      = (unsigned char)(setKeyBuffer / (unsigned int)1000);
      setKeyBuffer = setKeyBuffer - (unsigned int)Dis1[8] * 1000;
       
      Dis1[9]      = (unsigned char)(setKeyBuffer / 100);
      setKeyBuffer = setKeyBuffer - (unsigned int)Dis1[9] * 100;
      Dis1[10]     = setKeyBuffer / 10;
  
      setKeyBuffer = (unsigned char)(setKeyBuffer - (unsigned int)Dis1[10] * 10);
      Dis1[11]     = (unsigned char)setKeyBuffer;
       
      display0_data[FLOW_1] = Code_AFED_BGC[Dis1[1]];
      display0_data[FLOW_2] = Code_AFED_BGC[Dis1[2]];
      display0_data[FLOW_3] = Code_AFED_BGC[Dis1[3]];
      display0_data[FLOW_4] = Code_AFED_BGC[Dis1[4]];
      display0_data[FLOW_5] = Code_AFED_BGC[Dis1[5]];
      display0_data[FLOW_6] = Code_AFED_BGC[Dis1[6]];

      display0_data[FLOW_7]  = Code_AFED_BGC[Dis1[7]]; 
      display0_data[FLOW_8]  = Code_AFED_BGC[Dis1[8]]; 
      display0_data[FLOW_9]  = Code_AFED_BGC[Dis1[9]]; 
      display0_data[FLOW_10] = Code_AFED_BGC[Dis1[10]]; 
      display0_data[FLOW_11] = Code_AFED_BGC[Dis1[11]]; 
      LcdWriteDisplaySecond();

      // 从滑动滤波暂存器中读取当前新的零点值，并显示与总流量显示区
      Dis1[1]  = WORD_NULL;
      Dis1[2]  = WORD_NULL;
      Dis1[3]  = WORD_NULL;
      Dis1[8]  = WORD_NULL;
      Dis1[9]  = WORD_NULL;
      Dis1[10]  = WORD_NULL;
      Dis1[11]  = WORD_NULL;
       
      setKeyBuffer = ReadDataFromMovingAverage(NIDX);
      Dis1[4]      = (unsigned char)(setKeyBuffer / (unsigned int)10000);
      setKeyBuffer = setKeyBuffer - (unsigned int)Dis1[4] * 10000;
    
      Dis1[5]      = (unsigned char)(setKeyBuffer / (unsigned int)1000);
      setKeyBuffer = setKeyBuffer - (unsigned int)Dis1[5] * 1000;
       
      Dis1[6]      = (unsigned char)(setKeyBuffer / 100);
      setKeyBuffer = setKeyBuffer - (unsigned int)Dis1[6] * 100;
      
      Dis1[7]      = setKeyBuffer / 10;
      setKeyBuffer = (unsigned char)(setKeyBuffer - (unsigned int)Dis1[7] * 10);
       
      Dis1[8]      = (unsigned char)setKeyBuffer;
    }
    
    //键值处理
    switch(keyValue)
    {
        case FUN_KEY:
           ClearDisplay();
           setKeyBuffer  = ReadDataFromMovingAverage(NIDX);
           keyValue = 0;
           setKeyType = 1;
           keyFlag = DIS_PARA_INT;
           break;   
           
        //case UPPER_KEY:
        //   ClearDisplay();
        //   setKeyType = 0;
        //   keyFlag = DISPLAY_MENU;
        //   break;  
          
        default:
           break;
    } 
    
    keyValue = 0;
}

/*********************************************************************************/ 
//修改脉冲当量
void ModifyLPFactoryLiterPerPulse(void)
{
   unsigned int I;
    
   if(keyFlag == DIS_PARA_INT)
   {
      modifyBit = 5;
      keyValue = 0;
      keyFlag  = FLASH_BIT;
      ClearDisplay();
    
      Dis1[1] = WORD_NULL;
      Dis1[2] = WORD_NULL;
      Dis1[3] = WORD_NULL;
      Dis1[4] = WORD_NULL;
       
      Dis1[5] = 0; Dis1[6] = 0; Dis1[7] = 0; Dis1[8] = 0; Dis1[9] = 0;
      Dis1[10] = WORD_NULL;
      Dis1[11] = WORD_L; 
      Dis1[12] = WORD_NULL;
      Dis1[13] = WORD_NULL;
    
      setKeyBuffer  = factoryUnitPerPulse;
           if(setKeyBuffer == 10000)  modifyBit = 5;  //1000 L
      else if(setKeyBuffer == 1000)   modifyBit = 6;  //100 L
      else if(setKeyBuffer == 100)    modifyBit = 7;  //10 L
      else if(setKeyBuffer == 10)     modifyBit = 8;  //1 L
      else if(setKeyBuffer == 1)      modifyBit = 9;  //0.1 L
    }
    
    switch(keyValue)
    {
       case FUN_KEY:
               if(modifyBit == 5)  setKeyBuffer = 10000;
          else if(modifyBit == 6)  setKeyBuffer = 1000;
          else if(modifyBit == 7)  setKeyBuffer = 100;
          else if(modifyBit == 8)  setKeyBuffer = 10;
          else if(modifyBit == 9)  setKeyBuffer = 1;
          keyFlag  = DIS_PARA_INT;
          setKeyType = 1;
          break;
          
       case UPPER_KEY:
          if(modifyBit >= 9)  modifyBit = 5;
          else                modifyBit++;  
          break;
          
       default:
          break;
    } 
    
    Dis1[5] = Dis1[6] = Dis1[7] = Dis1[8] = Dis1[9] = 0;
    Dis1[modifyBit] = 1;
    for(I = 5; I < 9; I++)
    {
      if(Dis1[I] != 0) break;
      display1_data[ACC_1 + I - 1] &= (unsigned char)BIT0;
    }
    display1_data[ACC_POINT] |= (unsigned char)ACC_POINT_BIT; 
    
    keyValue =0;
}

/******************************************************************************/
void ModifyModBusAdr(void)
{
   if(keyFlag == DIS_PARA_INT)
   {
      modifyBit = 6;
      keyValue = 0;
      keyFlag  = FLASH_BIT;
      ClearDisplay();

      Dis1[1]  = WORD_F;
      Dis1[2]  = 5;
      Dis1[3]  = WORD_LINE;
      Dis1[4]  = WORD_LINE;
    
      Dis1[5]  = WORD_NULL;
      Dis1[9]  = WORD_NULL;    
      Dis1[10] = WORD_NULL;
      Dis1[11] = WORD_NULL;
      Dis1[12] = WORD_NULL;
      Dis1[13] = WORD_NULL; 
   
      setKeyBuffer = localAddress;
      Dis1[6]      = (unsigned char)(setKeyBuffer / (unsigned int)100);    
      setKeyBuffer = setKeyBuffer - (unsigned int)Dis1[6] * 100;
      Dis1[7]      = (unsigned char)(setKeyBuffer / 10);     
      setKeyBuffer = setKeyBuffer - (unsigned int)Dis1[7] * 10;
      Dis1[8]      = (unsigned char)setKeyBuffer;
    }
   
    switch(keyValue)
    {
       case FUN_KEY:
          setKeyBuffer  = (unsigned int)Dis1[6]*100;
          setKeyBuffer += (unsigned int)Dis1[7]*10;
          setKeyBuffer += (unsigned int)Dis1[8];
          keyFlag  = DIS_PARA_INT;
          setKeyType = 1;
          break;
          
       case UPPER_KEY:
           if(modifyBit == 6)
           {
              if(Dis1[modifyBit] >= 2) Dis1[modifyBit] = 0;
              else                     Dis1[modifyBit]++;   
           }
           else if(modifyBit == 7)
           {
              if(Dis1[modifyBit] >= 9) Dis1[modifyBit] = 0;
              else                     Dis1[modifyBit]++;   
            
              if( (Dis1[6] == 2) && (Dis1[7] > 3) && (Dis1[8] > 7) )   Dis1[8] = 7;
              if( (Dis1[6] == 2) && (Dis1[7] > 4) )   Dis1[modifyBit] = 0; 
           }
           else
           {
              if((Dis1[6] == 2) && (Dis1[7] == 4) && (Dis1[modifyBit] >= 7))       Dis1[modifyBit] = 0;
              else  if((Dis1[6] == 0) && (Dis1[7] == 0) && (Dis1[modifyBit] >= 9)) Dis1[modifyBit] = 1;
              else  if(Dis1[modifyBit] >= 9)                                       Dis1[modifyBit] = 0;
              else                                                                 Dis1[modifyBit]++;  
           }  
          break;
        
       case SHIFT_KEY:
          if(modifyBit >= 8)  modifyBit = 6;
          else                modifyBit++;  
          break;
    } 
    
    keyValue = 0;
}

void ModifyUartDecimalPoint(void)
{
   if(keyFlag == DIS_PARA_INT)
   {
      modifyBit = 6;
      keyValue = 0;
      keyFlag  = FLASH_BIT;
      ClearDisplay();

      Dis1[1]  = WORD_F;
      Dis1[2]  = 6;
      Dis1[3]  = WORD_LINE;
      Dis1[4]  = WORD_LINE;
    
      Dis1[5]  = WORD_NULL;
      Dis1[6]  = WORD_NULL;
      Dis1[7]  = WORD_NULL;
      Dis1[9]  = WORD_NULL;    
      Dis1[10] = WORD_NULL;
      Dis1[11] = WORD_NULL;
      Dis1[12] = WORD_NULL;
      Dis1[13] = WORD_NULL; 
   
      setKeyBuffer = uartDecimalPoint;
      Dis1[8]      = (unsigned char)setKeyBuffer;
    }
   
    switch(keyValue)
    {
       case FUN_KEY:
          setKeyBuffer = (unsigned int)Dis1[8];
          keyFlag  = DIS_PARA_INT;
          setKeyType = 1;
          break;
          
       case UPPER_KEY:
          if(Dis1[8] == 3) Dis1[8] = 4;
          else             Dis1[8] = 3;
          break;
        
       case SHIFT_KEY:
          if(Dis1[8] == 3) Dis1[8] = 4;
          else             Dis1[8] = 3;
          break;
    } 
    
    keyValue = 0;

}

/******************************************************************************/
//低功耗表按键处理程序
/******************************************************************************
低功耗表按键功能：
1、设置仪表系数；
2、设置二次修正系数；
进入按键处理程序前，需输入用户参数密码1（1111）；

用户参数密码1输入正确后，
1、选择SET-FCOE菜单即可设置仪表系数MeterFactor；
2、选择SET_DCOE菜单后，需要输入用户设置密码2（2222），正确后即可设置二次修正系数device coefficients；

用户选择return菜单项确定后，选择SET-Y则存储设置参数，否则，不存储设置参数
*******************************************************************************/
void KeyInputProcessing(void)
{ 
    isEnableLowPowerMode = 0;
    FlashBitForSetup();
    ReadKeyValue();
    if(keyValue == 0) return;
    IDvalidTime = 0;
    
KeyInputNext:
    if(keyFlag == DISPLAY_MENU) 
    {
       keyDealFlag = DisplaySetIndex();
            if(keyDealFlag == 1) goto KeyInputNext;
       else if(keyDealFlag == 2) goto KeyInputReturn;
    }
    else
    {
       // input password
       switch(menuIndex)
       {
           case KEY_INIT_PASSWORD: 
              if(keyFlag == DIS_PARA_INT) 
              {
                 if(keyValue == SHIFT_KEY) goto KeyInputReturn;
                 if(keyValue == UPPER_KEY) goto KeyInputReturn;
              }
              
              if(!KeyPasswordInput()) break;
              ComputPassWordToArray();
              keyFlag = DIS_PARA_INT;
              if(PassWord != LEVEL_1_PASSWORD) goto KeyInputReturn;
              menuIndex = 1; 
              keyFlag   = DISPLAY_MENU; 
              goto KeyInputNext;
              break;

           case KEY_SET_METERFACTOR:                                            //F1 设置仪表系数
               if(setKeyType == 0) ModifyMeterFactor();
               if(setKeyType == 1) 
               {
                  keyDealFlag = SaveModifyValue();
                  keyValue = 0;
                  if(keyDealFlag == NEXT) break;
                  setKeyType = 0;
                  keyFlag = DISPLAY_MENU;
                  if(keyDealFlag != SAVE) goto KeyInputNext;
                  
                  MeterFactor = setKeyBuffer;
                  tempL.DWord = (unsigned long int)MeterFactor;
                  tempL.Byte[METER_FACTOR_CRC] = CRC8(tempL.Byte, METER_FACTOR_CRC);
                  WriteMultiByteToEEPROM(METER_FACTOR, tempL.Byte, METER_FACTOR_WIDTH, PARA_EEPROM);
                  goto KeyInputNext;
               }
               break;
           
           case KEY_SET_COEFFIC:                                                //F2 设置二次修正系数
              if(PassWord != LEVEL_2_PASSWORD)                                  //2222
              {
                 if(!KeyPasswordInput()) break;
                 ComputPassWordToArray();
                 keyFlag = DISPLAY_MENU; 
                 if(PassWord != LEVEL_2_PASSWORD)  goto KeyInputNext;
                 setKeyType = 0;
                 keyFlag = DIS_PARA_INT; 
              }
              
       KeyInputLoop:
              if(setKeyType == 0) ModifyDcoefNum();        
              if(setKeyType == 1) ModifyDcoefNode();               
              if(setKeyType == 2) 
              {
                 if(ModifyDcoefVal())
                 {
                    setIndex++;
                    setKeyType = 1;
                    keyFlag = DIS_PARA_INT;
                    if(setIndex < temp_dcoefNum) goto KeyInputLoop;
                    keyValue = 0;
                    setKeyType = 3;
                 }
              }
              if(setKeyType == 3) 
              {
                 keyDealFlag = SaveModifyValue();
                 keyValue = 0;
                 if(keyDealFlag == NEXT) break;
                 PassWord   = 0;
                 setKeyType = 0;
                 keyFlag = DISPLAY_MENU;
                 if(keyDealFlag != SAVE) goto KeyInputNext;
                 // 存储二次修正系数
                 dcoefNum = temp_dcoefNum;
                 tempL.Byte[0] = dcoefNum;
                 tempL.Byte[1] = CRC8(tempL.Byte, 1);
                 WriteMultiByteToEEPROM(DCOEF_NUM, &tempL.Byte[0], DCOEF_NUM_WIDTH, PARA_EEPROM); 
                 for(setIndex = 0; setIndex < dcoefNum; setIndex++)
                 {
                    dcoefNode[setIndex] = temp_dcoefNode[setIndex];
                    dcoefVal[setIndex]  = temp_dcoefVal[setIndex];
                    StoreDevCoefNodeAndValue(setIndex);
                 }
                 RetriveDevCoef();
                 goto KeyInputNext;
              }
              break;
           
           case KEY_CALIB_OFFSETC:                                              //F3 按键校准offset c
              if(PassWord != LEVEL_3_PASSWORD)                                  //0520
              {
                 if(!KeyPasswordInput()) break;
                 ComputPassWordToArray();
                 keyFlag = DISPLAY_MENU; 
                 if(PassWord != LEVEL_3_PASSWORD) goto KeyInputNext;
                 keyFlag = DIS_PARA_INT; 
              }
              if(setKeyType == 0) CalibrateOffsetC();
              if(setKeyType == 1)
              {
                 keyDealFlag = SaveModifyValue();
                 keyValue = 0;
                 if(keyDealFlag == NEXT) break;
                 PassWord   = 0;
                 setKeyType = 0;
                 keyFlag = DISPLAY_MENU;
                 if(keyDealFlag != SAVE) goto KeyInputNext;
                 offsetGas = setKeyBuffer;
                 tempL.DWord = (unsigned long int)setKeyBuffer;
                 tempL.Byte[OFFSET_GAS_CRC] = CRC8(tempL.Byte, OFFSET_GAS_CRC);
                 WriteMultiByteToEEPROM(OFFSET_GAS, tempL.Byte, OFFSET_GAS_WIDTH, PARA_EEPROM);
                 goto KeyInputNext;
              }
              break;
           
           case KEY_SET_PULSE:                                                  //F4 设置脉冲当量
               if(setKeyType == 0) ModifyLPFactoryLiterPerPulse();
               if(setKeyType == 1) 
               {
                  keyDealFlag = SaveModifyValue();
                  keyValue = 0;
                  if(keyDealFlag == NEXT) break;
                  setKeyType = 0;
                  keyFlag = DISPLAY_MENU;
                  if(keyDealFlag != SAVE) goto KeyInputNext;
                  if(factoryUnitPerPulse == (unsigned int)setKeyBuffer) goto KeyInputNext;
                  
                  lastRemaining = 0;
                  factoryUnitPerPulse = setKeyBuffer;
                  tempL.DWord = (unsigned long int)factoryUnitPerPulse;
                  tempL.Byte[PULSE_UNIT_CRC] = CRC8(tempL.Byte, PULSE_UNIT_CRC);
                  WriteMultiByteToEEPROM(PULSE_UNIT, tempL.Byte, PULSE_UNIT_WIDTH, PARA_EEPROM);
                  goto KeyInputNext;
               }
              break;

           case KEY_SET_ADDR:                                                   //F5 设置MODBUS
              if(setKeyType == 0) ModifyModBusAdr();
              if(setKeyType == 1) 
              {
                 keyDealFlag = SaveModifyValue();
                 keyValue = 0;
                 if(keyDealFlag == NEXT) break;
                 setKeyType = 0;
                 keyFlag = DISPLAY_MENU;
                 if(keyDealFlag != SAVE) goto KeyInputNext;
                 localAddress = setKeyBuffer;
                 tempL.DWord = (unsigned long int)localAddress;
                 tempL.Byte[SLAVER_ADDR_CRC] = CRC8(tempL.Byte, SLAVER_ADDR_CRC);
                 WriteMultiByteToEEPROM(SLAVER_ADDR, tempL.Byte, SLAVER_ADDR_WIDTH, PARA_EEPROM);
                 goto KeyInputNext;
              }
              break;
   
           case KEY_SET_DECIMAL_POINT:                                          //F5 设置MODBUS
              if(setKeyType == 0) ModifyUartDecimalPoint();
              if(setKeyType == 1) 
              {
                 keyDealFlag = SaveModifyValue();
                 keyValue = 0;
                 if(keyDealFlag == NEXT) break;
                 setKeyType = 0;
                 keyFlag = DISPLAY_MENU;
                 if(keyDealFlag != SAVE) goto KeyInputNext;
                 uartDecimalPoint = (unsigned char)setKeyBuffer;
                 tempL.DWord = (unsigned long int)uartDecimalPoint;
                 tempL.Byte[COM_DECIMAL_POINT_CRC] = CRC8(tempL.Byte, COM_DECIMAL_POINT_CRC);
                 WriteMultiByteToEEPROM(COM_DECIMAL_POINT, tempL.Byte, COM_DECIMAL_POINT_WIDTH, PARA_EEPROM);
                 goto KeyInputNext;
              }
              break;
              
           //case KEY_SET_SAVE:                                                   //退出菜单-放弃/存储设置值选择
           //   if(ReturnKeySetSub()) goto KeyInputReturn;  
           //   break;
           
           default:
              goto KeyInputReturn;
              break;
       }  
    }
      
    keyValue = 0;
    DisplayEditMenu();
    return;
    
KeyInputReturn:
    KeyReset();
    DisableKeyInterrupt();
    NumericPrepForOutputAndDisplay();
    return;
}