libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/lpc54114-lite/Libraries/devices/LPC54114/drivers/fsl_sctimer.h

835 lines
33 KiB
C
Raw Normal View History

[bsp]add bsp lpc54114-lite
2018-12-05 11:44:53 +08:00
/*
* The Clear BSD License
* Copyright (c) 2016, Freescale Semiconductor, Inc.
* Copyright 2016-2017 NXP
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted (subject to the limitations in the disclaimer below) provided
* that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice, this list
* of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice, this
* list of conditions and the following disclaimer in the documentation and/or
* other materials provided with the distribution.
*
* o Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS LICENSE.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _FSL_SCTIMER_H_
#define _FSL_SCTIMER_H_
#include "fsl_common.h"
/*!
* @addtogroup sctimer
* @{
*/
/*! @file */
/*******************************************************************************
* Definitions
******************************************************************************/
/*! @name Driver version */
/*@{*/
#define FSL_SCTIMER_DRIVER_VERSION (MAKE_VERSION(2, 0, 0)) /*!< Version 2.0.0 */
/*@}*/
/*! @brief SCTimer PWM operation modes */
typedef enum _sctimer_pwm_mode
{
kSCTIMER_EdgeAlignedPwm = 0U, /*!< Edge-aligned PWM */
kSCTIMER_CenterAlignedPwm /*!< Center-aligned PWM */
} sctimer_pwm_mode_t;
/*! @brief SCTimer counters when working as two independent 16-bit counters */
typedef enum _sctimer_counter
{
kSCTIMER_Counter_L = 0U, /*!< Counter L */
kSCTIMER_Counter_H /*!< Counter H */
} sctimer_counter_t;
/*! @brief List of SCTimer input pins */
typedef enum _sctimer_input
{
kSCTIMER_Input_0 = 0U, /*!< SCTIMER input 0 */
kSCTIMER_Input_1, /*!< SCTIMER input 1 */
kSCTIMER_Input_2, /*!< SCTIMER input 2 */
kSCTIMER_Input_3, /*!< SCTIMER input 3 */
kSCTIMER_Input_4, /*!< SCTIMER input 4 */
kSCTIMER_Input_5, /*!< SCTIMER input 5 */
kSCTIMER_Input_6, /*!< SCTIMER input 6 */
kSCTIMER_Input_7 /*!< SCTIMER input 7 */
} sctimer_input_t;
/*! @brief List of SCTimer output pins */
typedef enum _sctimer_out
{
kSCTIMER_Out_0 = 0U, /*!< SCTIMER output 0*/
kSCTIMER_Out_1, /*!< SCTIMER output 1 */
kSCTIMER_Out_2, /*!< SCTIMER output 2 */
kSCTIMER_Out_3, /*!< SCTIMER output 3 */
kSCTIMER_Out_4, /*!< SCTIMER output 4 */
kSCTIMER_Out_5, /*!< SCTIMER output 5 */
kSCTIMER_Out_6, /*!< SCTIMER output 6 */
kSCTIMER_Out_7, /*!< SCTIMER output 7 */
kSCTIMER_Out_8, /*!< SCTIMER output 8 */
kSCTIMER_Out_9 /*!< SCTIMER output 9 */
} sctimer_out_t;
/*! @brief SCTimer PWM output pulse mode: high-true, low-true or no output */
typedef enum _sctimer_pwm_level_select
{
kSCTIMER_LowTrue = 0U, /*!< Low true pulses */
kSCTIMER_HighTrue /*!< High true pulses */
} sctimer_pwm_level_select_t;
/*! @brief Options to configure a SCTimer PWM signal */
typedef struct _sctimer_pwm_signal_param
{
sctimer_out_t output; /*!< The output pin to use to generate the PWM signal */
sctimer_pwm_level_select_t level; /*!< PWM output active level select. */
uint8_t dutyCyclePercent; /*!< PWM pulse width, value should be between 1 to 100
100 = always active signal (100% duty cycle).*/
} sctimer_pwm_signal_param_t;
/*! @brief SCTimer clock mode options */
typedef enum _sctimer_clock_mode
{
kSCTIMER_System_ClockMode = 0U, /*!< System Clock Mode */
kSCTIMER_Sampled_ClockMode, /*!< Sampled System Clock Mode */
kSCTIMER_Input_ClockMode, /*!< SCT Input Clock Mode */
kSCTIMER_Asynchronous_ClockMode /*!< Asynchronous Mode */
} sctimer_clock_mode_t;
/*! @brief SCTimer clock select options */
typedef enum _sctimer_clock_select
{
kSCTIMER_Clock_On_Rise_Input_0 = 0U, /*!< Rising edges on input 0 */
kSCTIMER_Clock_On_Fall_Input_0, /*!< Falling edges on input 0 */
kSCTIMER_Clock_On_Rise_Input_1, /*!< Rising edges on input 1 */
kSCTIMER_Clock_On_Fall_Input_1, /*!< Falling edges on input 1 */
kSCTIMER_Clock_On_Rise_Input_2, /*!< Rising edges on input 2 */
kSCTIMER_Clock_On_Fall_Input_2, /*!< Falling edges on input 2 */
kSCTIMER_Clock_On_Rise_Input_3, /*!< Rising edges on input 3 */
kSCTIMER_Clock_On_Fall_Input_3, /*!< Falling edges on input 3 */
kSCTIMER_Clock_On_Rise_Input_4, /*!< Rising edges on input 4 */
kSCTIMER_Clock_On_Fall_Input_4, /*!< Falling edges on input 4 */
kSCTIMER_Clock_On_Rise_Input_5, /*!< Rising edges on input 5 */
kSCTIMER_Clock_On_Fall_Input_5, /*!< Falling edges on input 5 */
kSCTIMER_Clock_On_Rise_Input_6, /*!< Rising edges on input 6 */
kSCTIMER_Clock_On_Fall_Input_6, /*!< Falling edges on input 6 */
kSCTIMER_Clock_On_Rise_Input_7, /*!< Rising edges on input 7 */
kSCTIMER_Clock_On_Fall_Input_7 /*!< Falling edges on input 7 */
} sctimer_clock_select_t;
/*!
* @brief SCTimer output conflict resolution options.
*
* Specifies what action should be taken if multiple events dictate that a given output should be
* both set and cleared at the same time
*/
typedef enum _sctimer_conflict_resolution
{
kSCTIMER_ResolveNone = 0U, /*!< No change */
kSCTIMER_ResolveSet, /*!< Set output */
kSCTIMER_ResolveClear, /*!< Clear output */
kSCTIMER_ResolveToggle /*!< Toggle output */
} sctimer_conflict_resolution_t;
/*! @brief List of SCTimer event types */
typedef enum _sctimer_event
{
kSCTIMER_InputLowOrMatchEvent =
(0 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (0 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (0 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_InputRiseOrMatchEvent =
(0 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (1 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (0 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_InputFallOrMatchEvent =
(0 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (2 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (0 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_InputHighOrMatchEvent =
(0 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (3 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (0 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_MatchEventOnly =
(1 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (0 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (0 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_InputLowEvent =
(2 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (0 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (0 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_InputRiseEvent =
(2 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (1 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (0 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_InputFallEvent =
(2 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (2 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (0 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_InputHighEvent =
(2 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (3 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (0 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_InputLowAndMatchEvent =
(3 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (0 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (0 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_InputRiseAndMatchEvent =
(3 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (1 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (0 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_InputFallAndMatchEvent =
(3 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (2 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (0 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_InputHighAndMatchEvent =
(3 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (3 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (0 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_OutputLowOrMatchEvent =
(0 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (0 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (1 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_OutputRiseOrMatchEvent =
(0 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (1 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (1 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_OutputFallOrMatchEvent =
(0 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (2 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (1 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_OutputHighOrMatchEvent =
(0 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (3 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (1 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_OutputLowEvent =
(2 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (0 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (1 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_OutputRiseEvent =
(2 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (1 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (1 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_OutputFallEvent =
(2 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (2 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (1 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_OutputHighEvent =
(2 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (3 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (1 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_OutputLowAndMatchEvent =
(3 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (0 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (1 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_OutputRiseAndMatchEvent =
(3 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (1 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (1 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_OutputFallAndMatchEvent =
(3 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (2 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (1 << SCT_EVENT_CTRL_OUTSEL_SHIFT),
kSCTIMER_OutputHighAndMatchEvent =
(3 << SCT_EVENT_CTRL_COMBMODE_SHIFT) + (3 << SCT_EVENT_CTRL_IOCOND_SHIFT) + (1 << SCT_EVENT_CTRL_OUTSEL_SHIFT)
} sctimer_event_t;
/*! @brief SCTimer callback typedef. */
typedef void (*sctimer_event_callback_t)(void);
/*! @brief List of SCTimer interrupts */
typedef enum _sctimer_interrupt_enable
{
kSCTIMER_Event0InterruptEnable = (1U << 0), /*!< Event 0 interrupt */
kSCTIMER_Event1InterruptEnable = (1U << 1), /*!< Event 1 interrupt */
kSCTIMER_Event2InterruptEnable = (1U << 2), /*!< Event 2 interrupt */
kSCTIMER_Event3InterruptEnable = (1U << 3), /*!< Event 3 interrupt */
kSCTIMER_Event4InterruptEnable = (1U << 4), /*!< Event 4 interrupt */
kSCTIMER_Event5InterruptEnable = (1U << 5), /*!< Event 5 interrupt */
kSCTIMER_Event6InterruptEnable = (1U << 6), /*!< Event 6 interrupt */
kSCTIMER_Event7InterruptEnable = (1U << 7), /*!< Event 7 interrupt */
kSCTIMER_Event8InterruptEnable = (1U << 8), /*!< Event 8 interrupt */
kSCTIMER_Event9InterruptEnable = (1U << 9), /*!< Event 9 interrupt */
kSCTIMER_Event10InterruptEnable = (1U << 10), /*!< Event 10 interrupt */
kSCTIMER_Event11InterruptEnable = (1U << 11), /*!< Event 11 interrupt */
kSCTIMER_Event12InterruptEnable = (1U << 12), /*!< Event 12 interrupt */
} sctimer_interrupt_enable_t;
/*! @brief List of SCTimer flags */
typedef enum _sctimer_status_flags
{
kSCTIMER_Event0Flag = (1U << 0), /*!< Event 0 Flag */
kSCTIMER_Event1Flag = (1U << 1), /*!< Event 1 Flag */
kSCTIMER_Event2Flag = (1U << 2), /*!< Event 2 Flag */
kSCTIMER_Event3Flag = (1U << 3), /*!< Event 3 Flag */
kSCTIMER_Event4Flag = (1U << 4), /*!< Event 4 Flag */
kSCTIMER_Event5Flag = (1U << 5), /*!< Event 5 Flag */
kSCTIMER_Event6Flag = (1U << 6), /*!< Event 6 Flag */
kSCTIMER_Event7Flag = (1U << 7), /*!< Event 7 Flag */
kSCTIMER_Event8Flag = (1U << 8), /*!< Event 8 Flag */
kSCTIMER_Event9Flag = (1U << 9), /*!< Event 9 Flag */
kSCTIMER_Event10Flag = (1U << 10), /*!< Event 10 Flag */
kSCTIMER_Event11Flag = (1U << 11), /*!< Event 11 Flag */
kSCTIMER_Event12Flag = (1U << 12), /*!< Event 12 Flag */
kSCTIMER_BusErrorLFlag =
(1U << SCT_CONFLAG_BUSERRL_SHIFT), /*!< Bus error due to write when L counter was not halted */
kSCTIMER_BusErrorHFlag =
(1U << SCT_CONFLAG_BUSERRH_SHIFT) /*!< Bus error due to write when H counter was not halted */
} sctimer_status_flags_t;
/*!
* @brief SCTimer configuration structure
*
* This structure holds the configuration settings for the SCTimer peripheral. To initialize this
* structure to reasonable defaults, call the SCTMR_GetDefaultConfig() function and pass a
* pointer to the configuration structure instance.
*
* The configuration structure can be made constant so as to reside in flash.
*/
typedef struct _sctimer_config
{
bool enableCounterUnify; /*!< true: SCT operates as a unified 32-bit counter;
false: SCT operates as two 16-bit counters */
sctimer_clock_mode_t clockMode; /*!< SCT clock mode value */
sctimer_clock_select_t clockSelect; /*!< SCT clock select value */
bool enableBidirection_l; /*!< true: Up-down count mode for the L or unified counter
false: Up count mode only for the L or unified counter */
bool enableBidirection_h; /*!< true: Up-down count mode for the H or unified counter
false: Up count mode only for the H or unified counter.
This field is used only if the enableCounterUnify is set
to false */
uint8_t prescale_l; /*!< Prescale value to produce the L or unified counter clock */
uint8_t prescale_h; /*!< Prescale value to produce the H counter clock.
This field is used only if the enableCounterUnify is set
to false */
uint8_t outInitState; /*!< Defines the initial output value */
} sctimer_config_t;
/*******************************************************************************
* API
******************************************************************************/
#if defined(__cplusplus)
extern "C" {
#endif
/*!
* @name Initialization and deinitialization
* @{
*/
/*!
* @brief Ungates the SCTimer clock and configures the peripheral for basic operation.
*
* @note This API should be called at the beginning of the application using the SCTimer driver.
*
* @param base SCTimer peripheral base address
* @param config Pointer to the user configuration structure.
*
* @return kStatus_Success indicates success; Else indicates failure.
*/
status_t SCTIMER_Init(SCT_Type *base, const sctimer_config_t *config);
/*!
* @brief Gates the SCTimer clock.
*
* @param base SCTimer peripheral base address
*/
void SCTIMER_Deinit(SCT_Type *base);
/*!
* @brief Fills in the SCTimer configuration structure with the default settings.
*
* The default values are:
* @code
* config->enableCounterUnify = true;
* config->clockMode = kSCTIMER_System_ClockMode;
* config->clockSelect = kSCTIMER_Clock_On_Rise_Input_0;
* config->enableBidirection_l = false;
* config->enableBidirection_h = false;
* config->prescale_l = 0;
* config->prescale_h = 0;
* config->outInitState = 0;
* @endcode
* @param config Pointer to the user configuration structure.
*/
void SCTIMER_GetDefaultConfig(sctimer_config_t *config);
/*! @}*/
/*!
* @name PWM setup operations
* @{
*/
/*!
* @brief Configures the PWM signal parameters.
*
* Call this function to configure the PWM signal period, mode, duty cycle, and edge. This
* function will create 2 events; one of the events will trigger on match with the pulse value
* and the other will trigger when the counter matches the PWM period. The PWM period event is
* also used as a limit event to reset the counter or change direction. Both events are enabled
* for the same state. The state number can be retrieved by calling the function
* SCTIMER_GetCurrentStateNumber().
* The counter is set to operate as one 32-bit counter (unify bit is set to 1).
* The counter operates in bi-directional mode when generating a center-aligned PWM.
*
* @note When setting PWM output from multiple output pins, they all should use the same PWM mode
* i.e all PWM's should be either edge-aligned or center-aligned.
* When using this API, the PWM signal frequency of all the initialized channels must be the same.
* Otherwise all the initialized channels' PWM signal frequency is equal to the last call to the
* API's pwmFreq_Hz.
*
* @param base SCTimer peripheral base address
* @param pwmParams PWM parameters to configure the output
* @param mode PWM operation mode, options available in enumeration ::sctimer_pwm_mode_t
* @param pwmFreq_Hz PWM signal frequency in Hz
* @param srcClock_Hz SCTimer counter clock in Hz
* @param event Pointer to a variable where the PWM period event number is stored
*
* @return kStatus_Success on success
* kStatus_Fail If we have hit the limit in terms of number of events created or if
* an incorrect PWM dutycylce is passed in.
*/
status_t SCTIMER_SetupPwm(SCT_Type *base,
const sctimer_pwm_signal_param_t *pwmParams,
sctimer_pwm_mode_t mode,
uint32_t pwmFreq_Hz,
uint32_t srcClock_Hz,
uint32_t *event);
/*!
* @brief Updates the duty cycle of an active PWM signal.
*
* @param base SCTimer peripheral base address
* @param output The output to configure
* @param dutyCyclePercent New PWM pulse width; the value should be between 1 to 100
* @param event Event number associated with this PWM signal. This was returned to the user by the
* function SCTIMER_SetupPwm().
*/
void SCTIMER_UpdatePwmDutycycle(SCT_Type *base, sctimer_out_t output, uint8_t dutyCyclePercent, uint32_t event);
/*!
* @name Interrupt Interface
* @{
*/
/*!
* @brief Enables the selected SCTimer interrupts.
*
* @param base SCTimer peripheral base address
* @param mask The interrupts to enable. This is a logical OR of members of the
* enumeration ::sctimer_interrupt_enable_t
*/
static inline void SCTIMER_EnableInterrupts(SCT_Type *base, uint32_t mask)
{
base->EVEN |= mask;
}
/*!
* @brief Disables the selected SCTimer interrupts.
*
* @param base SCTimer peripheral base address
* @param mask The interrupts to enable. This is a logical OR of members of the
* enumeration ::sctimer_interrupt_enable_t
*/
static inline void SCTIMER_DisableInterrupts(SCT_Type *base, uint32_t mask)
{
base->EVEN &= ~mask;
}
/*!
* @brief Gets the enabled SCTimer interrupts.
*
* @param base SCTimer peripheral base address
*
* @return The enabled interrupts. This is the logical OR of members of the
* enumeration ::sctimer_interrupt_enable_t
*/
static inline uint32_t SCTIMER_GetEnabledInterrupts(SCT_Type *base)
{
return (base->EVEN & 0xFFFFU);
}
/*! @}*/
/*!
* @name Status Interface
* @{
*/
/*!
* @brief Gets the SCTimer status flags.
*
* @param base SCTimer peripheral base address
*
* @return The status flags. This is the logical OR of members of the
* enumeration ::sctimer_status_flags_t
*/
static inline uint32_t SCTIMER_GetStatusFlags(SCT_Type *base)
{
uint32_t statusFlags = 0;
/* Add the recorded events */
statusFlags = (base->EVFLAG & 0xFFFFU);
/* Add bus error flags */
statusFlags |= (base->CONFLAG & (SCT_CONFLAG_BUSERRL_MASK | SCT_CONFLAG_BUSERRH_MASK));
return statusFlags;
}
/*!
* @brief Clears the SCTimer status flags.
*
* @param base SCTimer peripheral base address
* @param mask The status flags to clear. This is a logical OR of members of the
* enumeration ::sctimer_status_flags_t
*/
static inline void SCTIMER_ClearStatusFlags(SCT_Type *base, uint32_t mask)
{
/* Write to the flag registers */
base->EVFLAG = (mask & 0xFFFFU);
base->CONFLAG = (mask & (SCT_CONFLAG_BUSERRL_MASK | SCT_CONFLAG_BUSERRH_MASK));
}
/*! @}*/
/*!
* @name Counter Start and Stop
* @{
*/
/*!
* @brief Starts the SCTimer counter.
*
* @param base SCTimer peripheral base address
* @param countertoStart SCTimer counter to start; if unify mode is set then function always
* writes to HALT_L bit
*/
static inline void SCTIMER_StartTimer(SCT_Type *base, sctimer_counter_t countertoStart)
{
/* Clear HALT_L bit if counter is operating in 32-bit mode or user wants to start L counter */
if ((base->CONFIG & SCT_CONFIG_UNIFY_MASK) || (countertoStart == kSCTIMER_Counter_L))
{
base->CTRL &= ~(SCT_CTRL_HALT_L_MASK);
}
else
{
/* Start H counter */
base->CTRL &= ~(SCT_CTRL_HALT_H_MASK);
}
}
/*!
* @brief Halts the SCTimer counter.
*
* @param base SCTimer peripheral base address
* @param countertoStop SCTimer counter to stop; if unify mode is set then function always
* writes to HALT_L bit
*/
static inline void SCTIMER_StopTimer(SCT_Type *base, sctimer_counter_t countertoStop)
{
/* Set HALT_L bit if counter is operating in 32-bit mode or user wants to stop L counter */
if ((base->CONFIG & SCT_CONFIG_UNIFY_MASK) || (countertoStop == kSCTIMER_Counter_L))
{
base->CTRL |= (SCT_CTRL_HALT_L_MASK);
}
else
{
/* Stop H counter */
base->CTRL |= (SCT_CTRL_HALT_H_MASK);
}
}
/*! @}*/
/*!
* @name Functions to create a new event and manage the state logic
* @{
*/
/*!
* @brief Create an event that is triggered on a match or IO and schedule in current state.
*
* This function will configure an event using the options provided by the user. If the event type uses
* the counter match, then the function will set the user provided match value into a match register
* and put this match register number into the event control register.
* The event is enabled for the current state and the event number is increased by one at the end.
* The function returns the event number; this event number can be used to configure actions to be
* done when this event is triggered.
*
* @param base SCTimer peripheral base address
* @param howToMonitor Event type; options are available in the enumeration ::sctimer_interrupt_enable_t
* @param matchValue The match value that will be programmed to a match register
* @param whichIO The input or output that will be involved in event triggering. This field
* is ignored if the event type is "match only"
* @param whichCounter SCTimer counter to use when operating in 16-bit mode. In 32-bit mode, this
* field has no meaning as we have only 1 unified counter; hence ignored.
* @param event Pointer to a variable where the new event number is stored
*
* @return kStatus_Success on success
* kStatus_Error if we have hit the limit in terms of number of events created or
if we have reached the limit in terms of number of match registers
*/
status_t SCTIMER_CreateAndScheduleEvent(SCT_Type *base,
sctimer_event_t howToMonitor,
uint32_t matchValue,
uint32_t whichIO,
sctimer_counter_t whichCounter,
uint32_t *event);
/*!
* @brief Enable an event in the current state.
*
* This function will allow the event passed in to trigger in the current state. The event must
* be created earlier by either calling the function SCTIMER_SetupPwm() or function
* SCTIMER_CreateAndScheduleEvent() .
*
* @param base SCTimer peripheral base address
* @param event Event number to enable in the current state
*
*/
void SCTIMER_ScheduleEvent(SCT_Type *base, uint32_t event);
/*!
* @brief Increase the state by 1
*
* All future events created by calling the function SCTIMER_ScheduleEvent() will be enabled in this new
* state.
*
* @param base SCTimer peripheral base address
*
* @return kStatus_Success on success
* kStatus_Error if we have hit the limit in terms of states used
*/
status_t SCTIMER_IncreaseState(SCT_Type *base);
/*!
* @brief Provides the current state
*
* User can use this to set the next state by calling the function SCTIMER_SetupNextStateAction().
*
* @param base SCTimer peripheral base address
*
* @return The current state
*/
uint32_t SCTIMER_GetCurrentState(SCT_Type *base);
/*! @}*/
/*!
* @name Actions to take in response to an event
* @{
*/
/*!
* @brief Setup capture of the counter value on trigger of a selected event
*
* @param base SCTimer peripheral base address
* @param whichCounter SCTimer counter to use when operating in 16-bit mode. In 32-bit mode, this
* field has no meaning as only the Counter_L bits are used.
* @param captureRegister Pointer to a variable where the capture register number will be returned. User
* can read the captured value from this register when the specified event is triggered.
* @param event Event number that will trigger the capture
*
* @return kStatus_Success on success
* kStatus_Error if we have hit the limit in terms of number of match/capture registers available
*/
status_t SCTIMER_SetupCaptureAction(SCT_Type *base,
sctimer_counter_t whichCounter,
uint32_t *captureRegister,
uint32_t event);
/*!
* @brief Receive noticification when the event trigger an interrupt.
*
* If the interrupt for the event is enabled by the user, then a callback can be registered
* which will be invoked when the event is triggered
*
* @param base SCTimer peripheral base address
* @param event Event number that will trigger the interrupt
* @param callback Function to invoke when the event is triggered
*/
void SCTIMER_SetCallback(SCT_Type *base, sctimer_event_callback_t callback, uint32_t event);
/*!
* @brief Transition to the specified state.
*
* This transition will be triggered by the event number that is passed in by the user.
*
* @param base SCTimer peripheral base address
* @param nextState The next state SCTimer will transition to
* @param event Event number that will trigger the state transition
*/
static inline void SCTIMER_SetupNextStateAction(SCT_Type *base, uint32_t nextState, uint32_t event)
{
uint32_t reg = base->EVENT[event].CTRL;
reg &= ~(SCT_EVENT_CTRL_STATEV_MASK);
/* Load the STATEV value when the event occurs to be the next state */
reg |= SCT_EVENT_CTRL_STATEV(nextState) | SCT_EVENT_CTRL_STATELD_MASK;
base->EVENT[event].CTRL = reg;
}
/*!
* @brief Set the Output.
*
* This output will be set when the event number that is passed in by the user is triggered.
*
* @param base SCTimer peripheral base address
* @param whichIO The output to set
* @param event Event number that will trigger the output change
*/
static inline void SCTIMER_SetupOutputSetAction(SCT_Type *base, uint32_t whichIO, uint32_t event)
{
assert(whichIO < FSL_FEATURE_SCT_NUMBER_OF_OUTPUTS);
base->OUT[whichIO].SET |= (1U << event);
}
/*!
* @brief Clear the Output.
*
* This output will be cleared when the event number that is passed in by the user is triggered.
*
* @param base SCTimer peripheral base address
* @param whichIO The output to clear
* @param event Event number that will trigger the output change
*/
static inline void SCTIMER_SetupOutputClearAction(SCT_Type *base, uint32_t whichIO, uint32_t event)
{
assert(whichIO < FSL_FEATURE_SCT_NUMBER_OF_OUTPUTS);
base->OUT[whichIO].CLR |= (1U << event);
}
/*!
* @brief Toggle the output level.
*
* This change in the output level is triggered by the event number that is passed in by the user.
*
* @param base SCTimer peripheral base address
* @param whichIO The output to toggle
* @param event Event number that will trigger the output change
*/
void SCTIMER_SetupOutputToggleAction(SCT_Type *base, uint32_t whichIO, uint32_t event);
/*!
* @brief Limit the running counter.
*
* The counter is limited when the event number that is passed in by the user is triggered.
*
* @param base SCTimer peripheral base address
* @param whichCounter SCTimer counter to use when operating in 16-bit mode. In 32-bit mode, this
* field has no meaning as only the Counter_L bits are used.
* @param event Event number that will trigger the counter to be limited
*/
static inline void SCTIMER_SetupCounterLimitAction(SCT_Type *base, sctimer_counter_t whichCounter, uint32_t event)
{
/* Use Counter_L bits if counter is operating in 32-bit mode or user wants to setup the L counter */
if ((base->CONFIG & SCT_CONFIG_UNIFY_MASK) || (whichCounter == kSCTIMER_Counter_L))
{
base->LIMIT |= SCT_LIMIT_LIMMSK_L(1U << event);
}
else
{
base->LIMIT |= SCT_LIMIT_LIMMSK_H(1U << event);
}
}
/*!
* @brief Stop the running counter.
*
* The counter is stopped when the event number that is passed in by the user is triggered.
*
* @param base SCTimer peripheral base address
* @param whichCounter SCTimer counter to use when operating in 16-bit mode. In 32-bit mode, this
* field has no meaning as only the Counter_L bits are used.
* @param event Event number that will trigger the counter to be stopped
*/
static inline void SCTIMER_SetupCounterStopAction(SCT_Type *base, sctimer_counter_t whichCounter, uint32_t event)
{
/* Use Counter_L bits if counter is operating in 32-bit mode or user wants to setup the L counter */
if ((base->CONFIG & SCT_CONFIG_UNIFY_MASK) || (whichCounter == kSCTIMER_Counter_L))
{
base->STOP |= SCT_STOP_STOPMSK_L(1U << event);
}
else
{
base->STOP |= SCT_STOP_STOPMSK_H(1U << event);
}
}
/*!
* @brief Re-start the stopped counter.
*
* The counter will re-start when the event number that is passed in by the user is triggered.
*
* @param base SCTimer peripheral base address
* @param whichCounter SCTimer counter to use when operating in 16-bit mode. In 32-bit mode, this
* field has no meaning as only the Counter_L bits are used.
* @param event Event number that will trigger the counter to re-start
*/
static inline void SCTIMER_SetupCounterStartAction(SCT_Type *base, sctimer_counter_t whichCounter, uint32_t event)
{
/* Use Counter_L bits if counter is operating in 32-bit mode or user wants to setup the L counter */
if ((base->CONFIG & SCT_CONFIG_UNIFY_MASK) || (whichCounter == kSCTIMER_Counter_L))
{
base->START |= SCT_START_STARTMSK_L(1U << event);
}
else
{
base->START |= SCT_START_STARTMSK_H(1U << event);
}
}
/*!
* @brief Halt the running counter.
*
* The counter is disabled (halted) when the event number that is passed in by the user is
* triggered. When the counter is halted, all further events are disabled. The HALT condition
* can only be removed by calling the SCTIMER_StartTimer() function.
*
* @param base SCTimer peripheral base address
* @param whichCounter SCTimer counter to use when operating in 16-bit mode. In 32-bit mode, this
* field has no meaning as only the Counter_L bits are used.
* @param event Event number that will trigger the counter to be halted
*/
static inline void SCTIMER_SetupCounterHaltAction(SCT_Type *base, sctimer_counter_t whichCounter, uint32_t event)
{
/* Use Counter_L bits if counter is operating in 32-bit mode or user wants to setup the L counter */
if ((base->CONFIG & SCT_CONFIG_UNIFY_MASK) || (whichCounter == kSCTIMER_Counter_L))
{
base->HALT |= SCT_HALT_HALTMSK_L(1U << event);
}
else
{
base->HALT |= SCT_HALT_HALTMSK_H(1U << event);
}
}
#if !(defined(FSL_FEATURE_SCT_HAS_NO_DMA_REQUEST) && FSL_FEATURE_SCT_HAS_NO_DMA_REQUEST)
/*!
* @brief Generate a DMA request.
*
* DMA request will be triggered by the event number that is passed in by the user.
*
* @param base SCTimer peripheral base address
* @param dmaNumber The DMA request to generate
* @param event Event number that will trigger the DMA request
*/
static inline void SCTIMER_SetupDmaTriggerAction(SCT_Type *base, uint32_t dmaNumber, uint32_t event)
{
if (dmaNumber == 0)
{
base->DMA0REQUEST |= (1U << event);
}
else
{
base->DMA1REQUEST |= (1U << event);
}
}
#endif /* FSL_FEATURE_SCT_HAS_NO_DMA_REQUEST */
/*!
* @brief SCTimer interrupt handler.
*
* @param base SCTimer peripheral base address.
*/
void SCTIMER_EventHandleIRQ(SCT_Type *base);
/*! @}*/
#if defined(__cplusplus)
}
#endif
/*! @}*/
#endif /* _FSL_SCTIMER_H_ */