hal_timer.c

Zigbee2006入门（源代码+文档讲解+系统推荐）

uint8 halTimerSetCount (uint8 hwtimerid, uint32 timePerTick)
{
  uint16  count;
  uint8   high, low;

  /* Load count = ((sec/tick) x clock) / prescale */
  count = (uint16)((timePerTick * halTimerRecord[hwtimerid].clock) / halTimerRecord[hwtimerid].prescaleVal);
  high = (uint8) (count >> 8);
  low = (uint8) count;

  *(halTimerChannel[hwtimerid].TxCCH) = high;
  *(halTimerChannel[hwtimerid].TxCCL) = low;

  return HAL_TIMER_OK;
}

/***************************************************************************************************
 * @fn      halTimerSetPrescale
 *
 * @brief   Stop the Timer Service
 *
 * @param   hwtimerid - ID of the timer
 *          prescale - Prescale of the clock
 *
 * @return  Status - OK or Not OK
 ***************************************************************************************************/
uint8 halTimerSetPrescale (uint8 hwtimerid, uint8 prescale)
{
  switch (hwtimerid)
  {
    case HW_TIMER_1:
      T1CTL &= ~(HAL_TIMER1_16_TC_BITS);
      T1CTL |= prescale;
      break;
    case HW_TIMER_3:
      T3CTL &= ~(HAL_TIMER34_8_TC_BITS);
      T3CTL |= prescale;
      break;
    case HW_TIMER_4:
      T4CTL &= ~(HAL_TIMER34_8_TC_BITS);
      T4CTL |= prescale;
      break;
    default:
      return HAL_TIMER_INVALID_ID;
  }
  return HAL_TIMER_OK;
}

/***************************************************************************************************
 * @fn      halTimerSetOpMode
 *
 * @brief   Setup operate modes
 *
 * @param   hwtimerid - ID of the timer
 *          opMode - operation mode of the timer
 *
 * @return  Status - OK or Not OK
 ***************************************************************************************************/
uint8 halTimerSetOpMode (uint8 hwtimerid, uint8 opMode)
{
  /* Load Waveform Generation Mode */
  switch (opMode)
  {
    case HAL_TIMER_MODE_NORMAL:
      switch (hwtimerid)
      {
        case HW_TIMER_1:
          T1CTL &= ~(HAL_TIMER1_OPMODE_BITS);
          T1CTL |= HAL_TIMER1_OPMODE_FREERUN;
          break;
        case HW_TIMER_3:
          T3CTL &= ~(HAL_TIMER34_OPMODE_BITS);
          T3CTL |= HAL_TIMER34_OPMODE_FREERUN;
          break;
        case HW_TIMER_4:
          T4CTL &= ~(HAL_TIMER34_OPMODE_BITS);
          T4CTL |= HAL_TIMER34_OPMODE_FREERUN;
          break;
        default:
          return HAL_TIMER_INVALID_ID;
      }
      break;

    case HAL_TIMER_MODE_CTC:
      switch (hwtimerid)
      {
        case HW_TIMER_1:
          T1CTL &= ~(HAL_TIMER1_OPMODE_BITS);
          T1CTL |= HAL_TIMER1_OPMODE_MODULO;
          break;
        case HW_TIMER_3:
          T3CTL &= ~(HAL_TIMER34_OPMODE_BITS);
          T3CTL |= HAL_TIMER34_OPMODE_MODULO;
          break;
        case HW_TIMER_4:
          T4CTL &= ~(HAL_TIMER34_OPMODE_BITS);
          T4CTL |= HAL_TIMER34_OPMODE_MODULO;
          break;
        default:
          return HAL_TIMER_INVALID_ID;
      }
      break;

    case HAL_TIMER_MODE_STOP:
      if (hwtimerid == HW_TIMER_1)
      {
        T1CTL &= ~(HAL_TIMER1_OPMODE_BITS);
        T1CTL |= HAL_TIMER1_OPMODE_STOP;
      }
      break;

    default:
      return HAL_TIMER_INVALID_OP_MODE;
  }
  return HAL_TIMER_OK;
}

/***************************************************************************************************
 * @fn      halTimerSetChannelMode
 *
 * @brief   Setup channel modes.  Currently, only output compare mode is supported.  Input capture
 *          mode is NOT supported.  Additionally, mapping timer channel inputs/outputs to I/O pins
 *          is NOT supported.
 *
 * @param   hwtimerid - ID of the timer
 *          channelMode - channel mode of the timer
 *
 * @return  Status - OK or Not OK
 ***************************************************************************************************/
uint8 halTimerSetChannelMode (uint8 hwtimerid, uint8 channelMode)
{
  switch (channelMode)
  {
    case HAL_TIMER_CH_MODE_OUTPUT_COMPARE:
      *(halTimerChannel[hwtimerid].TxCCTL) &= ~(T134CCTL_CMP_BITS);
      *(halTimerChannel[hwtimerid].TxCCTL) |= (T134CCTL_CMP_OC | T134CCTL_MODE);
      break;

    case HAL_TIMER_CH_MODE_INPUT_CAPTURE:       /* Not Supported */
/*
      *(halTimerChannel[hwtimerid].TxCCTL) &= ~(T134CCTL_CAP_BITS | T134CCTL_MODE);
      *(halTimerChannel[hwtimerid].TxCCTL) |= T134CCTL_CAP_RE;
*/
      break;

    default:
      return HAL_TIMER_INVALID_CH_MODE;
  }
  return HAL_TIMER_OK;
}

/***************************************************************************************************
 * @fn      HalTimerInterruptEnable
 *
 * @brief   Setup operate modes
 *
 * @param   hwtimerid - ID of the timer
 *          channelMode - channel mode
 *          enable - TRUE or FALSE
 *
 * @return  Status - OK or Not OK
 ***************************************************************************************************/
uint8 HalTimerInterruptEnable (uint8 hwtimerid, uint8 channelMode, bool enable)
{
  switch (channelMode)
  {
    case HAL_TIMER_CH_MODE_OVERFLOW:

      if (enable)
      {
        *(halTimerChannel[hwtimerid].TxOVF) |= halTimerChannel[hwtimerid].ovfbit;
      }
      else
      {
        *(halTimerChannel[hwtimerid].TxOVF) &= ~(halTimerChannel[hwtimerid].ovfbit);
      }
      break;

    case HAL_TIMER_CH_MODE_OUTPUT_COMPARE:
    case HAL_TIMER_CH_MODE_INPUT_CAPTURE:

      if (enable)
      {
        *(halTimerChannel[hwtimerid].TxCCTL) |= T134CCTL_IM;
      }
      else
      {
        *(halTimerChannel[hwtimerid].TxCCTL) &= ~(T134CCTL_IM);
      }
      break;

    default:
      return HAL_TIMER_INVALID_CH_MODE;
  }

  if (halTimerRecord[hwtimerid].intEnable)
  {
    IEN1 |= halTimerChannel[hwtimerid].intbit;
  }
  else
  {
    IEN1 &= ~(halTimerChannel[hwtimerid].intbit);
  }
  return HAL_TIMER_OK;
}

/***************************************************************************************************
 * @fn      halTimerSendCallBack
 *
 * @brief   Send Callback back to the caller
 *
 * @param   timerId - ID of the timer
 *          channel - channel where the interrupt occurs
 *          channelMode - channel mode
 *
 *
 * @return  None
 ***************************************************************************************************/
void halTimerSendCallBack (uint8 timerId, uint8 channel, uint8 channelMode)
{
  uint8 hwtimerid;

  hwtimerid = halTimerRemap (timerId);

  if (halTimerRecord[hwtimerid].callBackFunc)
    (halTimerRecord[hwtimerid].callBackFunc) (timerId, channel, channelMode);
}

/***************************************************************************************************
 * @fn      halTimerRemap
 *
 * @brief   Maps API HAL_TIMER_ID to HW Timer ID.
 *          HAL_TIMER_0 --> HW Timer 3
 *          HAL_TIMER_2 --> HW Timer 4
 *          HAL_TIMER_3 --> HW Timer 1
 *
 * @param   timerId - ID of the timer
 *
 * @return  HW timer ID
 ***************************************************************************************************/
uint8 halTimerRemap (uint8 timerId)
{
  switch (timerId)
  {
    case HAL_TIMER_0:
      return HW_TIMER_3;
    case HAL_TIMER_2:
      return HW_TIMER_4;
    case HAL_TIMER_3:
      return HW_TIMER_1;
    default:
      return HW_TIMER_INVALID;
  }
}

/***************************************************************************************************
 * @fn      halProcessTimer1
 *
 * @brief   Processes Timer 1 Events.
 *
 * @param
 *
 * @return
 ***************************************************************************************************/
void halProcessTimer1 (void)
{
  if (halTimerRecord[halTimerRemap(HAL_TIMER_3)].channelMode == HAL_TIMER_CH_MODE_OUTPUT_COMPARE)
  {
    if (T1CTL & T1CTL_CH0IF)
    {
      T1CTL &= ~(T1CTL_CH0IF);
      halTimerSendCallBack (HAL_TIMER_3, HAL_TIMER_CHANNEL_A, HAL_TIMER_CH_MODE_OUTPUT_COMPARE);
    }
    if (T1CTL & T1CTL_CH1IF)
    {
      T1CTL &= ~(T1CTL_CH1IF);
      halTimerSendCallBack (HAL_TIMER_3, HAL_TIMER_CHANNEL_B, HAL_TIMER_CH_MODE_OUTPUT_COMPARE);
    }
    if (T1CTL & T1CTL_CH2IF)
    {
      T1CTL &= ~(T1CTL_CH2IF);
      halTimerSendCallBack (HAL_TIMER_3, HAL_TIMER_CHANNEL_C, HAL_TIMER_CH_MODE_OUTPUT_COMPARE);
    }
  }
  else if (halTimerRecord[halTimerRemap(HAL_TIMER_3)].channelMode == HAL_TIMER_CH_MODE_OVERFLOW)
  {
    if (T1CTL & T1CTL_OVFIF)
    {
      T1CTL &= ~(T1CTL_OVFIF);
      halTimerSendCallBack (HAL_TIMER_3, HAL_TIMER_CHANNEL_SINGLE, HAL_TIMER_CH_MODE_OVERFLOW);
    }
  }
}

/***************************************************************************************************
 * @fn      halProcessTimer3
 *
 * @brief   Processes Timer 3 Events.
 *
 * @param
 *
 * @return
 ***************************************************************************************************/
void halProcessTimer3 (void)
{
  if (halTimerRecord[halTimerRemap(HAL_TIMER_0)].channelMode == HAL_TIMER_CH_MODE_OUTPUT_COMPARE)
  {
    if (TIMIF & TIMIF_T3CH0IF)
    {
      TIMIF &= ~(TIMIF_T3CH0IF);
      halTimerSendCallBack (HAL_TIMER_0, HAL_TIMER_CHANNEL_A, HAL_TIMER_CH_MODE_OUTPUT_COMPARE);
    }
    if (TIMIF & TIMIF_T3CH1IF)
    {
      TIMIF &= ~(TIMIF_T3CH1IF);
      halTimerSendCallBack (HAL_TIMER_0, HAL_TIMER_CHANNEL_B, HAL_TIMER_CH_MODE_OUTPUT_COMPARE);
    }
  }
  else if (halTimerRecord[halTimerRemap(HAL_TIMER_0)].channelMode == HAL_TIMER_CH_MODE_OVERFLOW)
  {
    if (TIMIF & TIMIF_T3OVFIF)
    {
      TIMIF &= ~(TIMIF_T3OVFIF);
      halTimerSendCallBack (HAL_TIMER_0, HAL_TIMER_CHANNEL_SINGLE, HAL_TIMER_CH_MODE_OVERFLOW);
    }
  }
}

/***************************************************************************************************
 * @fn      halProcessTimer4
 *
 * @brief   Processes Timer 4 Events.
 *
 * @param
 *
 * @return
 ***************************************************************************************************/
void halProcessTimer4 (void)
{
  if (halTimerRecord[halTimerRemap(HAL_TIMER_2)].channelMode == HAL_TIMER_CH_MODE_OUTPUT_COMPARE)
  {
    if (TIMIF & TIMIF_T4CH0IF)
    {
      TIMIF &= ~(TIMIF_T4CH0IF);
      halTimerSendCallBack (HAL_TIMER_2, HAL_TIMER_CHANNEL_A, HAL_TIMER_CH_MODE_OUTPUT_COMPARE);
    }
    if (TIMIF & TIMIF_T4CH1IF)
    {
      TIMIF &= ~(TIMIF_T4CH1IF);
      halTimerSendCallBack (HAL_TIMER_2, HAL_TIMER_CHANNEL_B, HAL_TIMER_CH_MODE_OUTPUT_COMPARE);
    }
  }
  else if (halTimerRecord[halTimerRemap(HAL_TIMER_2)].channelMode == HAL_TIMER_CH_MODE_OVERFLOW)
  if (TIMIF & TIMIF_T4OVFIF)
  {
    TIMIF &= ~(TIMIF_T4OVFIF);
    halTimerSendCallBack (HAL_TIMER_2, HAL_TIMER_CHANNEL_SINGLE, HAL_TIMER_CH_MODE_OVERFLOW);
  }
}

/***************************************************************************************************
 *                                    INTERRUPT SERVICE ROUTINE
 ***************************************************************************************************/

/**************************************************************************************************
 * @fn      halTimer1Isr
 *
 * @brief   Timer 1 ISR
 *
 * @param
 *
 * @return
 **************************************************************************************************/
HAL_ISR_FUNCTION( halTimer1Isr, T1_VECTOR )
{
  halProcessTimer1 ();
}

/**************************************************************************************************
 * @fn      halTimer3Isr
 *
 * @brief   Timer 3 ISR
 *
 * @param
 *
 * @return
 **************************************************************************************************/
HAL_ISR_FUNCTION( halTimer3Isr, T3_VECTOR )
{
  halProcessTimer3 ();
}

/**************************************************************************************************
 * @fn      halTimer4Isr
 *
 * @brief   Timer 4 ISR
 *
 * @param
 *
 * @return
 **************************************************************************************************/
HAL_ISR_FUNCTION( halTimer4Isr, T4_VECTOR )
{
  halProcessTimer4 ();
}

/***************************************************************************************************
***************************************************************************************************/