开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > DNA > 查看源码
LPC_Timer.c
资源名称：LPC2148_IAR_LPC2148.zip　[点击查看]
上传用户：sourcesun
上传日期：2013-09-23
资源大小：362k
文件大小：25k
源码类别：

DNA

开发平台：

Asm

LPC_Timer.c：源码内容
  1. /*************************************************************************
  2.  *
  3.  *    Used with ICCARM and AARM.
  4.  *
  5.  *    (c) Copyright IAR Systems 2003
  6.  *
  7.  *    File name   : LPC_Timer.c
  8.  *    Description : Define API for Timer system
  9.  *
  10.  *    History :
  11.  *    1. Date: July 08, 2004
  12.  *       Author: Wilson Liu
  13.  *       Description: Create the basic function
  14.  *
  15.  *    2. Date: August 12, 2004
  16.  *       Author: Shawn Zhang
  17.  *       Description: Re-write some API interface
  18.  *
  19.  *    3. Data        : Oct 10, 2004
  20.  *       Author      : Stanimir Bonev
  21.  *       Description : Modify some functions interface
  22.  *
  23.  *    $Revision: 1.1.4.1 $
  24.  **************************************************************************/
  26. #include "LPC_Timer.h"
  28. LPC_Timer_Config_t Timer0Config, Timer1Config;
  30. /*************************************************************************
  31.  * Function Name: TIMER_Init
  32.  * Parameters:  LPC_TimerChanel_t DevNum
  33.  *          unsigned int precision -- the timer precision (Unit: us), general setting is 10 us
  34.  * Return: int
  35.  *              0: success
  36.  *   non-zero: error number
  37.  * Description: Initialize Timer, Set the PR register that represent the precision of timer.
  38.  *
  39.  *************************************************************************/
  40. int TIMER_Init(LPC_TimerChanel_t DevNum, unsigned long precision)
  41. {
  42. int i;
  43.   //all registers are set to 0;
  44.   switch (DevNum)
  45.   {
  46.   case TIMER0:
  47.     // Set globe variable
  48.     Timer0Config.Precision = precision;
  49.     // PR = Precision(us) * Pclk
  50.     if(precision)
  51.     {
  52.       Timer0Config.Prescaler = (precision * SYS_GetFpclk()) / 1000000;
  53.     }
  54.     else
  55.     {
  56.       Timer0Config.Prescaler = 1;
  57.     }
  58.     for (i=0; i<CH_MAXNUM; ++i)
  59.     {
  60.       Timer0Config.MatchCH[i].Enable = false;
  61.       Timer0Config.MatchCH[i].Action = 0;
  62.       Timer0Config.MatchCH[i].TimeValue =0;
  63.       Timer0Config.MatchCH[i].Fnpr = NULL;
  64.       Timer0Config.MatchCH[i].FnprArg = (void *)0;
  66.       Timer0Config.CaptureCH[i].Enable = false;
  67.       Timer0Config.CaptureCH[i].TriggerType= 0;
  68.       Timer0Config.CaptureCH[i].EnableInt = 0;
  69.       Timer0Config.CaptureCH[i].Fnpr = NULL;
  70.       Timer0Config.CaptureCH[i].FnprArg = (void *)0;
  71.       Timer0Config.CaptureCH[i].CPValue= 0;
  73.       Timer0Config.ExtAction[i]= DONOTHING;
  74.       Timer0Config.ExtBitValue[i]= 0;
  75.     }
  76.     // Clear interrupts flags
  77.     T0IR=0xFF;
  78.     // Disable counting
  79.     T0TCR=0;
  80.     // Clear timer counter
  81.     T0TC=0;
  82.     // PR = Presclare - 1
  83.     T0PR= Timer0Config.Prescaler - 1;
  84.     // Clear prescaler timer counter
  85.     T0PC=0;
  86.     // Reset Compare modules
  87.     T0MCR=0;
  88.     T0MR0=0;
  89.     T0MR1=0;
  90.     T0MR2=0;
  91.     T0MR3=0;
  92.     // Reset Capture modules
  93.     T0CCR=0;
  94.     // Reset External Compare module
  95.     T0EMR=0;
  96.     break;
  97.   case TIMER1:
  98.     // Set globe variable
  99.     Timer1Config.Precision = precision;
  100.     // PR = Precision(us) * Pclk
  101.     if(precision)
  102.     {
  103.       Timer1Config.Prescaler = (precision * SYS_GetFpclk()) / 1000000;
  104.     }
  105.     else
  106.     {
  107.       Timer1Config.Prescaler = 1;
  108.     }
  109.     for (i=0; i<CH_MAXNUM; ++i)
  110.     {
  111.       Timer1Config.MatchCH[i].Enable = false;
  112.       Timer1Config.MatchCH[i].Action = 0;
  113.       Timer1Config.MatchCH[i].TimeValue =0;
  114.       Timer1Config.MatchCH[i].Fnpr = NULL;
  115.       Timer1Config.MatchCH[i].FnprArg = (void *)0;
  117.       Timer1Config.CaptureCH[i].Enable = false;
  118.       Timer1Config.CaptureCH[i].TriggerType= 0;
  119.       Timer1Config.CaptureCH[i].EnableInt = 0;
  120.       Timer1Config.CaptureCH[i].Fnpr = NULL;
  121.       Timer1Config.CaptureCH[i].FnprArg = (void *)0;
  122.       Timer1Config.CaptureCH[i].CPValue= 0;
  124.       Timer1Config.ExtAction[i]= DONOTHING;
  125.       Timer1Config.ExtBitValue[i]= 0;
  126.     }
  127.     // Clear interrupts flags
  128.     T1IR=0xFF;
  129.     // Disable counting
  130.     T1TCR=0;
  131.     // Clear timer counter
  132.     T1TC=0;
  133.     // PR = Prescaler - 1
  134.     T1PR=Timer1Config.Prescaler - 1;
  135.     // Clear prescaler timer counter
  136.     T1PC=0;
  137.     // Reset Compare modules
  138.     T1MCR=0;
  139.     T1MR0=0;
  140.     T1MR1=0;
  141.     T1MR2=0;
  142.     T1MR3=0;
  143.     // Reset Capture modules
  144.     T1CCR=0;
  145.     // Reset External Compare module
  146.     T1EMR=0;
  147.     break;
  148.   default:
  149.     return 1;
  150.   }
  151.   return 0;
  152. }
  154. /*************************************************************************
  155.  * Function Name: TIMER_GetPrescaler
  156.  * Parameters:  LPC_TimerChanel_t DevNum
  157.  * Return: unsigned int
  158.  *
  159.  *
  160.  * Description: Return prescaler value
  161.  *
  162.  *
  163.  *************************************************************************/
  164. unsigned long TIMER_GetPrescaler(LPC_TimerChanel_t DevNum)
  165. {
  166.   switch (DevNum)
  167.   {
  168.   case TIMER0:
  169.     return Timer0Config.Prescaler;
  170.   case TIMER1:
  171.     return Timer1Config.Prescaler;
  172.   }
  173.   return 0;
  174. }
  176. /*************************************************************************
  177.  * Function Name: TIMER_Reset
  178.  * Parameters:  LPC_TimerChanel_t DevNum
  179.   * Return: int
  180.  *              0: success
  181.  *       non-zero: error number
  182.  * Description: When next pclk arrives, only the TC and PC will be reset.
  183.  *              Whilst other registers remain.
  184.  *
  185.  *************************************************************************/
  186. int TIMER_Reset(LPC_TimerChanel_t DevNum)
  187. {
  188.   switch (DevNum)
  189.   {
  190.   case TIMER0:
  191.     T0TCR |= 2;
  192.     return 0;
  193.   case TIMER1:
  194.     T1TCR |= 2;
  195.     return 0;
  196.   }
  197.   return 1;
  198. }
  200. /*************************************************************************
  201.  * Function Name: TIMER_Start
  202.  * Parameters:  LPC_TimerChanel_t DevNum
  203.  * Return: int
  204.  *              0: success
  205.  *       non-zero: error number
  206.  * Description: Start Timer or enable the Timer. if the Timer stop now, the Timer will
  207.  *    resume running after calling this function.
  208.  *
  209.  *************************************************************************/
  210. int TIMER_Start(LPC_TimerChanel_t DevNum)
  211. {
  212.   switch (DevNum)
  213.   {
  214.   case TIMER0:
  215.     // Clear reset flag
  216.     T0TCR &= ~2;
  217.     // Counting enable
  218.     T0TCR_bit.CE = true;
  219.     return 0;
  220.   case TIMER1:
  221.     // Clear reset flag
  222.     T1TCR &= ~2;
  223.     // Counting enable
  224.     T1TCR_bit.CE = true;
  225.     return 0;
  226.   }
  227.   return 1;
  228. }
  230. /*************************************************************************
  231.  * Function Name: TIMER_Stop
  232.  * Parameters:  LPC_TimerChanel_t DevNum
  233.  * Return: int
  234.  *              0: success
  235.  *       non-zero: error number
  236.  * Description: Just stop Timer or disable Timer, all registers remain.
  237.  *
  238.  *************************************************************************/
  239. int TIMER_Stop(LPC_TimerChanel_t DevNum)
  240. {
  241.   switch (DevNum)
  242.   {
  243.   case TIMER0:
  244.     T0TCR_bit.CE = false;
  245.     return 0;
  246.   case TIMER1:
  247.     T1TCR_bit.CE = false;
  248.     return 0;
  249.   }
  250.   return 1;
  251. }
  253. /*************************************************************************
  254.  * Function Name: TIMER_GetTimerMatch
  255.  * Parameters:  LPC_TimerChanel_t DevNum,
  256.  *          unsigned int MRNum,
  257.  *          unsigned int * pAction ,
  258.  *          unsigned int * pMatchValue
  259.  * Return: int
  260.  *              0: success
  261.  *   non-zero: error number
  262.  * Description: Get correponding matching information for specific timer.
  263.  *
  264.  *************************************************************************/
  265. int TIMER_GetTimerMatch(LPC_TimerChanel_t DevNum, unsigned int MRNum,
  266.             unsigned int * pAction , unsigned int * pMatchValue)
  267. {
  268.   if (MRNum >= CH_MAXNUM)
  269.     return 1;
  270.   switch(DevNum)
  271.   {
  272.   case TIMER0:
  273.     *pMatchValue = Timer0Config.MatchCH[MRNum].TimeValue;
  274.     *pAction = Timer0Config.MatchCH[MRNum].Action;
  275.     break;
  276.   case TIMER1:
  277.     *pMatchValue = Timer1Config.MatchCH[MRNum].TimeValue;
  278.     *pAction = Timer1Config.MatchCH[MRNum].Action;
  279.     break;
  280.   default:
  281.     return 1;
  282.   }
  283.   return 0;
  284. }
  286. /*************************************************************************
  287.  * Function Name: TIMER_SetMatchAction
  288.  * Parameters:  LPC_TimerChanel_t DevNum -- Device Number
  289.  *    unsigned int MRNum -- Match Channel Number
  290.  *    unsigned int action -- General Interrupt | Reset Timer | Stop Timer
  291.  *    unsigned int Timevalue -- the time value (Unit: us)
  292.  *    void (* Fnpr)(void *) -- ISR function pointer
  293.  *    void * FnprArg -- relative argument
  294.  *    LPC_Timer_ExtAction_t ExtAction -- External Match Control Action
  295.  *
  296.  * Return: int
  297.  *              0: success
  298.  *       non-zero: error number
  299.  * Description: Set correponding matching action and other information to the channel
  300.  *    for specific timer.
  301.  *
  302.  *************************************************************************/
  303. int TIMER_SetMatchAction(LPC_TimerChanel_t DevNum,
  304.                           unsigned int MRNum,
  305.                           unsigned int action ,
  306.                           unsigned long TimeValue,
  307.                           void (* Fnpr)(void *),
  308.                           void * FnprArg,
  309.                           LPC_Timer_ExtAction_t ExtAction)
  310. {
  311.   // Check parameter valid
  312.   if (action>TimerAction_StopTimer+TimerAction_ResetTimer+TimerAction_Interrupt)
  313.     return 1;
  314.   if (ExtAction > TOGGLE)
  315.     return 1;
  316.   switch (DevNum)
  317.   {
  318.   case TIMER0:
  319.     // Set Mash register
  320.     switch (MRNum)
  321.     {
  322.     case CH0:
  323.       T0MR0=TimeValue;
  324.       break;
  325.     case CH1:
  326.       T0MR1=TimeValue;
  327.       break;
  328.     case CH2:
  329.       T0MR2=TimeValue;
  330.       break;
  331.     case CH3:
  332.       T0MR3=TimeValue;
  333.       break;
  334.     default:
  335.       return 1;
  336.     }
  337.     Timer0Config.MatchCH[MRNum].Enable = true;
  338.     Timer0Config.MatchCH[MRNum].Action = action;
  339.     Timer0Config.MatchCH[MRNum].TimeValue= TimeValue;
  340.     Timer0Config.ExtAction[MRNum]= ExtAction;
  341.     // Clear actions
  342.     T0MCR &= ~(7<<(MRNum*3));
  343.     //Set Reset on Match
  344.     if (action & TimerAction_ResetTimer)
  345.       T0MCR |= TimerAction_ResetTimer << (3*MRNum);
  346.     //Set StopWatch on Match
  347.     if (action & TimerAction_StopTimer)
  348.       T0MCR |= TimerAction_StopTimer << (3*MRNum);
  349.     //Set Interrupt on Match
  350.     if (action & TimerAction_Interrupt)
  351.     {
  352.       Timer0Config.MatchCH[MRNum].Fnpr = Fnpr;
  353.       Timer0Config.MatchCH[MRNum].FnprArg = FnprArg;
  354.       T0MCR |= TimerAction_Interrupt << (3*MRNum);
  355.     }
  356.     // Clear External action
  357.     T0EMR &= ~(3 << (4 + 2*MRNum));
  358.     // Set External action
  359.     switch (MRNum)
  360.     {
  361.     case CH0:
  362.       // Set External action type
  363.       T0EMR_bit.EMC0 = ExtAction;
  364.       // Assign pin to match modyle
  365.       if (ExtAction != DONOTHING)
  366.         PINSEL0_bit.P0_3 = 0x2;
  367.       break;
  368.     case CH1:
  369.       // Set External action type
  370.       T0EMR_bit.EMC1 = ExtAction;
  371.       // Assign pin to match modyle
  372.       if (ExtAction != DONOTHING)
  373.         PINSEL0_bit.P0_5 = 0x2;
  374.       break;
  375.     case CH2:
  376.       // Set External action type
  377.       T0EMR_bit.EMC2 = ExtAction;
  378.       // Assign pin to match modyle
  379.       if (ExtAction != DONOTHING)
  380.         PINSEL1_bit.P0_16 = 0x2;
  381.       break;
  382.     case CH3:
  383.       // Set External action type
  384.       T0EMR_bit.EMC3 = ExtAction;
  385.       break;
  386.     }
  387.     return 0;
  388.   case TIMER1:
  389.     // Set Mash register
  390.     switch (MRNum)
  391.     {
  392.     case CH0:
  393.       T1MR0=TimeValue;
  394.       break;
  395.     case CH1:
  396.       T1MR1=TimeValue;
  397.       break;
  398.     case CH2:
  399.       T1MR2=TimeValue;
  400.       break;
  401.     case CH3:
  402.       T1MR3=TimeValue;
  403.       break;
  404.     default:
  405.       return 1;
  406.     }
  408.     Timer1Config.MatchCH[MRNum].Enable = true;
  409.     Timer1Config.MatchCH[MRNum].Action = action;
  410.     Timer1Config.MatchCH[MRNum].TimeValue= TimeValue;
  411.     Timer1Config.ExtAction[MRNum]= ExtAction;
  412.     // Clear actions
  413.     T1MCR &= ~(7<<(MRNum*3));
  414.     //Set Reset on Match
  415.     if (action & TimerAction_ResetTimer)
  416.       T1MCR |= TimerAction_ResetTimer << (3*MRNum);
  417.     //Set StopWatch on Match
  418.     if (action & TimerAction_StopTimer)
  419.       T1MCR |= TimerAction_StopTimer << (3*MRNum);
  420.     //Set Interrupt on Match
  421.     if (action & TimerAction_Interrupt)
  422.     {
  423.       Timer1Config.MatchCH[MRNum].Fnpr = Fnpr;
  424.       Timer1Config.MatchCH[MRNum].FnprArg = FnprArg;
  425.       T1MCR |= TimerAction_Interrupt << (3*MRNum);
  426.     }
  427.     // Clear External action
  428.     T1EMR &= ~(3 << (4 + 2*MRNum));
  429.     // Set External action
  430.     switch (MRNum)
  431.     {
  432.     case CH0:
  433.       // Set External action type
  434.       T1EMR_bit.EMC0 = ExtAction;
  435.       // Assign pin to match modyle
  436.       if (ExtAction != DONOTHING)
  437.         PINSEL0_bit.P0_12 = 0x2;
  438.       break;
  439.     case CH1:
  440.       // Set External action type
  441.       T1EMR_bit.EMC1 = ExtAction;
  442.       // Assign pin to match modyle
  443.       if (ExtAction != DONOTHING)
  444.         PINSEL0_bit.P0_13 = 0x2;
  445.       break;
  446.     case CH2:
  447.       // Set External action type
  448.       T1EMR_bit.EMC2 = ExtAction;
  449.       // Assign pin to match modyle
  450.       if (ExtAction != DONOTHING)
  451.         PINSEL1_bit.P0_19 = 0x2;
  452.       break;
  453.     case CH3:
  454.       // Set External action type
  455.       T0EMR_bit.EMC3 = ExtAction;
  456.       // Assign pin to match modyle
  457.       if (ExtAction != DONOTHING)
  458.         PINSEL1_bit.P0_20 = 0x2;
  459.       break;
  460.     }
  461.     return 0;
  462.   }
  463.   return 1;
  464. }
  466. /*************************************************************************
  467.  * Function Name: TIMER_GetTimerExternalMatch
  468.  * Parameters:  LPC_TimerChanel_t DevNum
  469.  *          unsigned int MRNum,
  470.  *          unsigned int *pAction,
  471.  *          unsigned int *pExternalMatchValue
  472.  * Return: int
  473.  *              0: success
  474.  *   non-zero: error number
  475.  * Description: Get correponding external matching information from specific timer.
  476.  *
  477.  *************************************************************************/
  478. int TIMER_GetTimerExternalMatch(LPC_TimerChanel_t DevNum, unsigned int MRNum,
  479.             unsigned int * pAction , unsigned int *pExternalMatchValue)
  480. {
  481.   if (MRNum >= CH_MAXNUM)
  482.     return 1;
  483.   switch(DevNum)
  484.   {
  485.   case TIMER0:
  486.     *pExternalMatchValue = Timer0Config.ExtAction[MRNum];
  487.     *pAction = Timer0Config.MatchCH[MRNum].Action;
  488.     break;
  489.   case TIMER1:
  490.     *pExternalMatchValue = Timer1Config.ExtAction[MRNum];
  491.     *pAction = Timer1Config.MatchCH[MRNum].Action;
  492.     break;
  493.   default:
  494.     return 1;
  495.   }
  496.   return 0;
  497. }
  500. /*************************************************************************
  501.  * Function Name: TIMER_GetTimerCapture
  502.  * Parameters:  LPC_TimerChanel_t DevNum,
  503.  *    unsigned int CRNum,
  504.  *    unsigned int * pCaptureValue
  505.  * Return: int
  506.  *              0: success
  507.  *   non-zero: error number
  508.  * Description: Get correponding capture information from specific timer.
  509.  *
  510.  *************************************************************************/
  511. int TIMER_GetTimerCapture(LPC_TimerChanel_t DevNum, unsigned int CRNum,
  512.             unsigned int * pCaptureValue)
  513. {
  514.   switch(DevNum)
  515.   {
  516.   case TIMER0:
  517.     if (CRNum >= CPCH_MAXNUM-1)
  518.       return 1;
  519.     *pCaptureValue = Timer0Config.CaptureCH[CRNum].CPValue;
  520.     break;
  521.   case TIMER1:
  522.     if (CRNum >= CPCH_MAXNUM)
  523.       return 1;
  524.     *pCaptureValue = Timer1Config.CaptureCH[CRNum].CPValue;
  525.     break;
  526.   default:
  527.     return 1;
  528.   }
  529.   return 0;
  530. }
  533. /*************************************************************************
  534.  * Function Name: TIMER_SetCaptureAction
  535.  * Parameters:  LPC_TimerChanel_t DevNum  -- Device Number
  536.  *          unsigned char CPCHNum -- Capture Channel Number
  537.  *    unsigned char TriggerType -- Rising edge | Falling edge
  538.  *    bool EnableInt -- whether interrupt is generated
  539.  *    void (* Fnpr)(void *) -- ISR function pointer
  540.  *    void * FnprArg -- relative argument
  541.  *
  542.  * Return: int
  543.  *              0: success
  544.  *   non-zero: error number
  545.  * Description: Set correponding capture trigger type and other information to the channel
  546.  *    for specific timer.
  547.  *
  548.  *************************************************************************/
  549. int TIMER_SetCaptureAction (LPC_TimerChanel_t DevNum,
  550.                               unsigned char CPCHNum,
  551.                               unsigned char  TriggerType,
  552.                               bool EnableInt,
  553.                               void (* Fnpr)(void *),
  554.                               void * FnprArg )
  555. {
  556.   // Check parameter valid
  557.   if (TriggerType > TimerCPTrigger_Rising+TimerCPTrigger_Falling)
  558.     return 1;
  559.   switch (DevNum)
  560.   {
  561.   case TIMER0:
  562.     if (CPCHNum > CPCH_MAXNUM-2)  // for timer 0 cature chanel 3 is not exist
  563.       return 1;
  564.     Timer0Config.CaptureCH[CPCHNum].Enable = true;
  565.     Timer0Config.CaptureCH[CPCHNum].TriggerType = TriggerType;
  567.     // Clear Capture actions
  568.     T0CCR &= ~(7 << (3*CPCHNum));
  569.     // Assign of pin to capture module
  570.     switch (CPCHNum)
  571.     {
  572.     case CH0:
  573.       if (TriggerType == 0)
  574.         PINSEL0_bit.P0_2 = 0;
  575.       else
  576.         PINSEL0_bit.P0_2 = 0x2;
  577.       break;
  578.     case CH1:
  579.       if (TriggerType == 0)
  580.         PINSEL0_bit.P0_4 = 0;
  581.       else
  582.         PINSEL0_bit.P0_4 = 0x2;
  583.       break;
  584.     case CH2:
  585.       if (TriggerType == 0)
  586.         PINSEL0_bit.P0_6 = 0;
  587.       else
  588.         PINSEL0_bit.P0_6 = 0x2;
  589.       break;
  590.     }
  591.     //Set Capture on Rising Edge
  592.     if (TriggerType & TimerCPTrigger_Rising)
  593.       T0CCR |= TimerCPTrigger_Rising << (3*CPCHNum);
  594.     //Set Capture on Falling Edge
  595.     if (TriggerType & TimerCPTrigger_Falling)
  596.       T0CCR |= TimerCPTrigger_Falling << (3*CPCHNum);
  598.     //Set Interrupt on Capture
  599.     if (EnableInt && TriggerType)
  600.     {
  601.       Timer0Config.CaptureCH[CPCHNum].EnableInt = true;
  602.       Timer0Config.CaptureCH[CPCHNum].Fnpr = Fnpr;
  603.       Timer0Config.CaptureCH[CPCHNum].FnprArg = FnprArg;
  604.       T0CCR |= 0x4 << (3*CPCHNum);
  605.     }
  606.     else
  607.     {
  608.       Timer0Config.CaptureCH[CPCHNum].EnableInt = false;
  609.       Timer0Config.CaptureCH[CPCHNum].Fnpr = NULL;
  610.       Timer0Config.CaptureCH[CPCHNum].FnprArg = (void *)0;
  611.     }
  612.     return 0;
  613.   case TIMER1:
  614.     if (CPCHNum > CPCH_MAXNUM-1)
  615.       return 1;
  616.     Timer1Config.CaptureCH[CPCHNum].Enable = true;
  617.     Timer1Config.CaptureCH[CPCHNum].TriggerType = TriggerType;
  619.     // Clear Capture actions
  620.     T1CCR &= ~(7 << (3*CPCHNum));
  621.     // Assign of pin to capture module
  622.     switch (CPCHNum)
  623.     {
  624.     case CH0:
  625.       if (TriggerType == 0)
  626.         PINSEL0_bit.P0_10 = 0;
  627.       else
  628.         PINSEL0_bit.P0_10 = 0x2;
  629.       break;
  630.     case CH1:
  631.       if (TriggerType)
  632.         PINSEL0_bit.P0_11 = 0x2;
  633.       break;
  634.     case CH2:
  635.       if (TriggerType == 0)
  636.         PINSEL1_bit.P0_17 = 0;
  637.       else
  638.         PINSEL1_bit.P0_17 = 0x2;
  639.       break;
  640.     case CH3:
  641.       if (TriggerType == 0)
  642.         PINSEL1_bit.P0_18 = 0;
  643.       else
  644.         PINSEL1_bit.P0_18 = 0x2;
  645.       break;
  646.     }
  647.     //Set Capture on Rising Edge
  648.     if (TriggerType & TimerCPTrigger_Rising)
  649.       T1CCR |= TimerCPTrigger_Rising << (3*CPCHNum);
  651.     //Set Capture on Falling Edge
  652.     if (TriggerType & TimerCPTrigger_Falling)
  653.       T1CCR |= TimerCPTrigger_Falling << (3*CPCHNum);
  655.     //Set Interrupt on Capture
  656.     if (EnableInt && TriggerType)
  657.     {
  658.       Timer1Config.CaptureCH[CPCHNum].EnableInt = true;
  659.       Timer1Config.CaptureCH[CPCHNum].Fnpr = Fnpr;
  660.       Timer1Config.CaptureCH[CPCHNum].FnprArg = FnprArg;
  661.       T1CCR |= 0x4 << (3*CPCHNum);
  662.     }
  663.     else
  664.     {
  665.       Timer1Config.CaptureCH[CPCHNum].EnableInt = false;
  666.       Timer1Config.CaptureCH[CPCHNum].Fnpr = NULL;
  667.       Timer1Config.CaptureCH[CPCHNum].FnprArg = (void *)0;
  668.     }
  669.     return 0;
  670.   }
  671.   return 1;
  672. }
  674. /*************************************************************************
  675.  * Function Name: TIMER_GetREGValue_CR
  676.  * Parameters:  LPC_TimerChanel_t DevNum
  677.  *          int CRNum
  678.  * Return: unsigned long
  679.  *
  680.  * Description: Get CR register value
  681.  *
  682.  *************************************************************************/
  683. unsigned long TIMER_GetREGValue_CR(LPC_TimerChanel_t DevNum, int CRNum)
  684. {
  685.   switch (DevNum)
  686.   {
  687.   case TIMER0:
  688.     switch(CRNum)
  689.     {
  690.     case CPCH0:
  691.       return T0CR0;
  692.     case CPCH1:
  693.       return T0CR1;
  694.     case CPCH2:
  695.       return T0CR2;
  696.     case CPCH3:
  697.       return T0CR3;
  698.     }
  699.   case TIMER1:
  700.     switch(CRNum)
  701.     {
  702.     case CPCH0:
  703.       return T1CR0;
  704.     case CPCH1:
  705.       return T1CR1;
  706.     case CPCH2:
  707.       return T1CR2;
  708.     case CPCH3:
  709.       return T1CR3;
  710.     }
  711.   }
  712.   return (unsigned int)-1;
  713. }
  715. /*************************************************************************
  716.  * Function Name: TIMER_GetREGValue_TC
  717.  * Parameters: LPC_TimerChanel_t DevNum
  718.  * Return: unsigned long
  719.  *
  720.  * Description: Get TC register value
  721.  *
  722.  *************************************************************************/
  723. unsigned long TIMER_GetREGValue_TC(LPC_TimerChanel_t DevNum)
  724. {
  725.   switch (DevNum)
  726.   {
  727.   case TIMER0:
  728.     return T0TC;
  729.   case TIMER1:
  730.     return T1TC;
  731.   }
  732.   return (unsigned int)-1;
  733. }
  735. /*************************************************************************
  736.  * Function Name: TIMER_CheckIntSrc
  737.  * Parameters: LPC_TimerChanel_t DevNum
  738.  * Return: unsigned long
  739.  *  TIMERMR0...3Int | TIMERCR0...3Int
  740.  *
  741.  * Description: Get Timer interrupt Type
  742.  *
  743.  *************************************************************************/
  744. unsigned long TIMER_CheckIntType(LPC_TimerChanel_t DevNum)
  745. {
  746.   switch (DevNum)
  747.   {
  748.   case TIMER0:
  749.     return (T0IR & 0xFF);
  750.   case TIMER1:
  751.     return (T1IR & 0xFF);
  752.   default:
  753.     return (unsigned long)-1;
  754.   }
  755. }
  757. /*************************************************************************
  758.  * Function Name: RTC_ClearInt
  759.  * Parameters:  LPC_TimerChanel_t DevNum
  760.  *          int IntType
  761.  *
  762.  * Return: unsigned long
  763.  *              0: sucess
  764.  *    1: fail
  765.  *
  766.  * Description: Clear Timer interrupt.
  767.  *
  768.  *************************************************************************/
  769. unsigned long TIMER_ClearInt(LPC_TimerChanel_t DevNum, int IntType)
  770. {
  771.   if (IntType<1 || IntType>0xFF)
  772.     return 1;
  774.   switch (DevNum)
  775.   {
  776.   case TIMER0:
  777.     T0IR = (IntType & 0xFF);
  778.     break;
  779.   case TIMER1:
  780.     T1IR = (IntType & 0xFF);
  781.     break;
  782.   default:
  783.     return 1;
  784.   }
  785.   return 0;
  786. }
  788. /*************************************************************************
  789.  * Function Name: T0ISR
  790.  * Parameters: void
  791.  * Return: void
  792.  *
  793.  * Description: TIMER0 interrupt subroutine
  794.  *
  795.  *************************************************************************/
  796. void TIMER0_ISR ()
  797. {
  798. int IntStatus;
  799.   IntStatus = TIMER_CheckIntType(TIMER0);
  800.   TIMER_ClearInt(TIMER0, IntStatus);
  802.   /* Match Register Interrupt */
  803.   if (IntStatus & TIMERMR0Int)
  804.   {
  805.     (Timer0Config.MatchCH[0].Fnpr)((void *)Timer0Config.MatchCH[0].FnprArg);
  806.   }
  808.   if (IntStatus & TIMERMR1Int)
  809.   {
  810.     (Timer0Config.MatchCH[1].Fnpr)((void *)Timer0Config.MatchCH[1].FnprArg);
  811.   }
  813.   if (IntStatus & TIMERMR2Int)
  814.   {
  815.     (Timer0Config.MatchCH[2].Fnpr)((void *)Timer0Config.MatchCH[2].FnprArg);
  816.   }
  818.   if (IntStatus & TIMERMR3Int)
  819.   {
  820.     (Timer0Config.MatchCH[3].Fnpr)((void *)Timer0Config.MatchCH[3].FnprArg);
  821.   }
  823.   /* Capture Register Interrupt */
  824.   if (IntStatus & TIMERCR0Int)
  825.   {
  826.     Timer0Config.CaptureCH[0].CPValue = TIMER_GetREGValue_CR(TIMER0, CPCH0);
  827.     (Timer0Config.CaptureCH[0].Fnpr)((void *)Timer0Config.CaptureCH[0].FnprArg);
  828.   }
  830.   if (IntStatus & TIMERCR1Int)
  831.   {
  832.     Timer0Config.CaptureCH[1].CPValue = TIMER_GetREGValue_CR(TIMER0, CPCH1);
  833.     (Timer0Config.CaptureCH[1].Fnpr)((void *)Timer0Config.CaptureCH[1].FnprArg);
  834.   }
  836.   if (IntStatus & TIMERCR2Int)
  837.   {
  838.     Timer0Config.CaptureCH[2].CPValue = TIMER_GetREGValue_CR(TIMER0, CPCH2);
  839.     (Timer0Config.CaptureCH[2].Fnpr)((void *)Timer0Config.CaptureCH[2].FnprArg);
  840.   }
  842.   if (IntStatus & TIMERCR3Int)
  843.   {
  844.     Timer0Config.CaptureCH[3].CPValue = TIMER_GetREGValue_CR(TIMER0, CPCH3);
  845.     (Timer0Config.CaptureCH[3].Fnpr)((void *)Timer0Config.CaptureCH[3].FnprArg);
  846.   }
  847.   VICVectAddr = 0;    // Clear interrupt in VIC.
  848. }
  850. /*************************************************************************
  851.  * Function Name: T1ISR
  852.  * Parameters: void
  853.  * Return: void
  854.  *
  855.  * Description: TIMER1 interrupt subroutine
  856.  *
  857.  *************************************************************************/
  858. void TIMER1_ISR ()
  859. {
  860.   int IntStatus;
  862.   IntStatus = TIMER_CheckIntType(TIMER1);
  863.   TIMER_ClearInt(TIMER1, IntStatus);
  865.   /* Match Register Interrupt */
  866.   if (IntStatus & TIMERMR0Int)
  867.   {
  868.     (Timer1Config.MatchCH[0].Fnpr)((void *)Timer1Config.MatchCH[0].FnprArg);
  869.   }
  871.   if (IntStatus & TIMERMR1Int)
  872.   {
  873.     (Timer1Config.MatchCH[1].Fnpr)((void *)Timer1Config.MatchCH[1].FnprArg);
  874.   }
  876.   if (IntStatus & TIMERMR2Int)
  877.   {
  878.     (Timer1Config.MatchCH[2].Fnpr)((void *)Timer1Config.MatchCH[2].FnprArg);
  879.   }
  881.   if (IntStatus & TIMERMR3Int)
  882.   {
  883.     (Timer1Config.MatchCH[3].Fnpr)((void *)Timer1Config.MatchCH[3].FnprArg);
  884.   }
  886.   /* Capture Register Interrupt */
  887.   if (IntStatus & TIMERCR0Int)
  888.   {
  889.     Timer1Config.CaptureCH[0].CPValue = TIMER_GetREGValue_CR(TIMER1, CPCH0);
  890.     (Timer1Config.CaptureCH[0].Fnpr)((void *)Timer1Config.CaptureCH[0].FnprArg);
  891.   }
  893.   if (IntStatus & TIMERCR1Int)
  894.   {
  895.     Timer1Config.CaptureCH[1].CPValue = TIMER_GetREGValue_CR(TIMER1, CPCH1);
  896.     (Timer1Config.CaptureCH[1].Fnpr)((void *)Timer1Config.CaptureCH[1].FnprArg);
  897.   }
  899.   if (IntStatus & TIMERCR2Int)
  900.   {
  901.     Timer1Config.CaptureCH[2].CPValue = TIMER_GetREGValue_CR(TIMER1, CPCH2);
  902.     (Timer1Config.CaptureCH[2].Fnpr)((void *)Timer1Config.CaptureCH[2].FnprArg);
  903.   }
  905.   if (IntStatus & TIMERCR3Int)
  906.   {
  907.     Timer1Config.CaptureCH[3].CPValue = TIMER_GetREGValue_CR(TIMER1, CPCH3);
  908.     (Timer1Config.CaptureCH[3].Fnpr)((void *)Timer1Config.CaptureCH[3].FnprArg);
  909.   }
  911.   VICVectAddr = 0;    // Clear interrupt in VIC.
  912. }