stm8_tsl_rc_services.c

基于STM8 的电容按键算法, 方案便宜

  {
    // KeyToCheck and current key are in same group ?
    if ( sMCKeyInfo[KeyToCheck].DESGroup & DESGroupMask )
    {
      if ( sMCKeyInfo[KeyToCheck].Setting.b.LOCKED )
      {
        goto ExitToIdle;
      }
    }
  }
#endif

  pKeyStruct->Setting.b.LOCKED = 1;
  return;

ExitToIdle:   // The DES is verified at PRE DETECT state only !
  pKeyStruct->Channel.IntegratorCounter++;  // Increment integrator to never allow DETECT state
  return;
}


/**
  ******************************************************************************
  * @brief Verify Detection Timeout for current Key.
  * @par Parameters:
  * None
  * @retval void None
  * @par Required preconditions:
  * None
  ******************************************************************************
  */
void TSL_SCKey_DetectionTimeout(void)
{
  if ( Local_TickFlag.b.DTO_1sec )
  {
    if ( DetectionTimeout )
    {
      pKeyStruct->Counter--;
      if ( !pKeyStruct->Counter )
      {
        TSL_SCKey_SetCalibrationState( );
      }
    }
  }
}

//============================================================================
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//-----             MULTI CHANNEL KEY SERVICES                           -----
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//============================================================================

//============================================================================
//-----         CONDITIONAL COMPILING FOR MCKEYS !!!               -----------
#if NUMBER_OF_MULTI_CHANNEL_KEYS > 0
//============================================================================

//--------    SECTION DEFINITION FOR THIS FILE   --------------
#if defined(__CSMC__) && defined(USE_PRAGMA_SECTION)
#pragma section [TSLMCK_RAM]
#pragma section @tiny [TSLMCK_RAM0]
#pragma section (TSLMCK_CODE)
#pragma section const {TSLMCK_CONST}
#endif

/* Coefficient table used to adjust the Delta on MCKey1 */
const u16 MCKEY1_DELTA_COEFF[CHANNEL_PER_MCKEY] =
{
#ifdef MCKEY1_DELTA_COEFF_A
  MCKEY1_DELTA_COEFF_A,
#else
  0x0100,
#endif
#ifdef MCKEY1_DELTA_COEFF_B
  MCKEY1_DELTA_COEFF_B,
#else
  0x0100,
#endif
#ifdef MCKEY1_DELTA_COEFF_C
  MCKEY1_DELTA_COEFF_C,
#else
  0x0100,
#endif
#ifdef MCKEY1_DELTA_COEFF_D
  MCKEY1_DELTA_COEFF_D,
#else
  0x0100,
#endif
#ifdef MCKEY1_DELTA_COEFF_E
  MCKEY1_DELTA_COEFF_E,
#else
  0x0100,
#endif
#if CHANNEL_PER_MCKEY == 8
#ifdef MCKEY1_DELTA_COEFF_F
  MCKEY1_DELTA_COEFF_F,
#else
  0x0100,
#endif
#ifdef MCKEY1_DELTA_COEFF_G
  MCKEY1_DELTA_COEFF_G,
#else
  0x0100,
#endif
#ifdef MCKEY1_DELTA_COEFF_H
  MCKEY1_DELTA_COEFF_H
#else
  0x0100
#endif
#endif
};

#if NUMBER_OF_MULTI_CHANNEL_KEYS > 1
/* Coefficient table used to adjust the Delta on MCKey2 */
const u16 MCKEY2_DELTA_COEFF[CHANNEL_PER_MCKEY] =
{
#ifdef MCKEY2_DELTA_COEFF_A
  MCKEY2_DELTA_COEFF_A,
#else
  0x0100,
#endif
#ifdef MCKEY2_DELTA_COEFF_B
  MCKEY2_DELTA_COEFF_B,
#else
  0x0100,
#endif
#ifdef MCKEY2_DELTA_COEFF_C
  MCKEY2_DELTA_COEFF_C,
#else
  0x0100,
#endif
#ifdef MCKEY2_DELTA_COEFF_D
  MCKEY2_DELTA_COEFF_D,
#else
  0x0100,
#endif
#ifdef MCKEY2_DELTA_COEFF_E
  MCKEY2_DELTA_COEFF_E,
#else
  0x0100,
#endif
#if CHANNEL_PER_MCKEY == 8
#ifdef MCKEY2_DELTA_COEFF_F
  MCKEY2_DELTA_COEFF_F,
#else
  0x0100,
#endif
#ifdef MCKEY2_DELTA_COEFF_G
  MCKEY2_DELTA_COEFF_G,
#else
  0x0100,
#endif
#ifdef MCKEY2_DELTA_COEFF_H
  MCKEY2_DELTA_COEFF_H
#else
  0x0100
#endif
#endif
};
#endif

/**
  ******************************************************************************
  * @brief Update pointer to current MCKey Structure.
  * @par Parameters:
  * None
  * @retval void None
  * @par Required preconditions:
  * None
  ******************************************************************************
  */
void TSL_MCKey_SetStructPointer(void)
{
  pMCKeyStruct = &sMCKeyInfo[KeyIndex];
}


/**
  ******************************************************************************
  * @brief Calculates Delta for a channel of the current MCKey.
  * @param[in] ChIdx Channel index (0 = MCKEY1, 1 = MCKEY2)
  * @retval void None
  * @par Required preconditions:
  * None
  ******************************************************************************
  */
void TSL_MCKey_DeltaCalculation(u8 ChIdx)
{
  Delta = (s16)(pMCKeyStruct->Channel[ChIdx].LastMeas - pMCKeyStruct->Channel[ChIdx].Reference);
}


/**
  ******************************************************************************
  * @brief Short local routine to setup MCKey internal state machine.
  * @par Parameters:
  * None
  * @retval void None
  * @par Required preconditions:
  * None
  ******************************************************************************
  */
void TSL_MCKey_SetIdleState(void)
{
  pMCKeyStruct->Setting.b.CHANGED = 1;
  TSL_MCKey_BackToIdleState( );
}


/**
  ******************************************************************************
  * @brief Short local routine to setup MCKey internal state machine.
  * @par Parameters:
  * None
  * @retval void None
  * @par Required preconditions:
  * None
  ******************************************************************************
  */
void TSL_MCKey_BackToIdleState(void)
{
  pMCKeyStruct->State.whole = IDLE_STATE;
  pMCKeyStruct->Setting.b.DETECTED = 0;
  pMCKeyStruct->Setting.b.LOCKED = 0;
}


/**
  ******************************************************************************
  * @brief Short local routine to setup MCKey internal state machine.
  * @par Parameters:
  * None
  * @retval void None
  * @par Required preconditions:
  * None
  ******************************************************************************
  */
void TSL_MCKey_SetPreDetectState(void)
{
  pMCKeyStruct->State.whole = PRE_DETECTED_STATE;
  pMCKeyStruct->Channel[0].IntegratorCounter = DetectionIntegrator;
}


/**
  ******************************************************************************
  * @brief Short local routine to setup MCKey internal state machine.
  * @par Parameters:
  * None
  * @retval void None
  * @par Required preconditions:
  * None
  ******************************************************************************
  */
void TSL_MCKey_SetDetectedState(void)
{
  pMCKeyStruct->State.whole = DETECTED_STATE;
  pMCKeyStruct->Setting.b.DETECTED = 1;
  pMCKeyStruct->Setting.b.CHANGED = 1;
  pMCKeyStruct->Counter = DetectionTimeout;
  pMCKeyStruct->Channel[1].IntegratorCounter = pMCKeyStruct->DirectionChangeIntegrator;
}


/**
  ******************************************************************************
  * @brief Short local routine to setup MCKey internal state machine.
  * @par Parameters:
  * None
  * @retval void None
  * @par Required preconditions:
  * None
  ******************************************************************************
  */
void TSL_MCKey_SetPostDetectState(void)
{
  pMCKeyStruct->State.whole = POST_DETECTED_STATE;
  pMCKeyStruct->Channel[0].IntegratorCounter = EndDetectionIntegrator;
}


/**
  ******************************************************************************
  * @brief Short local routine to setup MCKey internal state machine.
  * @par Parameters:
  * None
  * @retval void None
  * @par Required preconditions:
  * None
  ******************************************************************************
  */
void TSL_MCKey_BackToDetectedState(void)
{
  pMCKeyStruct->State.whole = DETECTED_STATE;
}


/**
  ******************************************************************************
  * @brief Short local routine to setup MCKey internal state machine.
  * @par Parameters:
  * None
  * @retval void None
  * @par Required preconditions:
  * None
  ******************************************************************************
  */
void TSL_MCKey_SetPreRecalibrationState(void)
{
  pMCKeyStruct->State.whole = PRE_CALIBRATION_STATE;
  pMCKeyStruct->Channel[0].IntegratorCounter = RecalibrationIntegrator;
}


/**
  ******************************************************************************
  * @brief Short local routine to setup MCKey internal state machine.
  * @par Parameters:
  * None
  * @retval void None
  * @par Required preconditions:
  * None
  ******************************************************************************
  */
void TSL_MCKey_SetCalibrationState(void)
{
  u8 Index;

  pMCKeyStruct->State.whole = CALIBRATION_STATE;
  pMCKeyStruct->Setting.b.DETECTED = 0;
  pMCKeyStruct->Setting.b.CHANGED = 1;
  pMCKeyStruct->Setting.b.LOCKED = 0;
  pMCKeyStruct->Counter = MCKEY_CALIBRATION_COUNT_DEFAULT;
  for ( Index = 0; Index < CHANNEL_PER_MCKEY; Index++ )
  {
    pMCKeyStruct->Channel[Index].Reference = 0;
  }
}


/**
  ******************************************************************************
  * @brief Short local routine to setup MCKey internal state machine.
  * @par Parameters:
  * None
  * @retval void None
  * @par Required preconditions:
  * None
  ******************************************************************************
  */
void TSL_MCKey_SetErrorState(void)
{
  pMCKeyStruct->State.whole = ERROR_STATE;
  pMCKeyStruct->Setting.b.DETECTED = 0;
  pMCKeyStruct->Setting.b.CHANGED = 1;
  pMCKeyStruct->Setting.b.LOCKED = 0;
  pMCKeyStruct->Setting.b.ERROR = 1;
}


/**
  ******************************************************************************
  * @brief Short local routine to setup MCKey internal state machine.
  * @par Parameters:
  * None
  * @retval void None
  * @par Required preconditions:
  * None
  ******************************************************************************
  */
void TSL_MCKey_SetDisabledState(void)
{
  pMCKeyStruct->State.whole = DISABLED_STATE;
  pMCKeyStruct->Setting.b.DETECTED = 0;
  pMCKeyStruct->Setting.b.CHANGED = 1;
  pMCKeyStruct->Setting.b.LOCKED = 0;
}


/**
  ******************************************************************************
  * @brief Apply Detection Exclusion System algorithm (DES) on MCKeys.
  * This function modify the LOCKED bit of current MCKey structure only.
  * @par Parameters:
  * None
  * @retval void None
  * @par Required preconditions:
  * None
  ******************************************************************************
  */
void TSL_MCKey_DES(void)
{

  u8 DESGroupMask, KeyToCheck;

  if ( pMCKeyStruct->Setting.b.LOCKED )
    return;

  DESGroupMask = pMCKeyStruct->DESGroup;

  for ( KeyToCheck = 0; KeyToCheck < NUMBER_OF_SINGLE_CHANNEL_KEYS; KeyToCheck++ )
  {
    // KeyToCheck and current key are in same group ?
    if ( sSCKeyInfo[KeyToCheck].DESGroup & DESGroupMask )
    {
      if ( sSCKeyInfo[KeyToCheck].Setting.b.LOCKED )
      {
        goto ExitToIdle;
      }
    }
  }

#if NUMBER_OF_MULTI_CHANNEL_KEYS > 1
  for ( KeyToCheck = 0; KeyToCheck < NUMBER_OF_MULTI_CHANNEL_KEYS; KeyToCheck++ )
  {
    if ( KeyToCheck != KeyIndex )
    {
      // KeyToCheck and current key are in same group ?
      if ( sMCKeyInfo[KeyToCheck].DESGroup & DESGroupMask )
      {
        if ( sMCKeyInfo[KeyToCheck].Setting.b.LOCKED )
        {
          goto ExitToIdle;
        }
      }
    }
  }
#endif

  pMCKeyStruct->Setting.b.LOCKED = 1;
  return;

ExitToIdle:   // The DES is verified at PRE DETECT state only !
  pMCKeyStruct->Channel[0].IntegratorCounter++;  // Increment integrator to never allow DETECT state
  return;
}


/**
  ******************************************************************************
  * @brief Verify Detection Timeout for current MCKey.
  * @par Parameters:
  * None
  * @retval void None
  * @par Required preconditions:
  * None
  ******************************************************************************
  */
void TSL_MCKey_DetectionTimeout(void)
{
  if ( Local_TickFlag.b.DTO_1sec )
  {
    if ( DetectionTimeout )
    {
      pMCKeyStruct->Counter--;
      if ( !pMCKeyStruct->Counter )
      {
        TSL_MCKey_SetCalibrationState( );
      }
    }
  }
}

//============================================================================
//-----         CONDITIONAL COMPILING FOR MCKEYS !!!               -----------
#endif
//============================================================================

/*********************** (c) 2009 STMicroelectronics **************************/