PDL for FM0+  Version1.0
Peripheral Driverl Library for FM0+
C:/pdl_v10/library/driver/mft/mft_icu.c
Go to the documentation of this file.
00001 /*******************************************************************************
00002 * Copyright (C) 2013 Spansion LLC. All Rights Reserved. 
00003 *
00004 * This software is owned and published by: 
00005 * Spansion LLC, 915 DeGuigne Dr. Sunnyvale, CA  94088-3453 ("Spansion").
00006 *
00007 * BY DOWNLOADING, INSTALLING OR USING THIS SOFTWARE, YOU AGREE TO BE BOUND 
00008 * BY ALL THE TERMS AND CONDITIONS OF THIS AGREEMENT.
00009 *
00010 * This software contains source code for use with Spansion 
00011 * components. This software is licensed by Spansion to be adapted only 
00012 * for use in systems utilizing Spansion components. Spansion shall not be 
00013 * responsible for misuse or illegal use of this software for devices not 
00014 * supported herein.  Spansion is providing this software "AS IS" and will 
00015 * not be responsible for issues arising from incorrect user implementation 
00016 * of the software.  
00017 *
00018 * SPANSION MAKES NO WARRANTY, EXPRESS OR IMPLIED, ARISING BY LAW OR OTHERWISE,
00019 * REGARDING THE SOFTWARE (INCLUDING ANY ACOOMPANYING WRITTEN MATERIALS), 
00020 * ITS PERFORMANCE OR SUITABILITY FOR YOUR INTENDED USE, INCLUDING, 
00021 * WITHOUT LIMITATION, THE IMPLIED WARRANTY OF MERCHANTABILITY, THE IMPLIED 
00022 * WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE OR USE, AND THE IMPLIED 
00023 * WARRANTY OF NONINFRINGEMENT.  
00024 * SPANSION SHALL HAVE NO LIABILITY (WHETHER IN CONTRACT, WARRANTY, TORT, 
00025 * NEGLIGENCE OR OTHERWISE) FOR ANY DAMAGES WHATSOEVER (INCLUDING, WITHOUT 
00026 * LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, 
00027 * LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS) ARISING FROM USE OR 
00028 * INABILITY TO USE THE SOFTWARE, INCLUDING, WITHOUT LIMITATION, ANY DIRECT, 
00029 * INDIRECT, INCIDENTAL, SPECIAL OR CONSEQUENTIAL DAMAGES OR LOSS OF DATA, 
00030 * SAVINGS OR PROFITS, 
00031 * EVEN IF SPANSION HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 
00032 * YOU ASSUME ALL RESPONSIBILITIES FOR SELECTION OF THE SOFTWARE TO ACHIEVE YOUR
00033 * INTENDED RESULTS, AND FOR THE INSTALLATION OF, USE OF, AND RESULTS OBTAINED 
00034 * FROM, THE SOFTWARE.  
00035 *
00036 * This software may be replicated in part or whole for the licensed use, 
00037 * with the restriction that this Disclaimer and Copyright notice must be 
00038 * included with each copy of this software, whether used in part or whole, 
00039 * at all times.  
00040 */
00041 /******************************************************************************/
00055 /******************************************************************************/
00056 /* Include files                                                              */
00057 /******************************************************************************/
00058 #include "mft_icu.h"
00059 
00060 #if (defined(PDL_PERIPHERAL_MFT_ICU_ACTIVE))
00061    
00067 /******************************************************************************/
00068 /* Local pre-processor symbols/macros ('#define')                             */
00069 /******************************************************************************/
00070 
00071 /******************************************************************************/
00072 /* Global variable definitions (declared in header file with 'extern')        */
00073 /******************************************************************************/
00074 stc_mft_icu_instance_data_t m_astcMftIcuInstanceDataLut[MFT_ICU_INSTANCE_COUNT] =
00075 {
00076 #if (PDL_PERIPHERAL_ENABLE_MFT0_ICU == PDL_ON)
00077     { 
00078         &MFT0_ICU,    // pstcInstance
00079         {NULL,NULL,NULL,NULL}          // stcInternData (not initialized yet)
00080     },
00081 #endif
00082 #if (PDL_PERIPHERAL_ENABLE_MFT1_ICU == PDL_ON)
00083     { 
00084         &MFT1_ICU,    // pstcInstance
00085         {NULL,NULL,NULL,NULL}          // stcInternData (not initialized yet)
00086     },
00087 #endif
00088 #if (PDL_PERIPHERAL_ENABLE_MFT2_ICU == PDL_ON)
00089     { 
00090         &MFT2_ICU,    // pstcInstance
00091         {NULL,NULL,NULL,NULL}          // stcInternData (not initialized yet)
00092     },
00093 #endif
00094 };
00095 
00096 /******************************************************************************/
00097 /* Local type definitions ('typedef')                                         */
00098 /******************************************************************************/
00099 
00100 /******************************************************************************/
00101 /* Local function prototypes ('static')                                       */
00102 /******************************************************************************/
00103 #if (PDL_INTERRUPT_ENABLE_MFT0_ICU == PDL_ON) || \
00104     (PDL_INTERRUPT_ENABLE_MFT1_ICU == PDL_ON) || \
00105     (PDL_INTERRUPT_ENABLE_MFT2_ICU == PDL_ON)
00106 static stc_mft_icu_intern_data_t* MftIcuGetInternDataPtr(volatile stc_mftn_icu_t *pstcMftIcu);
00107 static void Mft_Icu_InitIrq( volatile stc_mftn_icu_t* pstcMftIcu );
00108 static void Mft_Icu_DeInitIrq( volatile stc_mftn_icu_t* pstcMftIcu );
00109 #endif
00110 /******************************************************************************/
00111 /* Local variable definitions ('static')                                      */
00112 /******************************************************************************/
00113 
00114 /******************************************************************************/
00115 /* Function implementation - global ('extern') and local ('static')           */
00116 /******************************************************************************/
00117 
00118 #if (PDL_INTERRUPT_ENABLE_MFT0_ICU == PDL_ON) || \
00119     (PDL_INTERRUPT_ENABLE_MFT1_ICU == PDL_ON) || \
00120     (PDL_INTERRUPT_ENABLE_MFT2_ICU == PDL_ON)
00121 
00130 static stc_mft_icu_intern_data_t* MftIcuGetInternDataPtr(volatile stc_mftn_icu_t *pstcMftIcu) 
00131 {
00132     uint8_t u8Instance;
00133    
00134     for (u8Instance = 0u; u8Instance < MFT_ICU_INSTANCE_COUNT; u8Instance++)
00135     {
00136         if (pstcMftIcu == m_astcMftIcuInstanceDataLut[u8Instance].pstcInstance)
00137         {
00138             return &m_astcMftIcuInstanceDataLut[u8Instance].stcInternData;
00139         }
00140     }
00141 
00142     return NULL;
00143 }       
00144         
00154 void Mft_Icu_IrqHandler( volatile stc_mftn_icu_t* pstcMftIcu, 
00155                          stc_mft_icu_intern_data_t* pstcMftIcuInternData)
00156 {
00157     // ICU interrupt 0
00158     if(TRUE == pstcMftIcu->ICSA10_f.ICP0)
00159     {
00160         pstcMftIcu->ICSA10_f.ICP0 = 0u;
00161         if (pstcMftIcuInternData->pfnIcu0Callback != NULL)
00162         {
00163              pstcMftIcuInternData->pfnIcu0Callback();
00164         }
00165     }
00166     // ICU interrupt 1
00167     if(TRUE == pstcMftIcu->ICSA10_f.ICP1)
00168     {
00169         pstcMftIcu->ICSA10_f.ICP1 = 0u;
00170         if (pstcMftIcuInternData->pfnIcu1Callback != NULL)
00171         {
00172              pstcMftIcuInternData->pfnIcu1Callback();
00173         }
00174     }
00175     // ICU interrupt 2
00176     if(TRUE == pstcMftIcu->ICSA32_f.ICP0)
00177     {
00178         pstcMftIcu->ICSA32_f.ICP0 = 0u;
00179         if (pstcMftIcuInternData->pfnIcu2Callback != NULL)
00180         {
00181              pstcMftIcuInternData->pfnIcu2Callback();
00182         }
00183     }
00184     // ICU interrupt 3
00185     if(TRUE == pstcMftIcu->ICSA32_f.ICP1)
00186     {
00187         pstcMftIcu->ICSA32_f.ICP1 = 0u;
00188         if (pstcMftIcuInternData->pfnIcu3Callback != NULL)
00189         {
00190              pstcMftIcuInternData->pfnIcu3Callback();
00191         }
00192     }
00193 }
00194 
00202 static void Mft_Icu_InitIrq( volatile stc_mftn_icu_t* pstcMftIcu ) 
00203 {
00204     if ((pstcMftIcu == (volatile stc_mftn_icu_t*)(&MFT0_ICU)) || 
00205         (pstcMftIcu == (volatile stc_mftn_icu_t*)(&MFT1_ICU)) ||
00206         (pstcMftIcu == (volatile stc_mftn_icu_t*)(&MFT2_ICU)))  
00207     {
00208         NVIC_ClearPendingIRQ(INCAP_IRQn);
00209         NVIC_EnableIRQ(INCAP_IRQn);
00210         NVIC_SetPriority(INCAP_IRQn, PDL_IRQ_LEVEL_MFT_ICU);   
00211     }
00212     return;
00213 }
00214 
00221 static void Mft_Icu_DeInitIrq( volatile stc_mftn_icu_t* pstcMftIcu ) 
00222 {
00223     if ((pstcMftIcu == (volatile stc_mftn_icu_t*)(&MFT0_ICU)) || 
00224         (pstcMftIcu == (volatile stc_mftn_icu_t*)(&MFT1_ICU)) ||
00225         (pstcMftIcu == (volatile stc_mftn_icu_t*)(&MFT2_ICU)))  
00226     {
00227         if(pstcMftIcu->ICSA10_f.ICE0 == 1u)
00228         {
00229             return;
00230         }
00231         if(pstcMftIcu->ICSA10_f.ICE1 == 1u)
00232         {
00233             return;
00234         }
00235         if(pstcMftIcu->ICSA32_f.ICE0 == 1u)
00236         {
00237             return;
00238         }
00239         if(pstcMftIcu->ICSA32_f.ICE1 == 0u)
00240         {
00241             return;
00242         }
00243         NVIC_ClearPendingIRQ(INCAP_IRQn);
00244         NVIC_DisableIRQ(INCAP_IRQn);
00245         NVIC_SetPriority(INCAP_IRQn, PDL_DEFAULT_INTERRUPT_LEVEL);
00246     }
00247     
00248     return;
00249 }
00250 
00251 #endif
00252 
00272 en_result_t Mft_Icu_SelFrt( volatile stc_mftn_icu_t* pstcMftIcu, uint8_t u8Ch, 
00273                             en_mft_icu_frt_t enFrt)
00274 {
00275     volatile stc_mft_icu_icfs10_field_t* stcICFS10;
00276     volatile stc_mft_icu_icfs32_field_t* stcICFS32;
00277 
00278     // Check for NULL pointer and channel parameter
00279     boolean_t bAvoidSideEffects  = ((NULL == pstcMftIcu) ? 1u : 0u);
00280               bAvoidSideEffects |= ((u8Ch > MFT_ICU_CHx_MAX) ? 1u : 0u);
00281     if (TRUE == bAvoidSideEffects)
00282     {
00283         return ErrorInvalidParameter ;
00284     }
00285 
00286     // Get actual address of register list of current channel
00287     stcICFS10 = (volatile stc_mft_icu_icfs10_field_t*)(&(pstcMftIcu->ICFS10));
00288     stcICFS32 = (volatile stc_mft_icu_icfs32_field_t*)(&(pstcMftIcu->ICFS32));
00289     
00290     // FRT channel select: FRTx -> ICUx
00291     if(enFrt > IcuFrtToExt1)
00292     {
00293         return ErrorInvalidParameter;
00294     }
00295     // configure the Frt channel to connect to Icu
00296     switch(u8Ch)
00297     {
00298         // ICU channel 0
00299         case MFT_ICU_CH0: 
00300             stcICFS10->FSI0 = (uint8_t)enFrt;           
00301             break;
00302         // ICU channel 1
00303         case MFT_ICU_CH1:            
00304             stcICFS10->FSI1 = (uint8_t)enFrt;
00305             break;
00306         // ICU channel 2
00307         case MFT_ICU_CH2:           
00308             stcICFS32->FSI0 = (uint8_t)enFrt;
00309             break;
00310         // ICU channel 3
00311         case MFT_ICU_CH3:
00312             stcICFS32->FSI1 = (uint8_t)enFrt;
00313             break;
00314         default:
00315             return ErrorInvalidParameter;
00316     }
00317     
00318     return Ok;
00319 }
00320 
00340 en_result_t Mft_Icu_ConfigDetectMode( volatile stc_mftn_icu_t* pstcMftIcu, uint8_t u8Ch, 
00341                                       en_mft_icu_mode_t enMode)
00342 {
00343     // Check for NULL pointer and channel parameter
00344     boolean_t bAvoidSideEffects  = ((NULL == pstcMftIcu) ? 1u : 0u);
00345     bAvoidSideEffects |= ((u8Ch > MFT_ICU_CHx_MAX) ? 1u : 0u);
00346     if (bAvoidSideEffects)
00347     {
00348         return ErrorInvalidParameter ;
00349     }
00350 
00351     // Check configuration of Mft Icu mode
00352     if(enMode > IcuBothDetect)
00353     {
00354         return ErrorInvalidParameter;
00355     }
00356     // Configure Icu detection mode
00357     switch (u8Ch)
00358     {
00359         // ICU channel 0
00360         case MFT_ICU_CH0:            
00361             pstcMftIcu->ICSA10_f.EG0 = (uint8_t)enMode;
00362             break;
00363         // ICU channel 1
00364         case MFT_ICU_CH1:
00365             pstcMftIcu->ICSA10_f.EG1 = (uint8_t)enMode;
00366             break;
00367         // ICU channel 2
00368         case MFT_ICU_CH2:
00369             pstcMftIcu->ICSA32_f.EG0 = (uint8_t)enMode;
00370             break;
00371         // ICU channel 3
00372         case MFT_ICU_CH3:
00373             pstcMftIcu->ICSA32_f.EG1 = (uint8_t)enMode;
00374             break;
00375         // ICU channel number error
00376         default:
00377             return ErrorInvalidParameter;
00378     }
00379     return Ok;
00380 }
00381 
00382 #if (PDL_INTERRUPT_ENABLE_MFT0_ICU == PDL_ON) || \
00383     (PDL_INTERRUPT_ENABLE_MFT1_ICU == PDL_ON) || \
00384     (PDL_INTERRUPT_ENABLE_MFT2_ICU == PDL_ON)
00385 
00401 en_result_t Mft_Icu_EnableInt( volatile stc_mftn_icu_t*pstcMftIcu, uint8_t u8Ch, 
00402                                func_ptr_t pfnCallback)
00403 {
00404     // Pointer to internal data
00405     stc_mft_icu_intern_data_t* pstcMftIcuInternData ;  
00406     volatile stc_mftn_icu_t* pstcOrgMftIcu = pstcMftIcu;
00407 
00408     // Check for NULL pointer and channel parameter
00409     boolean_t bAvoidSideEffects  = ((NULL == pstcMftIcu) ? 1u : 0u);
00410     bAvoidSideEffects |= ((u8Ch > MFT_ICU_CHx_MAX) ? 1u : 0u);
00411     bAvoidSideEffects |= ((NULL == pfnCallback) ? 1u : 0u);
00412     if (bAvoidSideEffects)
00413     {
00414         return ErrorInvalidParameter ;
00415     }
00416 
00417     // Get pointer to internal data structure
00418     pstcMftIcuInternData = MftIcuGetInternDataPtr( pstcOrgMftIcu );
00419     
00420     switch (u8Ch)
00421     {
00422         // ICU channel 0
00423         case MFT_ICU_CH0:
00424             pstcMftIcuInternData->pfnIcu0Callback = pfnCallback;
00425             pstcMftIcu->ICSA10_f.ICE0 = 1u;
00426             break;
00427         // ICU channel 1
00428         case MFT_ICU_CH1:
00429             pstcMftIcuInternData->pfnIcu1Callback = pfnCallback;
00430             pstcMftIcu->ICSA10_f.ICE1 = 1u;
00431             break;
00432         // ICU channel 2
00433         case MFT_ICU_CH2:
00434             pstcMftIcuInternData->pfnIcu2Callback = pfnCallback;
00435             pstcMftIcu->ICSA32_f.ICE0 = 1u;
00436             break;
00437         // ICU channel 3
00438         case MFT_ICU_CH3:
00439             pstcMftIcuInternData->pfnIcu3Callback = pfnCallback;
00440             pstcMftIcu->ICSA32_f.ICE1 = 1u;
00441             break;
00442         // ICU channel number error
00443         default:
00444             return ErrorInvalidParameter;
00445     }
00446 
00447     // initialize interrupt
00448     Mft_Icu_InitIrq(pstcOrgMftIcu);
00449     return Ok;
00450 }
00451 
00467 en_result_t Mft_Icu_DisableInt( volatile stc_mftn_icu_t*pstcMftIcu, uint8_t u8Ch)
00468 {
00469     // Pointer to internal data
00470     stc_mft_icu_intern_data_t* pstcMftIcuInternData ;  
00471     volatile stc_mftn_icu_t* pstcOrgMftIcu = pstcMftIcu;
00472 
00473     // Check for NULL pointer and channel parameter
00474     boolean_t bAvoidSideEffects  = ((NULL == pstcMftIcu) ? 1u : 0u);
00475               bAvoidSideEffects |= ((u8Ch > MFT_ICU_CHx_MAX) ? 1u : 0u);
00476     if (bAvoidSideEffects)
00477     {
00478         return ErrorInvalidParameter ;
00479     }
00480 
00481     // Get pointer to internal data structure
00482     pstcMftIcuInternData = MftIcuGetInternDataPtr( pstcOrgMftIcu );
00483     // Dis-register callback function and disable interrupt operation
00484     switch (u8Ch)
00485     {
00486         // ICU channel 0
00487         case MFT_ICU_CH0:
00488             pstcMftIcuInternData->pfnIcu0Callback = NULL;
00489             pstcMftIcu->ICSA10_f.ICE0 = 0u;
00490             break;
00491         // ICU channel 1
00492         case MFT_ICU_CH1:
00493             pstcMftIcuInternData->pfnIcu1Callback = NULL;
00494             pstcMftIcu->ICSA10_f.ICE1 = 0u;
00495             break;
00496         // ICU channel 2
00497         case MFT_ICU_CH2:
00498             pstcMftIcuInternData->pfnIcu2Callback = NULL;
00499             pstcMftIcu->ICSA32_f.ICE0 = 0u;
00500             break;
00501         // ICU channel 3
00502         case MFT_ICU_CH3:
00503             pstcMftIcuInternData->pfnIcu3Callback = NULL;
00504             pstcMftIcu->ICSA32_f.ICE1 = 0u;
00505             break;
00506         // ICU channel number error
00507         default:
00508             return ErrorInvalidParameter;
00509     }
00510    
00511     Mft_Icu_DeInitIrq(pstcOrgMftIcu);
00512     return Ok;
00513 }
00514 
00515 #endif
00516 
00529 en_int_flag_t Mft_Icu_GetIntFlag(volatile stc_mftn_icu_t *pstcMftIcu, uint8_t u8Ch)
00530 {
00531     en_int_flag_t enIntFlagBuf;
00532 
00533     // Read interrupt flag
00534     switch (u8Ch)
00535     {
00536         // ICU channel 0
00537         case MFT_ICU_CH0:
00538             (pstcMftIcu->ICSA10_f.ICP0 == 1) ? (enIntFlagBuf = PdlSet) : (enIntFlagBuf = PdlClr);
00539             break;
00540         // ICU channel 1
00541         case MFT_ICU_CH1:
00542             (pstcMftIcu->ICSA10_f.ICP1 == 1) ? (enIntFlagBuf = PdlSet) : (enIntFlagBuf = PdlClr);
00543             break;
00544         // ICU channel 2
00545         case MFT_ICU_CH2:         
00546             (pstcMftIcu->ICSA32_f.ICP0 == 1) ? (enIntFlagBuf = PdlSet) : (enIntFlagBuf = PdlClr);
00547             break;
00548         // ICU channel 3
00549         case MFT_ICU_CH3:          
00550             (pstcMftIcu->ICSA32_f.ICP1 == 1) ? (enIntFlagBuf = PdlSet) : (enIntFlagBuf = PdlClr);
00551             break;
00552         // ICU channel number error
00553         default:
00554             break;
00555     }
00556     // return interrupt flag
00557     return enIntFlagBuf;
00558 }
00574 en_result_t Mft_Icu_ClrIntFlag( volatile stc_mftn_icu_t *pstcMftIcu, uint8_t u8Ch)
00575 {
00576     // Check for NULL pointer and channel parameter
00577     boolean_t bAvoidSideEffects  = ((NULL == pstcMftIcu) ? 1u : 0u);
00578               bAvoidSideEffects |= ((u8Ch > MFT_ICU_CHx_MAX) ? 1u : 0u);
00579     if (bAvoidSideEffects)
00580     {
00581         return ErrorInvalidParameter ;
00582     }
00583 
00584     // Clear interrupt flag
00585     switch (u8Ch)
00586     {
00587         // ICU channel 0
00588         case MFT_ICU_CH0:
00589             pstcMftIcu->ICSA10_f.ICP0 = 0u;
00590             break;
00591         // ICU channel 1
00592         case MFT_ICU_CH1:
00593             pstcMftIcu->ICSA10_f.ICP1 = 0u;
00594             break;
00595         // ICU channel 2
00596         case MFT_ICU_CH2:
00597             pstcMftIcu->ICSA32_f.ICP0 = 0u;
00598             break;
00599         // ICU channel 3
00600         case MFT_ICU_CH3:
00601             pstcMftIcu->ICSA32_f.ICP1 = 0u;
00602             break;
00603         // ICU channel number error
00604         default:
00605             return ErrorInvalidParameter;
00606     }
00607     
00608     return Ok;
00609 }
00620 en_mft_icu_edge_t Mft_Icu_GetLastEdge( volatile stc_mftn_icu_t *pstcMftIcu, uint8_t u8Ch)
00621 {
00622     en_mft_icu_edge_t enEdgeTypeBuf;
00623 
00624     // Read last Edge type
00625     switch (u8Ch)
00626     {
00627         // ICU channel 0
00628         case MFT_ICU_CH0:
00629             (pstcMftIcu->ICSB10_f.IEI0 == 1) ? (enEdgeTypeBuf = IcuRisingEdge) : (enEdgeTypeBuf = IcuFallingEdge);
00630             break;
00631         // ICU channel 1
00632         case MFT_ICU_CH1:
00633             (pstcMftIcu->ICSB10_f.IEI1 == 1) ? (enEdgeTypeBuf = IcuRisingEdge) : (enEdgeTypeBuf = IcuFallingEdge);
00634             break;
00635         // ICU channel 2
00636         case MFT_ICU_CH2:
00637             (pstcMftIcu->ICSB32_f.IEI0 == 1) ? (enEdgeTypeBuf = IcuRisingEdge) : (enEdgeTypeBuf = IcuFallingEdge);
00638             break;
00639         // ICU channel 3
00640         case MFT_ICU_CH3:           
00641             (pstcMftIcu->ICSB32_f.IEI1 == 1) ? (enEdgeTypeBuf = IcuRisingEdge) : (enEdgeTypeBuf = IcuFallingEdge);      
00642             break;
00643         // ICU channel number error
00644         default:
00645             break;
00646     }
00647     // return last edge type
00648     return enEdgeTypeBuf;
00649 }
00660 uint16_t Mft_Icu_GetCaptureData(volatile stc_mftn_icu_t *pstcMftIcu, uint8_t u8Ch)
00661 {
00662     uint16_t u16CaptureVal;
00663 
00664     // Read captured value
00665     switch (u8Ch)
00666     {
00667         // ICU channel 0
00668         case MFT_ICU_CH0:
00669             u16CaptureVal = (uint16_t)(pstcMftIcu->ICCP0);
00670             break;
00671         // ICU channel 1
00672         case MFT_ICU_CH1:
00673             u16CaptureVal = (uint16_t)(pstcMftIcu->ICCP1);
00674             break;
00675         // ICU channel 2
00676         case MFT_ICU_CH2:
00677             u16CaptureVal = (uint16_t)(pstcMftIcu->ICCP2);
00678             break;
00679         // ICU channel 3
00680         case MFT_ICU_CH3:
00681             u16CaptureVal = (uint16_t)(pstcMftIcu->ICCP3);
00682             break;
00683         // ICU channel number error
00684         default:
00685             break;
00686     }
00687     
00688     return (uint16_t)u16CaptureVal;
00689 }
00690 
00692 
00693 #endif // #if (defined(PDL_PERIPHERAL_MFT_ICU_ACTIVE))