Elements of the module that are not confined to the scope of the compilation unit. Perfectly corresponds to the module's header file, except the IRQ handlers. More...

Macros
#define	HIERODULE_TIM_HANDLE_IRQ
	Precompiler constant to toggle timer ISR management elements.

#define	HIERODULE_TIM_RESERVED 0
	Precompiler constant to omit the IRQ implementation of a timer.

#define	HIERODULE_TIM_CONVENIENT_IRQ
	Precompiler constant to select timer ISR assignment routines.

Typedefs
typedef void(*	FUNC_POINTER) (void)
	Typedef as for an alias for the void function pointer.

Functions
void	HIERODULE_TIM_SetPeriod (TIM_TypeDef *Timer, double DurationSec)
	Sets the period duration of a timer.

double	HIERODULE_TIM_GetPeriod (TIM_TypeDef *Timer)
	Returns the period duration of a timer in seconds.

void	HIERODULE_TIM_SetFrequency (TIM_TypeDef *Timer, double Frequency_Hz)
	Sets the frequency of a timer.

double	HIERODULE_TIM_GetFrequency (TIM_TypeDef *Timer)
	Returns the frequency of a timer in Hertz.

void	HIERODULE_TIM_ClearCounter (TIM_TypeDef *Timer)
	Clears the counter register of a timer.

void	HIERODULE_TIM_SetRepetition (TIM_TypeDef *Timer, uint32_t Reps)
	Sets the additional period repetitions of a timer.

uint32_t	HIERODULE_TIM_GetRepetition (TIM_TypeDef *Timer)
	Returns the number of additional period repetitions of a timer.

void	HIERODULE_TIM_EnableChannel (TIM_TypeDef *Timer, int8_t Channel)
	Enables the PWM output channel of a timer.

void	HIERODULE_TIM_DisableChannel (TIM_TypeDef *Timer, int8_t Channel)
	Disables the PWM output channel of a timer.

uint32_t	HIERODULE_TIM_IsEnabledChannel (TIM_TypeDef *Timer, int8_t Channel)
	Checks the status of the PWM output channel of a timer.

void	HIERODULE_TIM_EnableMainOutput (TIM_TypeDef *Timer)
	Sets the main output enable bit in the break and dead time register of the timer.

void	HIERODULE_TIM_DisableMainOutput (TIM_TypeDef *Timer)
	Clears the main output enable bit in the break and dead time register of the timer.

void	HIERODULE_TIM_SetDutyCycle (TIM_TypeDef *Timer, uint8_t Channel, double NormalizedDutyCycle)
	Sets the duty cycle of the specified PWM output channel of a timer.

double	HIERODULE_TIM_GetDutyCycle (TIM_TypeDef *Timer, uint8_t Channel)
	Returns the duty cycle of the specified PWM output channel of a timer.

void	HIERODULE_TIM_ClearFlag_UPD (TIM_TypeDef *Timer)
	Clears the update interrupt flag of the timer.

void	HIERODULE_TIM_ClearFlag_CC1 (TIM_TypeDef *Timer)
	Clears the capture compare channel 1 interrupt flag of the timer.

void	HIERODULE_TIM_ClearFlag_CC2 (TIM_TypeDef *Timer)
	Clears the capture compare channel 2 interrupt flag of the timer.

void	HIERODULE_TIM_ClearFlag_CC3 (TIM_TypeDef *Timer)
	Clears the capture compare channel 3 interrupt flag of the timer.

void	HIERODULE_TIM_ClearFlag_CC4 (TIM_TypeDef *Timer)
	Clears the capture compare channel 4 interrupt flag of the timer.

void	HIERODULE_TIM_ClearFlag_BRK (TIM_TypeDef *Timer)
	Clears the break interrupt flag of the timer.

uint32_t	HIERODULE_TIM_IsSetFlag_UPD (TIM_TypeDef *Timer)
	Checks the status of the update interrupt flag of the timer.

uint32_t	HIERODULE_TIM_IsSetFlag_CC1 (TIM_TypeDef *Timer)
	Checks the status of the capture compare channel 1 interrupt flag of the timer.

uint32_t	HIERODULE_TIM_IsSetFlag_CC2 (TIM_TypeDef *Timer)
	Checks the status of the capture compare channel 2 interrupt flag of the timer.

uint32_t	HIERODULE_TIM_IsSetFlag_CC3 (TIM_TypeDef *Timer)
	Checks the status of the capture compare channel 3 interrupt flag of the timer.

uint32_t	HIERODULE_TIM_IsSetFlag_CC4 (TIM_TypeDef *Timer)
	Checks the status of the capture compare channel 4 interrupt flag of the timer.

uint32_t	HIERODULE_TIM_IsSetFlag_BRK (TIM_TypeDef *Timer)
	Checks the status of the break interrupt flag of the timer.

void	HIERODULE_TIM_Enable_IT_UPD (TIM_TypeDef *Timer)
	Enables the update interrupt of the timer.

void	HIERODULE_TIM_Enable_IT_CC1 (TIM_TypeDef *Timer)
	Enables the capture compare channel 1 interrupt of the timer.

void	HIERODULE_TIM_Enable_IT_CC2 (TIM_TypeDef *Timer)
	Enables the capture compare channel 2 interrupt of the timer.

void	HIERODULE_TIM_Enable_IT_CC3 (TIM_TypeDef *Timer)
	Enables the capture compare channel 3 interrupt of the timer.

void	HIERODULE_TIM_Enable_IT_CC4 (TIM_TypeDef *Timer)
	Enables the capture compare channel 4 interrupt of the timer.

void	HIERODULE_TIM_Enable_IT_BRK (TIM_TypeDef *Timer)
	Enables the break interrupt of the timer.

void	HIERODULE_TIM_Disable_IT_UPD (TIM_TypeDef *Timer)
	Disables the update interrupt of the timer.

void	HIERODULE_TIM_Disable_IT_CC1 (TIM_TypeDef *Timer)
	Disables the capture compare channel 1 interrupt of the timer.

void	HIERODULE_TIM_Disable_IT_CC2 (TIM_TypeDef *Timer)
	Disables the capture compare channel 2 interrupt of the timer.

void	HIERODULE_TIM_Disable_IT_CC3 (TIM_TypeDef *Timer)
	Disables the capture compare channel 3 interrupt of the timer.

void	HIERODULE_TIM_Disable_IT_CC4 (TIM_TypeDef *Timer)
	Disables the capture compare channel 4 interrupt of the timer.

void	HIERODULE_TIM_Disable_IT_BRK (TIM_TypeDef *Timer)
	Disables the break interrupt of the timer.

uint32_t	HIERODULE_TIM_IsEnabled_IT_UPD (TIM_TypeDef *Timer)
	Checks the update interrupt of the timer.

uint32_t	HIERODULE_TIM_IsEnabled_IT_CC1 (TIM_TypeDef *Timer)
	Checks the capture compare channel 1 interrupt of the timer.

uint32_t	HIERODULE_TIM_IsEnabled_IT_CC2 (TIM_TypeDef *Timer)
	Checks the capture compare channel 2 interrupt of the timer.

uint32_t	HIERODULE_TIM_IsEnabled_IT_CC3 (TIM_TypeDef *Timer)
	Checks the capture compare channel 3 interrupt of the timer.

uint32_t	HIERODULE_TIM_IsEnabled_IT_CC4 (TIM_TypeDef *Timer)
	Checks the capture compare channel 4 interrupt of the timer.

uint32_t	HIERODULE_TIM_IsEnabled_IT_BRK (TIM_TypeDef *Timer)
	Checks the break interrupt of the timer.

void	HIERODULE_TIM_EnableAutomaticOutput (TIM_TypeDef *Timer)
	Sets the automatic output enable bit in the break and dead time register of the timer.

void	HIERODULE_TIM_DisableAutomaticOutput (TIM_TypeDef *Timer)
	Clears the automatic output enable bit in the break and dead time register of the timer.

void	HIERODULE_TIM_EnableCounter (TIM_TypeDef *Timer)
	Enables the counter of a timer.

void	HIERODULE_TIM_DisableCounter (TIM_TypeDef *Timer)
	Disables the counter of a timer.

uint32_t	HIERODULE_TIM_IsEnabledCounter (TIM_TypeDef *Timer)
	Checks the status of the counter of a timer.

void	HIERODULE_TIM_Assign_ISR_UPD (TIM_TypeDef *Timer, FUNC_POINTER ISR)
	Assigns a function to the designated flag handler for the update interrupt of a timer. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be defined.

void	HIERODULE_TIM_Assign_ISR_CC1 (TIM_TypeDef *Timer, FUNC_POINTER ISR)
	Assigns a function to the designated flag handler for the capture compare channel 1 interrupt of a timer. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be defined.

void	HIERODULE_TIM_Assign_ISR_CC2 (TIM_TypeDef *Timer, FUNC_POINTER ISR)
	Assigns a function to the designated flag handler for the capture compare channel 2 interrupt of a timer. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be defined.

void	HIERODULE_TIM_Assign_ISR_CC3 (TIM_TypeDef *Timer, FUNC_POINTER ISR)
	Assigns a function to the designated flag handler for the capture compare channel 3 interrupt of a timer. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be defined.

void	HIERODULE_TIM_Assign_ISR_CC4 (TIM_TypeDef *Timer, FUNC_POINTER ISR)
	Assigns a function to the designated flag handler for the capture compare channel 4 interrupt of a timer. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be defined.

void	HIERODULE_TIM_Assign_ISR_BRK (TIM_TypeDef *Timer, FUNC_POINTER ISR)
	Assigns a function to the designated flag handler for the break interrupt of a timer. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be defined.

void	HIERODULE_TIM_Assign_TIM1_CC_ISR (FUNC_POINTER ISR)
	Assigns a function to the timer 1 capture compare IRQ handler. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be NOT defined.

void	HIERODULE_TIM_Assign_TIM2_ISR (FUNC_POINTER ISR)
	Assigns a function to the timer 2 IRQ handler. Requires the device specific macro __STM32F103xB_H or __STM32F401xC_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be NOT defined.

void	HIERODULE_TIM_Assign_TIM3_ISR (FUNC_POINTER ISR)
	Assigns a function to the timer 3 IRQ handler. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be NOT defined.

void	HIERODULE_TIM_Assign_TIM4_ISR (FUNC_POINTER ISR)
	Assigns a function to the timer 4 IRQ handler. Requires the device specific macro __STM32F103xB_H or __STM32F401xC_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be NOT defined.

void	HIERODULE_TIM_Assign_TIM1_UP_ISR (FUNC_POINTER ISR)
	Assigns a function to the timer 1 update IRQ handler. Requires the device specific macro __STM32F103xB_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be NOT defined.

void	HIERODULE_TIM_Assign_TIM1_BRK_ISR (FUNC_POINTER ISR)
	Assigns a function to the timer 1 break IRQ handler. Requires the device specific macro __STM32F103xB_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be NOT defined.

void	HIERODULE_TIM_Assign_TIM1_UP_TIM10_ISR (FUNC_POINTER ISR)
	Assigns a function to the timer 1 update - timer 10 IRQ handler. Requires the device specific macro __STM32F401xC_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be NOT defined.

void	HIERODULE_TIM_Assign_TIM1_BRK_TIM9_ISR (FUNC_POINTER ISR)
	Assigns a function to the timer 1 break - timer 9 IRQ handler. Requires the device specific macro __STM32F401xC_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be NOT defined.

void	HIERODULE_TIM_Assign_TIM5_ISR (FUNC_POINTER ISR)
	Assigns a function to the timer 5 IRQ handler. Requires the device specific macro __STM32F401xC_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be NOT defined.

void	HIERODULE_TIM_Assign_TIM1_TRG_COM_TIM11_ISR (FUNC_POINTER ISR)
	Assigns a function to the timer 1 trigger comm - timer 11 IRQ handler. Requires the device specific macro __STM32F401xC_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be NOT defined.

void	HIERODULE_TIM_Assign_TIM1_BRK_UP_TRG_COM_ISR (FUNC_POINTER ISR)
	Assigns a function to the timer 1 break - update - trigger comm IRQ handler. Requires the device specific macro __STM32F030x6_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be NOT defined.

void	HIERODULE_TIM_Assign_TIM14_ISR (FUNC_POINTER ISR)
	Assigns a function to the timer 14 IRQ handler. Requires the device specific macro __STM32F030x6_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be NOT defined.

void	HIERODULE_TIM_Assign_TIM16_ISR (FUNC_POINTER ISR)
	Assigns a function to the timer 16 IRQ handler. Requires the device specific macro __STM32F030x6_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be NOT defined.

void	HIERODULE_TIM_Assign_TIM17_ISR (FUNC_POINTER ISR)
	Assigns a function to the timer 17 IRQ handler. Requires the device specific macro __STM32F030x6_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Requires HIERODULE_TIM_CONVENIENT_IRQ to be NOT defined.

void	TIM1_UP_IRQHandler (void)
	Timer 1 update interrupt IRQ implementation. Requires the device specific macro __STM32F103xB_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Won't be compiled if HIERODULE_TIM_RESERVED equals 1.

void	TIM1_UP_TIM10_IRQHandler (void)
	Timer 1 update interrupt - timer 10 IRQ implementation. Requires the device specific macro __STM32F401xC_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Won't be compiled if HIERODULE_TIM_RESERVED equals 1 or 10.

void	TIM1_CC_IRQHandler (void)
	Timer 1 capture compare interrupt IRQ implementation. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Won't be compiled if HIERODULE_TIM_RESERVED equals 1.

void	TIM1_BRK_IRQHandler (void)
	Timer 1 break interrupt IRQ implementation. Requires the device specific macro __STM32F103xB_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Won't be compiled if HIERODULE_TIM_RESERVED equals 1.

void	TIM1_BRK_TIM9_IRQHandler (void)
	Timer 1 break interrupt - timer 9 IRQ implementation. Requires the device specific macro __STM32F401xC_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Won't be compiled if HIERODULE_TIM_RESERVED equals 1 or 9.

void	TIM1_BRK_UP_TRG_COM_IRQHandler (void)
	Timer 1 break - update - trigger comm IRQ implementation. Requires the device specific macro __STM32F030x6_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Won't be compiled if HIERODULE_TIM_RESERVED equals 1.

void	TIM2_IRQHandler (void)
	Timer 2 IRQ implementation. Requires the device specific macro __STM32F103xB_H or __STM32F401xC_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Won't be compiled if HIERODULE_TIM_RESERVED equals 2.

void	TIM3_IRQHandler (void)
	Timer 3 IRQ implementation. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Won't be compiled if HIERODULE_TIM_RESERVED equals 3.

void	TIM4_IRQHandler (void)
	Timer 4 IRQ implementation. Requires the device specific macro __STM32F103xB_H or __STM32F401xC_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Won't be compiled if HIERODULE_TIM_RESERVED equals 4.

void	TIM5_IRQHandler (void)
	Timer 5 IRQ implementation. Requires the device specific macro __STM32F401xC_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Won't be compiled if HIERODULE_TIM_RESERVED equals 5.

void	TIM1_TRG_COM_TIM11_IRQHandler (void)
	Timer 1 trigger comm interrupt - timer 11 IRQ implementation. Requires the device specific macro __STM32F401xC_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Won't be compiled if HIERODULE_TIM_RESERVED equals 1 or 11.

void	TIM14_IRQHandler (void)
	Timer 14 IRQ implementation. Requires the device specific macro __STM32F030x6_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Won't be compiled if HIERODULE_TIM_RESERVED equals 14.

void	TIM16_IRQHandler (void)
	Timer 16 IRQ implementation. Requires the device specific macro __STM32F030x6_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Won't be compiled if HIERODULE_TIM_RESERVED equals 16.

void	TIM17_IRQHandler (void)
	Timer 17 IRQ implementation. Requires the device specific macro __STM32F030x6_H to be defined. Requires HIERODULE_TIM_HANDLE_IRQ to be defined. Won't be compiled if HIERODULE_TIM_RESERVED equals 17.

Detailed Description

Consists of PWM output management and Timer interrupt handling routines, as well as a void function pointer alias typedef for convenience and a pair of precompiler constants to configure module behaviour.
Device-specific macro constants and type definitions are imported with an include directive to main.h, where the device driver headers are assumed to be included.
stdlib.h also included for abs.

Macro Definition Documentation

◆ HIERODULE_TIM_CONVENIENT_IRQ

#define HIERODULE_TIM_CONVENIENT_IRQ

When commented out, ISRs will be assigned per IRQ instead of per interrupt flag and the routine Check_IT will be omitted.
Requires HIERODULE_TIM_HANDLE_IRQ to be defined.

Definition at line 56 of file hierodule_tim.h.

◆ HIERODULE_TIM_HANDLE_IRQ

#define HIERODULE_TIM_HANDLE_IRQ

When commented out, IRQ handler routines won't be defined in the source file.

Definition at line 39 of file hierodule_tim.h.

◆ HIERODULE_TIM_RESERVED

#define HIERODULE_TIM_RESERVED 0

This is basically to reserve a timer for HAL timebase, when FreeRTOS uses SysTick.
When declared as 0, it will have no effect. When declared as n, TIMn IRQ won't be implemented.
Requires HIERODULE_TIM_HANDLE_IRQ to be defined.

Definition at line 48 of file hierodule_tim.h.

Typedef Documentation

◆ FUNC_POINTER

typedef void(* FUNC_POINTER) (void)

Used for convenience, really. It's used a lot, especially in the source file. It would be a clutter of asterisks and paranthesis otherwise.

Definition at line 66 of file hierodule_tim.h.

Function Documentation

◆ HIERODULE_TIM_Assign_ISR_BRK()

void HIERODULE_TIM_Assign_ISR_BRK	(	TIM_TypeDef *	Timer,
		FUNC_POINTER	ISR )

Parameters

Timer	Pointer to timer struct.
ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Assigns the the ISR to the designated handler for Check_IT to use inside the IRQ if the selected timer indeed has the break interrupt flag, branches to InfiniteLoopOfError otherwise.

Definition at line 1337 of file hierodule_tim.c.

{
    uint32_t TimerAddress = (uint32_t)Timer;
 
    switch(TimerAddress)
    {
        case ( (uint32_t)TIM1 ):
            BRK_Handler_TIM1 = ISR;
            break;
        #ifdef __STM32F030x6_H 
        case ( (uint32_t)TIM17 ):
            BRK_Handler_TIM17 = ISR;
            break;
        #endif 
        default:
            InfiniteLoopOfError();
    }
}

References BRK_Handler_TIM1, BRK_Handler_TIM17, and InfiniteLoopOfError().

◆ HIERODULE_TIM_Assign_ISR_CC1()

void HIERODULE_TIM_Assign_ISR_CC1	(	TIM_TypeDef *	Timer,
		FUNC_POINTER	ISR )

Parameters

Timer	Pointer to timer struct.
ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Assigns the the ISR to the designated handler for Check_IT to use inside the IRQ if the selected timer indeed has the capture compare channel 1 interrupt flag, branches to InfiniteLoopOfError otherwise.

Definition at line 1158 of file hierodule_tim.c.

{
    uint32_t TimerAddress = (uint32_t)Timer;
 
    switch(TimerAddress)
    {
        case ( (uint32_t)TIM1 ):
            CC1_Handler_TIM1 = ISR;
            break;
        #if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
        case ( (uint32_t)TIM2 ):
            CC1_Handler_TIM2 = ISR;
            break;
        #endif 
        case ( (uint32_t)TIM3 ):
            CC1_Handler_TIM3 = ISR;
            break;
        #if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
        case ( (uint32_t)TIM4 ):
            CC1_Handler_TIM4 = ISR;
            break;
        #endif
        #ifdef __STM32F401xC_H 
        case ( (uint32_t)TIM5 ):
            CC1_Handler_TIM5 = ISR;
            break;
        case ( (uint32_t)TIM9 ):
            CC1_Handler_TIM9 = ISR;
            break;
        case ( (uint32_t)TIM10 ):
            CC1_Handler_TIM10 = ISR;
            break;
        case ( (uint32_t)TIM11 ):
            CC1_Handler_TIM11 = ISR;
            break;
        #elif defined __STM32F030x6_H 
        case ( (uint32_t)TIM14 ):
            CC1_Handler_TIM14 = ISR;
            break;
        case ( (uint32_t)TIM16 ):
            CC1_Handler_TIM16 = ISR;
            break;
        case ( (uint32_t)TIM17 ):
            CC1_Handler_TIM17 = ISR;
            break;
        #endif 
        default:
            InfiniteLoopOfError();
    }
}

References CC1_Handler_TIM1, CC1_Handler_TIM10, CC1_Handler_TIM11, CC1_Handler_TIM14, CC1_Handler_TIM16, CC1_Handler_TIM17, CC1_Handler_TIM2, CC1_Handler_TIM3, CC1_Handler_TIM4, CC1_Handler_TIM5, CC1_Handler_TIM9, and InfiniteLoopOfError().

◆ HIERODULE_TIM_Assign_ISR_CC2()

void HIERODULE_TIM_Assign_ISR_CC2	(	TIM_TypeDef *	Timer,
		FUNC_POINTER	ISR )

Parameters

Timer	Pointer to timer struct.
ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Assigns the the ISR to the designated handler for Check_IT to use inside the IRQ if the selected timer indeed has the capture compare channel 2 interrupt flag, branches to InfiniteLoopOfError otherwise.

Definition at line 1217 of file hierodule_tim.c.

{
    uint32_t TimerAddress = (uint32_t)Timer;
 
    switch(TimerAddress)
    {
        case ( (uint32_t)TIM1 ):
            CC2_Handler_TIM1 = ISR;
            break;
        #if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
        case ( (uint32_t)TIM2 ):
            CC2_Handler_TIM2 = ISR;
            break;
        #endif 
        case ( (uint32_t)TIM3 ):
            CC2_Handler_TIM3 = ISR;
            break;
        #if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
        case ( (uint32_t)TIM4 ):
            CC2_Handler_TIM4 = ISR;
            break;
        #endif
        #ifdef __STM32F401xC_H 
        case ( (uint32_t)TIM5 ):
            CC2_Handler_TIM5 = ISR;
            break;
        case ( (uint32_t)TIM9 ):
            CC2_Handler_TIM9 = ISR;
            break;
        #endif 
        default:
            InfiniteLoopOfError();
    }
}

References CC2_Handler_TIM1, CC2_Handler_TIM2, CC2_Handler_TIM3, CC2_Handler_TIM4, CC2_Handler_TIM5, CC2_Handler_TIM9, and InfiniteLoopOfError().

◆ HIERODULE_TIM_Assign_ISR_CC3()

void HIERODULE_TIM_Assign_ISR_CC3	(	TIM_TypeDef *	Timer,
		FUNC_POINTER	ISR )

Parameters

Timer	Pointer to timer struct.
ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Assigns the the ISR to the designated handler for Check_IT to use inside the IRQ if the selected timer indeed has the capture compare channel 3 interrupt flag, branches to InfiniteLoopOfError otherwise.

Definition at line 1259 of file hierodule_tim.c.

{
    uint32_t TimerAddress = (uint32_t)Timer;
 
    switch(TimerAddress)
    {
        case ( (uint32_t)TIM1 ):
            CC3_Handler_TIM1 = ISR;
            break;
        #if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
        case ( (uint32_t)TIM2 ):
            CC3_Handler_TIM2 = ISR;
            break;
        #endif 
        case ( (uint32_t)TIM3 ):
            CC3_Handler_TIM3 = ISR;
            break;
        #if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
        case ( (uint32_t)TIM4 ):
            CC3_Handler_TIM4 = ISR;
            break;
        #endif
        #ifdef __STM32F401xC_H 
        case ( (uint32_t)TIM5 ):
            CC3_Handler_TIM5 = ISR;
            break;
        #endif 
        default:
            InfiniteLoopOfError();
    }
}

References CC3_Handler_TIM1, CC3_Handler_TIM2, CC3_Handler_TIM3, CC3_Handler_TIM4, CC3_Handler_TIM5, and InfiniteLoopOfError().

◆ HIERODULE_TIM_Assign_ISR_CC4()

void HIERODULE_TIM_Assign_ISR_CC4	(	TIM_TypeDef *	Timer,
		FUNC_POINTER	ISR )

Parameters

Timer	Pointer to timer struct.
ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Assigns the the ISR to the designated handler for Check_IT to use inside the IRQ if the selected timer indeed has the capture compare channel 4 interrupt flag, branches to InfiniteLoopOfError otherwise.

Definition at line 1298 of file hierodule_tim.c.

{
    uint32_t TimerAddress = (uint32_t)Timer;
 
    switch(TimerAddress)
    {
        case ( (uint32_t)TIM1 ):
            CC4_Handler_TIM1 = ISR;
            break;
        #if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
        case ( (uint32_t)TIM2 ):
            CC4_Handler_TIM2 = ISR;
            break;
        #endif 
        case ( (uint32_t)TIM3 ):
            CC4_Handler_TIM3 = ISR;
            break;
        #if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
        case ( (uint32_t)TIM4 ):
            CC4_Handler_TIM4 = ISR;
            break;
        #endif
        #ifdef __STM32F401xC_H 
        case ( (uint32_t)TIM5 ):
            CC4_Handler_TIM5 = ISR;
            break;
        #endif 
        default:
            InfiniteLoopOfError();
    }
}

References CC4_Handler_TIM1, CC4_Handler_TIM2, CC4_Handler_TIM3, CC4_Handler_TIM4, CC4_Handler_TIM5, and InfiniteLoopOfError().

◆ HIERODULE_TIM_Assign_ISR_UPD()

void HIERODULE_TIM_Assign_ISR_UPD	(	TIM_TypeDef *	Timer,
		FUNC_POINTER	ISR )

Parameters

Timer	Pointer to timer struct.
ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Assigns the the ISR to the designated handler for Check_IT to use inside the IRQ if the selected timer indeed has the update interrupt flag, branches to InfiniteLoopOfError otherwise.

Definition at line 1099 of file hierodule_tim.c.

{
    uint32_t TimerAddress = (uint32_t)Timer;
 
    switch(TimerAddress)
    {
        case ( (uint32_t)TIM1 ):
            UPD_Handler_TIM1 = ISR;
            break;
        #if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
        case ( (uint32_t)TIM2 ):
            UPD_Handler_TIM2 = ISR;
            break;
        #endif 
        case ( (uint32_t)TIM3 ):
            UPD_Handler_TIM3 = ISR;
            break;
        #if ( (defined __STM32F103xB_H) || (defined __STM32F401xC_H) ) 
        case ( (uint32_t)TIM4 ):
            UPD_Handler_TIM4 = ISR;
            break;
        #endif
        #ifdef __STM32F401xC_H 
        case ( (uint32_t)TIM5 ):
            UPD_Handler_TIM5 = ISR;
            break;
        case ( (uint32_t)TIM9 ):
            UPD_Handler_TIM9 = ISR;
            break;
        case ( (uint32_t)TIM10 ):
            UPD_Handler_TIM10 = ISR;
            break;
        case ( (uint32_t)TIM11 ):
            UPD_Handler_TIM11 = ISR;
            break;
        #elif defined __STM32F030x6_H 
        case ( (uint32_t)TIM14 ):
            UPD_Handler_TIM14 = ISR;
            break;
        case ( (uint32_t)TIM16 ):
            UPD_Handler_TIM16 = ISR;
            break;
        case ( (uint32_t)TIM17 ):
            UPD_Handler_TIM17 = ISR;
            break;
        #endif 
        default:
            InfiniteLoopOfError();
    }
}

References InfiniteLoopOfError(), UPD_Handler_TIM1, UPD_Handler_TIM10, UPD_Handler_TIM11, UPD_Handler_TIM14, UPD_Handler_TIM16, UPD_Handler_TIM17, UPD_Handler_TIM2, UPD_Handler_TIM3, UPD_Handler_TIM4, UPD_Handler_TIM5, and UPD_Handler_TIM9.

◆ HIERODULE_TIM_Assign_TIM14_ISR()

void HIERODULE_TIM_Assign_TIM14_ISR ( FUNC_POINTER ISR )

Parameters

ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 1452 of file hierodule_tim.c.

    {
        TIM14_ISR = ISR;
    }

References TIM14_ISR.

◆ HIERODULE_TIM_Assign_TIM16_ISR()

void HIERODULE_TIM_Assign_TIM16_ISR ( FUNC_POINTER ISR )

Parameters

ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 1459 of file hierodule_tim.c.

    {
        TIM16_ISR = ISR;
    }

References TIM16_ISR.

◆ HIERODULE_TIM_Assign_TIM17_ISR()

void HIERODULE_TIM_Assign_TIM17_ISR ( FUNC_POINTER ISR )

Parameters

ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 1466 of file hierodule_tim.c.

    {
        TIM17_ISR = ISR;
    }

References TIM17_ISR.

◆ HIERODULE_TIM_Assign_TIM1_BRK_ISR()

void HIERODULE_TIM_Assign_TIM1_BRK_ISR ( FUNC_POINTER ISR )

Parameters

ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 1405 of file hierodule_tim.c.

    {
        TIM1_BRK_ISR = ISR;
    }

References TIM1_BRK_ISR.

◆ HIERODULE_TIM_Assign_TIM1_BRK_TIM9_ISR()

void HIERODULE_TIM_Assign_TIM1_BRK_TIM9_ISR ( FUNC_POINTER ISR )

Parameters

ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 1421 of file hierodule_tim.c.

    {
        TIM1_BRK_TIM9_ISR = ISR;
    }

References TIM1_BRK_TIM9_ISR.

◆ HIERODULE_TIM_Assign_TIM1_BRK_UP_TRG_COM_ISR()

void HIERODULE_TIM_Assign_TIM1_BRK_UP_TRG_COM_ISR ( FUNC_POINTER ISR )

Parameters

ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 1445 of file hierodule_tim.c.

    {
        TIM1_BRK_UP_TRG_COM_ISR = ISR;
    }

References TIM1_BRK_UP_TRG_COM_ISR.

◆ HIERODULE_TIM_Assign_TIM1_CC_ISR()

void HIERODULE_TIM_Assign_TIM1_CC_ISR ( FUNC_POINTER ISR )

Parameters

ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 1361 of file hierodule_tim.c.

    {
        TIM1_CC_ISR = ISR;
    }

References TIM1_CC_ISR.

◆ HIERODULE_TIM_Assign_TIM1_TRG_COM_TIM11_ISR()

void HIERODULE_TIM_Assign_TIM1_TRG_COM_TIM11_ISR ( FUNC_POINTER ISR )

Parameters

ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 1435 of file hierodule_tim.c.

    {
        TIM1_TRG_COM_TIM11_ISR = ISR;
    }

References TIM1_TRG_COM_TIM11_ISR.

◆ HIERODULE_TIM_Assign_TIM1_UP_ISR()

void HIERODULE_TIM_Assign_TIM1_UP_ISR ( FUNC_POINTER ISR )

Parameters

ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 1398 of file hierodule_tim.c.

    {
        TIM1_UP_ISR = ISR;
    }

References TIM1_UP_ISR.

◆ HIERODULE_TIM_Assign_TIM1_UP_TIM10_ISR()

void HIERODULE_TIM_Assign_TIM1_UP_TIM10_ISR ( FUNC_POINTER ISR )

Parameters

ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 1414 of file hierodule_tim.c.

    {
        TIM1_UP_TIM10_ISR = ISR;
    }

References TIM1_UP_TIM10_ISR.

◆ HIERODULE_TIM_Assign_TIM2_ISR()

void HIERODULE_TIM_Assign_TIM2_ISR ( FUNC_POINTER ISR )

Parameters

ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 1370 of file hierodule_tim.c.

    {
        TIM2_ISR = ISR;
    }

References TIM2_ISR.

◆ HIERODULE_TIM_Assign_TIM3_ISR()

void HIERODULE_TIM_Assign_TIM3_ISR ( FUNC_POINTER ISR )

Parameters

ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 1379 of file hierodule_tim.c.

    {
        TIM3_ISR = ISR;
    }

References TIM3_ISR.

◆ HIERODULE_TIM_Assign_TIM4_ISR()

void HIERODULE_TIM_Assign_TIM4_ISR ( FUNC_POINTER ISR )

Parameters

ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 1388 of file hierodule_tim.c.

    {
        TIM4_ISR = ISR;
    }

References TIM4_ISR.

◆ HIERODULE_TIM_Assign_TIM5_ISR()

void HIERODULE_TIM_Assign_TIM5_ISR ( FUNC_POINTER ISR )

Parameters

ISR	Pointer to ISR, a void-parameter void-return function.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 1428 of file hierodule_tim.c.

    {
        TIM5_ISR = ISR;
    }

References TIM5_ISR.

◆ HIERODULE_TIM_ClearCounter()

void HIERODULE_TIM_ClearCounter ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 693 of file hierodule_tim.c.

{
    Timer->CNT = 0U;
}

◆ HIERODULE_TIM_ClearFlag_BRK()

void HIERODULE_TIM_ClearFlag_BRK ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

Break interrupt flag is cleared software-wise with the logical NOT of the flag's timer status register bitmask.

Definition at line 873 of file hierodule_tim.c.

{
    WRITE_REG(Timer->SR, ~(TIM_SR_BIF));
}

Referenced by HIERODULE_TIM_Enable_IT_BRK(), TIM17_IRQHandler(), TIM1_BRK_IRQHandler(), TIM1_BRK_TIM9_IRQHandler(), and TIM1_BRK_UP_TRG_COM_IRQHandler().

◆ HIERODULE_TIM_ClearFlag_CC1()

void HIERODULE_TIM_ClearFlag_CC1 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

Capture compare channel 1 interrupt flag is cleared software-wise with the logical NOT of the flag's timer status register bitmask.

Definition at line 845 of file hierodule_tim.c.

{
    WRITE_REG(Timer->SR, ~(TIM_SR_CC1IF));
}

Referenced by HIERODULE_TIM_Enable_IT_CC1(), TIM14_IRQHandler(), TIM16_IRQHandler(), TIM17_IRQHandler(), TIM1_BRK_TIM9_IRQHandler(), TIM1_CC_IRQHandler(), TIM1_TRG_COM_TIM11_IRQHandler(), TIM1_UP_TIM10_IRQHandler(), TIM2_IRQHandler(), TIM3_IRQHandler(), TIM4_IRQHandler(), and TIM5_IRQHandler().

◆ HIERODULE_TIM_ClearFlag_CC2()

void HIERODULE_TIM_ClearFlag_CC2 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

Capture compare channel 2 interrupt flag is cleared software-wise with the logical NOT of the flag's timer status register bitmask.

Definition at line 852 of file hierodule_tim.c.

{
    WRITE_REG(Timer->SR, ~(TIM_SR_CC2IF));
}

Referenced by HIERODULE_TIM_Enable_IT_CC2(), TIM1_BRK_TIM9_IRQHandler(), TIM1_CC_IRQHandler(), TIM2_IRQHandler(), TIM3_IRQHandler(), TIM4_IRQHandler(), and TIM5_IRQHandler().

◆ HIERODULE_TIM_ClearFlag_CC3()

void HIERODULE_TIM_ClearFlag_CC3 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

Capture compare channel 3 interrupt flag is cleared software-wise with the logical NOT of the flag's timer status register bitmask.

Definition at line 859 of file hierodule_tim.c.

{
    WRITE_REG(Timer->SR, ~(TIM_SR_CC3IF));
}

Referenced by HIERODULE_TIM_Enable_IT_CC3(), TIM1_CC_IRQHandler(), TIM2_IRQHandler(), TIM3_IRQHandler(), TIM4_IRQHandler(), and TIM5_IRQHandler().

◆ HIERODULE_TIM_ClearFlag_CC4()

void HIERODULE_TIM_ClearFlag_CC4 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

Capture compare channel 4 interrupt flag is cleared software-wise with the logical NOT of the flag's timer status register bitmask.

Definition at line 866 of file hierodule_tim.c.

{
    WRITE_REG(Timer->SR, ~(TIM_SR_CC4IF));
}

Referenced by HIERODULE_TIM_Enable_IT_CC4(), TIM1_CC_IRQHandler(), TIM2_IRQHandler(), TIM3_IRQHandler(), TIM4_IRQHandler(), and TIM5_IRQHandler().

◆ HIERODULE_TIM_ClearFlag_UPD()

void HIERODULE_TIM_ClearFlag_UPD ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

Update interrupt flag is cleared software-wise with the logical NOT of the flag's timer status register bitmask.

Definition at line 838 of file hierodule_tim.c.

{
    WRITE_REG(Timer->SR, ~(TIM_SR_UIF));
}

Referenced by HIERODULE_TIM_Enable_IT_UPD(), TIM14_IRQHandler(), TIM16_IRQHandler(), TIM17_IRQHandler(), TIM1_BRK_TIM9_IRQHandler(), TIM1_BRK_UP_TRG_COM_IRQHandler(), TIM1_TRG_COM_TIM11_IRQHandler(), TIM1_UP_IRQHandler(), TIM1_UP_TIM10_IRQHandler(), TIM2_IRQHandler(), TIM3_IRQHandler(), TIM4_IRQHandler(), and TIM5_IRQHandler().

◆ HIERODULE_TIM_Disable_IT_BRK()

void HIERODULE_TIM_Disable_IT_BRK ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

The break interrupt is disabled by clearing the enable bit in the timer control register.

Definition at line 1005 of file hierodule_tim.c.

{
    CLEAR_BIT(Timer->DIER, TIM_DIER_BIE);
}

◆ HIERODULE_TIM_Disable_IT_CC1()

void HIERODULE_TIM_Disable_IT_CC1 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

The capture compare channel 1 interrupt is disabled by clearing the enable bit in the timer control register.

Definition at line 977 of file hierodule_tim.c.

{
    CLEAR_BIT(Timer->DIER, TIM_DIER_CC1IE);
}

◆ HIERODULE_TIM_Disable_IT_CC2()

void HIERODULE_TIM_Disable_IT_CC2 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

The capture compare channel 2 interrupt is disabled by clearing the enable bit in the timer control register.

Definition at line 984 of file hierodule_tim.c.

{
    CLEAR_BIT(Timer->DIER, TIM_DIER_CC2IE);
}

◆ HIERODULE_TIM_Disable_IT_CC3()

void HIERODULE_TIM_Disable_IT_CC3 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

The capture compare channel 3 interrupt is disabled by clearing the enable bit in the timer control register.

Definition at line 991 of file hierodule_tim.c.

{
    CLEAR_BIT(Timer->DIER, TIM_DIER_CC3IE);
}

◆ HIERODULE_TIM_Disable_IT_CC4()

void HIERODULE_TIM_Disable_IT_CC4 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

The capture compare channel 4 interrupt is disabled by clearing the enable bit in the timer control register.

Definition at line 998 of file hierodule_tim.c.

{
    CLEAR_BIT(Timer->DIER, TIM_DIER_CC4IE);
}

◆ HIERODULE_TIM_Disable_IT_UPD()

void HIERODULE_TIM_Disable_IT_UPD ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

The update interrupt is disabled by clearing the enable bit in the timer control register.

Definition at line 970 of file hierodule_tim.c.

{
    CLEAR_BIT(Timer->DIER, TIM_DIER_UIE);
}

◆ HIERODULE_TIM_DisableAutomaticOutput()

void HIERODULE_TIM_DisableAutomaticOutput ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

Note that this will only work if the timer has the automatic output enable bit in a break and dead time register.

Definition at line 1067 of file hierodule_tim.c.

{
    CLEAR_BIT(Timer->BDTR, TIM_BDTR_AOE);
}

◆ HIERODULE_TIM_DisableChannel()

void HIERODULE_TIM_DisableChannel	(	TIM_TypeDef *	Timer,
		int8_t	Channel )

Parameters

Timer	Pointer to timer struct.
Channel	Integer to specify the channel, 1 to 4, negative for complimentary output channels.

Returns: None

Fetches the bit mask of the selected channel from the array TimerChannel_EN and uses that to clear the designated CCER register bit.
Channel parameter is ensured to be a valid integer value beforehand to avoid failure.

Definition at line 737 of file hierodule_tim.c.

{
    if( (Channel > 0) && (Channel < 5) )
    {
        CLEAR_BIT(Timer->CCER, TimerChannel_EN[Channel-1]);
    }
    else if( (Channel < 0) && (Channel > -4) )
    {
        CLEAR_BIT(Timer->CCER, TimerChannel_EN[abs(Channel)+3]);
    }
}

References TimerChannel_EN.

◆ HIERODULE_TIM_DisableCounter()

void HIERODULE_TIM_DisableCounter ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 1081 of file hierodule_tim.c.

{
    CLEAR_BIT(Timer->CR1, TIM_CR1_CEN);
}

◆ HIERODULE_TIM_DisableMainOutput()

void HIERODULE_TIM_DisableMainOutput ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

Note that this will only work if the timer has the main output enable bit in a break and dead time register.

Definition at line 794 of file hierodule_tim.c.

{
    CLEAR_BIT(Timer->BDTR, TIM_BDTR_MOE);
}

◆ HIERODULE_TIM_Enable_IT_BRK()

void HIERODULE_TIM_Enable_IT_BRK ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

The enable bit in the timer control register is set after clearing the break interrupt flag.

Definition at line 962 of file hierodule_tim.c.

{
    HIERODULE_TIM_ClearFlag_BRK(Timer);
    SET_BIT(Timer->DIER, TIM_DIER_BIE);
}

References HIERODULE_TIM_ClearFlag_BRK().

◆ HIERODULE_TIM_Enable_IT_CC1()

void HIERODULE_TIM_Enable_IT_CC1 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

The enable bit in the timer control register is set after clearing the capture compare channel 1 interrupt flag.

Definition at line 930 of file hierodule_tim.c.

{
    HIERODULE_TIM_ClearFlag_CC1(Timer);
    SET_BIT(Timer->DIER, TIM_DIER_CC1IE);
}

References HIERODULE_TIM_ClearFlag_CC1().

◆ HIERODULE_TIM_Enable_IT_CC2()

void HIERODULE_TIM_Enable_IT_CC2 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

The enable bit in the timer control register is set after clearing the capture compare channel 2 interrupt flag.

Definition at line 938 of file hierodule_tim.c.

{
    HIERODULE_TIM_ClearFlag_CC2(Timer);
    SET_BIT(Timer->DIER, TIM_DIER_CC2IE);
}

References HIERODULE_TIM_ClearFlag_CC2().

◆ HIERODULE_TIM_Enable_IT_CC3()

void HIERODULE_TIM_Enable_IT_CC3 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

The enable bit in the timer control register is set after clearing the capture compare channel 3 interrupt flag.

Definition at line 946 of file hierodule_tim.c.

{
    HIERODULE_TIM_ClearFlag_CC3(Timer);
    SET_BIT(Timer->DIER, TIM_DIER_CC3IE);
}

References HIERODULE_TIM_ClearFlag_CC3().

◆ HIERODULE_TIM_Enable_IT_CC4()

void HIERODULE_TIM_Enable_IT_CC4 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

The enable bit in the timer control register is set after clearing the capture compare channel 4 interrupt flag.

Definition at line 954 of file hierodule_tim.c.

{
    HIERODULE_TIM_ClearFlag_CC4(Timer);
    SET_BIT(Timer->DIER, TIM_DIER_CC4IE);
}

References HIERODULE_TIM_ClearFlag_CC4().

◆ HIERODULE_TIM_Enable_IT_UPD()

void HIERODULE_TIM_Enable_IT_UPD ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

The enable bit in the timer control register is set after clearing the update interrupt flag.

Definition at line 922 of file hierodule_tim.c.

{
    HIERODULE_TIM_ClearFlag_UPD(Timer);
    SET_BIT(Timer->DIER, TIM_DIER_UIE);
}

References HIERODULE_TIM_ClearFlag_UPD().

◆ HIERODULE_TIM_EnableAutomaticOutput()

void HIERODULE_TIM_EnableAutomaticOutput ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

Note that this will only work if the timer has the automatic output enable bit in a break and dead time register.

Definition at line 1060 of file hierodule_tim.c.

{
    SET_BIT(Timer->BDTR, TIM_BDTR_AOE);
}

◆ HIERODULE_TIM_EnableChannel()

void HIERODULE_TIM_EnableChannel	(	TIM_TypeDef *	Timer,
		int8_t	Channel )

Parameters

Timer	Pointer to timer struct.
Channel	Integer to specify the channel, 1 to 4, negative for complimentary output channels.

Returns: None

Fetches the bit mask of the selected channel from the array TimerChannel_EN and uses that to set the designated CCER register bit.
Channel parameter is ensured to be a valid integer value beforehand to avoid failure.

Definition at line 722 of file hierodule_tim.c.

{
    if( (Channel > 0) && (Channel < 5) )
    {
        SET_BIT(Timer->CCER, TimerChannel_EN[Channel-1]);
    }
    else if( (Channel < 0) && (Channel > -4) )
    {
        SET_BIT(Timer->CCER, TimerChannel_EN[abs(Channel)+3]);
    }
}

References TimerChannel_EN.

◆ HIERODULE_TIM_EnableCounter()

void HIERODULE_TIM_EnableCounter ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

Self-explanatory code, nothing to elaborate.

Definition at line 1074 of file hierodule_tim.c.

{
    SET_BIT(Timer->CR1, TIM_CR1_CEN);
}

◆ HIERODULE_TIM_EnableMainOutput()

void HIERODULE_TIM_EnableMainOutput ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: None

Note that this will only work if the timer has the main output enable bit in a break and dead time register.

Definition at line 787 of file hierodule_tim.c.

{
    SET_BIT(Timer->BDTR, TIM_BDTR_MOE);
}

◆ HIERODULE_TIM_GetDutyCycle()

double HIERODULE_TIM_GetDutyCycle	(	TIM_TypeDef *	Timer,
		uint8_t	Channel )

Parameters

Timer	Pointer to timer struct.
Channel	Integer to specify the channel, 1 to 4, negative for complimentary output channels.

Returns: Duty cycle percentage, normalized.

The duty cycle is simply calculated dividing ARR by CCR, the pointer to which is acquired with a call to ChannelSelector with the timer struct pointer and the corresponding element of the CCR variable offset array TimerChannel_CCR.
Channel parameter is ensured to be a valid integer value beforehand to avoid failure. In case of an invalid input, -1.0 is returned.

Definition at line 822 of file hierodule_tim.c.

{
    if( (Channel < 1) && (Channel > 4) )
    {
        return -1.0;
    }
    else
    {
        return
            ((double)(*(ChannelSelector(Timer, TimerChannel_CCR[Channel-1]))))
            / ((double)(READ_REG(Timer->ARR)));
    }
}

References ChannelSelector(), and TimerChannel_CCR.

◆ HIERODULE_TIM_GetFrequency()

double HIERODULE_TIM_GetFrequency ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: Frequency in Hertz.

The frequency is calculated on the fly using the ARR and base frequency. See GetBaseFreq for further info.

\(Frequency = Base Frequency / (ARR+1) \)

Definition at line 686 of file hierodule_tim.c.

{
    return ((double)GetBaseFreq(Timer))/((double)(READ_REG(Timer->ARR)+1.0));
}

References GetBaseFreq().

◆ HIERODULE_TIM_GetPeriod()

double HIERODULE_TIM_GetPeriod ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: Period duration in seconds.

The period is calculated on the fly using the ARR and base frequency. See GetBaseFreq for further info.

\(Period = (ARR+1) / Base Frequency \)

Definition at line 669 of file hierodule_tim.c.

{
    return ((double)READ_REG(Timer->ARR)+1.0)/((double)GetBaseFreq(Timer));
}

References GetBaseFreq().

◆ HIERODULE_TIM_GetRepetition()

uint32_t HIERODULE_TIM_GetRepetition ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: Number of repetitions.

Basically reads from the repetition counter register and returns the value.
Note that this will only work if the timer has the repetition counter register.

Definition at line 714 of file hierodule_tim.c.

{
    return READ_REG(Timer->RCR);
}

◆ HIERODULE_TIM_IsEnabled_IT_BRK()

uint32_t HIERODULE_TIM_IsEnabled_IT_BRK ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: 1 if the break interrupt is enabled, 0 otherwise.

TIM_DIER_BIE bit is isolated from the register with its bitmask and compared to the same bitmask instead of shifting since the amount of shift would depend on the bitmask.

Definition at line 1052 of file hierodule_tim.c.

{
    return ((READ_BIT(Timer->DIER, TIM_DIER_BIE) == (TIM_DIER_BIE))
        ? 1UL : 0UL);
}

Referenced by TIM17_IRQHandler(), TIM1_BRK_TIM9_IRQHandler(), and TIM1_BRK_UP_TRG_COM_IRQHandler().

◆ HIERODULE_TIM_IsEnabled_IT_CC1()

uint32_t HIERODULE_TIM_IsEnabled_IT_CC1 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: 1 if the capture compare channel 1 interrupt is enabled, 0 otherwise.

TIM_DIER_CC1IE bit is isolated from the register with its bitmask and compared to the same bitmask instead of shifting since the amount of shift would depend on the bitmask.

Definition at line 1020 of file hierodule_tim.c.

{
    return ((READ_BIT(Timer->DIER, TIM_DIER_CC1IE) == (TIM_DIER_CC1IE))
        ? 1UL : 0UL);
}

Referenced by TIM14_IRQHandler(), TIM16_IRQHandler(), TIM17_IRQHandler(), TIM1_BRK_TIM9_IRQHandler(), TIM1_CC_IRQHandler(), TIM1_TRG_COM_TIM11_IRQHandler(), TIM1_UP_TIM10_IRQHandler(), TIM2_IRQHandler(), TIM3_IRQHandler(), TIM4_IRQHandler(), and TIM5_IRQHandler().

◆ HIERODULE_TIM_IsEnabled_IT_CC2()

uint32_t HIERODULE_TIM_IsEnabled_IT_CC2 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: 1 if the capture compare channel 2 interrupt is enabled, 0 otherwise.

TIM_DIER_CC2IE bit is isolated from the register with its bitmask and compared to the same bitmask instead of shifting since the amount of shift would depend on the bitmask.

Definition at line 1028 of file hierodule_tim.c.

{
    return ((READ_BIT(Timer->DIER, TIM_DIER_CC2IE) == (TIM_DIER_CC2IE))
        ? 1UL : 0UL);
}

Referenced by TIM1_BRK_TIM9_IRQHandler(), TIM1_CC_IRQHandler(), TIM2_IRQHandler(), TIM3_IRQHandler(), TIM4_IRQHandler(), and TIM5_IRQHandler().

◆ HIERODULE_TIM_IsEnabled_IT_CC3()

uint32_t HIERODULE_TIM_IsEnabled_IT_CC3 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: 1 if the capture compare channel 3 interrupt is enabled, 0 otherwise.

TIM_DIER_CC3IE bit is isolated from the register with its bitmask and compared to the same bitmask instead of shifting since the amount of shift would depend on the bitmask.

Definition at line 1036 of file hierodule_tim.c.

{
    return ((READ_BIT(Timer->DIER, TIM_DIER_CC3IE) == (TIM_DIER_CC3IE))
        ? 1UL : 0UL);
}

Referenced by TIM1_CC_IRQHandler(), TIM2_IRQHandler(), TIM3_IRQHandler(), TIM4_IRQHandler(), and TIM5_IRQHandler().

◆ HIERODULE_TIM_IsEnabled_IT_CC4()

uint32_t HIERODULE_TIM_IsEnabled_IT_CC4 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: 1 if the capture compare channel 4 interrupt is enabled, 0 otherwise.

TIM_DIER_CC4IE bit is isolated from the register with its bitmask and compared to the same bitmask instead of shifting since the amount of shift would depend on the bitmask.

Definition at line 1044 of file hierodule_tim.c.

{
    return ((READ_BIT(Timer->DIER, TIM_DIER_CC4IE) == (TIM_DIER_CC4IE))
        ? 1UL : 0UL);
}

Referenced by TIM1_CC_IRQHandler(), TIM2_IRQHandler(), TIM3_IRQHandler(), TIM4_IRQHandler(), and TIM5_IRQHandler().

◆ HIERODULE_TIM_IsEnabled_IT_UPD()

uint32_t HIERODULE_TIM_IsEnabled_IT_UPD ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: 1 if the update interrupt is enabled, 0 otherwise.

UIE bit is isolated from the register with its bitmask and compared to the same bitmask instead of shifting since the amount of shift would depend on the bitmask.

Definition at line 1012 of file hierodule_tim.c.

{
    return ((READ_BIT(Timer->DIER, TIM_DIER_UIE) == (TIM_DIER_UIE))
        ? 1UL : 0UL);
}

Referenced by TIM14_IRQHandler(), TIM16_IRQHandler(), TIM17_IRQHandler(), TIM1_BRK_TIM9_IRQHandler(), TIM1_BRK_UP_TRG_COM_IRQHandler(), TIM1_TRG_COM_TIM11_IRQHandler(), TIM1_UP_TIM10_IRQHandler(), TIM2_IRQHandler(), TIM3_IRQHandler(), TIM4_IRQHandler(), and TIM5_IRQHandler().

◆ HIERODULE_TIM_IsEnabledChannel()

uint32_t HIERODULE_TIM_IsEnabledChannel	(	TIM_TypeDef *	Timer,
		int8_t	Channel )

Parameters

Timer	Pointer to timer struct.
Channel	Integer to specify the channel, 1 to 4, negative for complimentary output channels.

Returns: 1 if the channel is enabled, 0 otherwise.

Fetches the bit mask of the selected channel from the array TimerChannel_EN and uses that to check the designated CCER register bit. Returns 1 if so and 0 otherwise.
Channel parameter is ensured to be a valid integer value beforehand to avoid failure.

Definition at line 753 of file hierodule_tim.c.

{
    if( (Channel > 0) && (Channel < 5) )
    {
        if( (READ_BIT(Timer->CCER, TimerChannel_EN[Channel-1]))
            == (TimerChannel_EN[Channel-1]))
        {
            return 1UL;
        }
        else
        {
            return 0UL;
        }
    }
    else if( (Channel < 0) && (Channel > -4) )
    {
        if( (READ_BIT(Timer->CCER, TimerChannel_EN[abs(Channel)+3]))
            == (TimerChannel_EN[abs(Channel)+3]))
        {
            return 1UL;
        }
        else
        {
            return 0UL;
        }
    }
    else
    {
        return 0UL;
    }
}

References TimerChannel_EN.

◆ HIERODULE_TIM_IsEnabledCounter()

uint32_t HIERODULE_TIM_IsEnabledCounter ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: 1 if the counter is enabled, 0 otherwise.

CEN bit is isolated from the register with its bitmask and compared to the same bitmask instead of shifting since the amount of shift would depend on the bitmask.

Definition at line 1088 of file hierodule_tim.c.

{
    return ((READ_BIT(Timer->CR1, TIM_CR1_CEN) == (TIM_CR1_CEN)) ? 1UL : 0UL);
}

◆ HIERODULE_TIM_IsSetFlag_BRK()

uint32_t HIERODULE_TIM_IsSetFlag_BRK ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: 1 if the interrupt flag is set. Returns 0 otherwise.

BIF bit is isolated from the register with its bitmask and compared to the same bitmask instead of shifting since the amount of shift would depend on the bitmask.

Definition at line 915 of file hierodule_tim.c.

{
    return ((READ_BIT(Timer->SR, TIM_SR_BIF) == (TIM_SR_BIF)) ? 1UL : 0UL);
}

Referenced by TIM17_IRQHandler(), TIM1_BRK_TIM9_IRQHandler(), and TIM1_BRK_UP_TRG_COM_IRQHandler().

◆ HIERODULE_TIM_IsSetFlag_CC1()

uint32_t HIERODULE_TIM_IsSetFlag_CC1 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: 1 if the interrupt flag is set. Returns 0 otherwise.

CC1IF bit is isolated from the register with its bitmask and compared to the same bitmask instead of shifting since the amount of shift would depend on the bitmask.

Definition at line 887 of file hierodule_tim.c.

{
    return ((READ_BIT(Timer->SR, TIM_SR_CC1IF) == (TIM_SR_CC1IF)) ? 1UL : 0UL);
}

Referenced by TIM14_IRQHandler(), TIM16_IRQHandler(), TIM17_IRQHandler(), TIM1_BRK_TIM9_IRQHandler(), TIM1_CC_IRQHandler(), TIM1_TRG_COM_TIM11_IRQHandler(), TIM1_UP_TIM10_IRQHandler(), TIM2_IRQHandler(), TIM3_IRQHandler(), TIM4_IRQHandler(), and TIM5_IRQHandler().

◆ HIERODULE_TIM_IsSetFlag_CC2()

uint32_t HIERODULE_TIM_IsSetFlag_CC2 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: 1 if the interrupt flag is set. Returns 0 otherwise.

CC2IF bit is isolated from the register with its bitmask and compared to the same bitmask instead of shifting since the amount of shift would depend on the bitmask.

Definition at line 894 of file hierodule_tim.c.

{
    return ((READ_BIT(Timer->SR, TIM_SR_CC2IF) == (TIM_SR_CC2IF)) ? 1UL : 0UL);
}

Referenced by TIM1_BRK_TIM9_IRQHandler(), TIM1_CC_IRQHandler(), TIM2_IRQHandler(), TIM3_IRQHandler(), TIM4_IRQHandler(), and TIM5_IRQHandler().

◆ HIERODULE_TIM_IsSetFlag_CC3()

uint32_t HIERODULE_TIM_IsSetFlag_CC3 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: 1 if the interrupt flag is set. Returns 0 otherwise.

CC3IF bit is isolated from the register with its bitmask and compared to the same bitmask instead of shifting since the amount of shift would depend on the bitmask.

Definition at line 901 of file hierodule_tim.c.

{
    return ((READ_BIT(Timer->SR, TIM_SR_CC3IF) == (TIM_SR_CC3IF)) ? 1UL : 0UL);
}

Referenced by TIM1_CC_IRQHandler(), TIM2_IRQHandler(), TIM3_IRQHandler(), TIM4_IRQHandler(), and TIM5_IRQHandler().

◆ HIERODULE_TIM_IsSetFlag_CC4()

uint32_t HIERODULE_TIM_IsSetFlag_CC4 ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: 1 if the interrupt flag is set. Returns 0 otherwise.

CC4IF bit is isolated from the register with its bitmask and compared to the same bitmask instead of shifting since the amount of shift would depend on the bitmask.

Definition at line 908 of file hierodule_tim.c.

{
    return ((READ_BIT(Timer->SR, TIM_SR_CC4IF) == (TIM_SR_CC4IF)) ? 1UL : 0UL);
}

Referenced by TIM1_CC_IRQHandler(), TIM2_IRQHandler(), TIM3_IRQHandler(), TIM4_IRQHandler(), and TIM5_IRQHandler().

◆ HIERODULE_TIM_IsSetFlag_UPD()

uint32_t HIERODULE_TIM_IsSetFlag_UPD ( TIM_TypeDef * Timer )

Parameters

Timer Pointer to timer struct.

Returns: 1 if the interrupt flag is set. Returns 0 otherwise.

UIF bit is isolated from the register with its bitmask and compared to the same bitmask instead of shifting since the amount of shift would depend on the bitmask.

Definition at line 880 of file hierodule_tim.c.

{
    return ((READ_BIT(Timer->SR, TIM_SR_UIF) == (TIM_SR_UIF)) ? 1UL : 0UL);
}

Referenced by TIM14_IRQHandler(), TIM16_IRQHandler(), TIM17_IRQHandler(), TIM1_BRK_TIM9_IRQHandler(), TIM1_BRK_UP_TRG_COM_IRQHandler(), TIM1_TRG_COM_TIM11_IRQHandler(), TIM1_UP_TIM10_IRQHandler(), TIM2_IRQHandler(), TIM3_IRQHandler(), TIM4_IRQHandler(), and TIM5_IRQHandler().

◆ HIERODULE_TIM_SetDutyCycle()

void HIERODULE_TIM_SetDutyCycle	(	TIM_TypeDef *	Timer,
		uint8_t	Channel,
		double	NormalizedDutyCycle )

Parameters

Timer	Pointer to timer struct.
Channel	Integer to specify the channel, 1 to 4, negative for complimentary output channels.
NormalizedDutyCycle	Duty cycle percentage, normalized.

Returns: None

Scaling ARR with the normalized duty cycle yields the value meant to be loaded to the designated CCR, the pointer to which is acquired with a call to ChannelSelector with the timer struct pointer and the corresponding element of the CCR variable offset array TimerChannel_CCR.
Channel parameter is ensured to be a valid integer value beforehand to avoid failure.

Definition at line 803 of file hierodule_tim.c.

{
    if( (Channel > 0) && (Channel < 5) )
    {
        (*(ChannelSelector(Timer, TimerChannel_CCR[Channel-1]))) =
            ((uint32_t)(READ_REG(Timer->ARR)))*NormalizedDutyCycle;
    }
}

References ChannelSelector(), and TimerChannel_CCR.

◆ HIERODULE_TIM_SetFrequency()

void HIERODULE_TIM_SetFrequency	(	TIM_TypeDef *	Timer,
		double	Frequency_Hz )

Parameters

Timer	Pointer to timer struct.
Frequency_Hz	Frequency in Hertz.

Returns: None

This is performed by updating ARR value while keeping PSC constant. PSC value and peripheral bus clock determine the base frequency. See GetBaseFreq for further info.

\(Frequency = Base Frequency / (ARR+1) \)
\(ARR = Base Frequency * Period - 1\)

Definition at line 678 of file hierodule_tim.c.

{
    WRITE_REG(Timer->ARR, GetBaseFreq(Timer)/Frequency_Hz-1.0);
}

References GetBaseFreq().

◆ HIERODULE_TIM_SetPeriod()

void HIERODULE_TIM_SetPeriod	(	TIM_TypeDef *	Timer,
		double	DurationSec )

Parameters

Timer	Pointer to timer struct.
DurationSec	Duration of period in seconds.

Returns: None

This is performed by updating ARR value while keeping PSC constant. PSC value and peripheral bus clock determine the base frequency. See GetBaseFreq for further info.

\(Period = (ARR+1) / Base Frequency \)
\(ARR = Base Frequency * Period - 1\)

Definition at line 661 of file hierodule_tim.c.

{
    WRITE_REG(Timer->ARR, GetBaseFreq(Timer)*DurationSec-1.0);
}

References GetBaseFreq().

◆ HIERODULE_TIM_SetRepetition()

void HIERODULE_TIM_SetRepetition	(	TIM_TypeDef *	Timer,
		uint32_t	Reps )

Parameters

Timer	Pointer to timer struct.
Reps	Number of repetitions.

Returns: None

Timer's RCR value is set to the input parameter. The UPD interrupt of the timer will get triggered after 0+Reps periods.
Keep in mind repetition value the hardware supports may not be as high as 65535, even though it's a 32 bit register. See the device manual to verify the maximum amount of repetitions allowed.
Note that this will only work if the timer has the repetition counter register.

Definition at line 705 of file hierodule_tim.c.

{
    WRITE_REG(Timer->RCR, Reps);
}

◆ TIM14_IRQHandler()

void TIM14_IRQHandler ( void )

extern

Returns: None

Performs a call to Check_IT for each flag set with its interrupt enabled if HIERODULE_TIM_CONVENIENT_IRQ is enabled, uses the plain ISR handler implemented by the user otherwise.

Definition at line 1885 of file hierodule_tim.c.

{
    #ifdef HIERODULE_TIM_CONVENIENT_IRQ 
        if(HIERODULE_TIM_IsEnabled_IT_UPD(TIM14) && HIERODULE_TIM_IsSetFlag_UPD(TIM14))
        {
            Check_IT(TIM14, UPD_Handler_TIM14, &HIERODULE_TIM_ClearFlag_UPD);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC1(TIM14) && HIERODULE_TIM_IsSetFlag_CC1(TIM14))
        {
            Check_IT(TIM14, CC1_Handler_TIM14, &HIERODULE_TIM_ClearFlag_CC1);
        }
    #else 
        TIM14_ISR();
    #endif 
}

References CC1_Handler_TIM14, Check_IT(), HIERODULE_TIM_ClearFlag_CC1(), HIERODULE_TIM_ClearFlag_UPD(), HIERODULE_TIM_IsEnabled_IT_CC1(), HIERODULE_TIM_IsEnabled_IT_UPD(), HIERODULE_TIM_IsSetFlag_CC1(), HIERODULE_TIM_IsSetFlag_UPD(), TIM14_ISR, and UPD_Handler_TIM14.

◆ TIM16_IRQHandler()

void TIM16_IRQHandler ( void )

extern

Returns: None

Performs a call to Check_IT for each flag set with its interrupt enabled if HIERODULE_TIM_CONVENIENT_IRQ is enabled, uses the plain ISR handler implemented by the user otherwise.

Definition at line 1915 of file hierodule_tim.c.

{
    #ifdef HIERODULE_TIM_CONVENIENT_IRQ 
        if(HIERODULE_TIM_IsEnabled_IT_UPD(TIM16) && HIERODULE_TIM_IsSetFlag_UPD(TIM16))
        {
            Check_IT(TIM16, UPD_Handler_TIM16, &HIERODULE_TIM_ClearFlag_UPD);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC1(TIM16) && HIERODULE_TIM_IsSetFlag_CC1(TIM16))
        {
            Check_IT(TIM16, CC1_Handler_TIM16, &HIERODULE_TIM_ClearFlag_CC1);
        }
    #else 
        TIM16_ISR();
    #endif 
}

References CC1_Handler_TIM16, Check_IT(), HIERODULE_TIM_ClearFlag_CC1(), HIERODULE_TIM_ClearFlag_UPD(), HIERODULE_TIM_IsEnabled_IT_CC1(), HIERODULE_TIM_IsEnabled_IT_UPD(), HIERODULE_TIM_IsSetFlag_CC1(), HIERODULE_TIM_IsSetFlag_UPD(), TIM16_ISR, and UPD_Handler_TIM16.

◆ TIM17_IRQHandler()

void TIM17_IRQHandler ( void )

extern

Returns: None

Performs a call to Check_IT for each flag set with its interrupt enabled if HIERODULE_TIM_CONVENIENT_IRQ is enabled, uses the plain ISR handler implemented by the user otherwise.

Definition at line 1945 of file hierodule_tim.c.

{
    #ifdef HIERODULE_TIM_CONVENIENT_IRQ 
        if(HIERODULE_TIM_IsEnabled_IT_BRK(TIM17) && HIERODULE_TIM_IsSetFlag_BRK(TIM17))
        {
            Check_IT(TIM17, BRK_Handler_TIM17, &HIERODULE_TIM_ClearFlag_BRK);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_UPD(TIM17) && HIERODULE_TIM_IsSetFlag_UPD(TIM17))
        {
            Check_IT(TIM17, UPD_Handler_TIM17, &HIERODULE_TIM_ClearFlag_UPD);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC1(TIM17) && HIERODULE_TIM_IsSetFlag_CC1(TIM17))
        {
            Check_IT(TIM17, CC1_Handler_TIM17, &HIERODULE_TIM_ClearFlag_CC1);
        }
    #else 
        TIM17_ISR();
    #endif 
}

References BRK_Handler_TIM17, CC1_Handler_TIM17, Check_IT(), HIERODULE_TIM_ClearFlag_BRK(), HIERODULE_TIM_ClearFlag_CC1(), HIERODULE_TIM_ClearFlag_UPD(), HIERODULE_TIM_IsEnabled_IT_BRK(), HIERODULE_TIM_IsEnabled_IT_CC1(), HIERODULE_TIM_IsEnabled_IT_UPD(), HIERODULE_TIM_IsSetFlag_BRK(), HIERODULE_TIM_IsSetFlag_CC1(), HIERODULE_TIM_IsSetFlag_UPD(), TIM17_ISR, and UPD_Handler_TIM17.

◆ TIM1_BRK_IRQHandler()

void TIM1_BRK_IRQHandler ( void )

extern

Returns: None

Performs a call to Check_IT for the break interrupt if HIERODULE_TIM_CONVENIENT_IRQ is enabled, uses the plain ISR handler implemented by the user otherwise.

Definition at line 1585 of file hierodule_tim.c.

{
    #ifdef HIERODULE_TIM_CONVENIENT_IRQ 
    Check_IT(TIM1, BRK_Handler_TIM1, &HIERODULE_TIM_ClearFlag_BRK);
    #else 
    TIM1_BRK_ISR();
    #endif 
}

References BRK_Handler_TIM1, Check_IT(), HIERODULE_TIM_ClearFlag_BRK(), and TIM1_BRK_ISR.

◆ TIM1_BRK_TIM9_IRQHandler()

void TIM1_BRK_TIM9_IRQHandler ( void )

extern

Returns: None

Performs a call to Check_IT for each flag set with its interrupt enabled if HIERODULE_TIM_CONVENIENT_IRQ is enabled, uses the plain ISR handler implemented by the user otherwise.

Definition at line 1608 of file hierodule_tim.c.

{
    #ifdef HIERODULE_TIM_CONVENIENT_IRQ 
    if(HIERODULE_TIM_IsEnabled_IT_BRK(TIM1) && HIERODULE_TIM_IsSetFlag_BRK(TIM1))
    {
        Check_IT(TIM1, BRK_Handler_TIM1, &HIERODULE_TIM_ClearFlag_BRK);
    }
    else if(HIERODULE_TIM_IsEnabled_IT_UPD(TIM9) && HIERODULE_TIM_IsSetFlag_UPD(TIM9))
    {
        Check_IT(TIM9, UPD_Handler_TIM9, &HIERODULE_TIM_ClearFlag_UPD);
    }
    else if(HIERODULE_TIM_IsEnabled_IT_CC1(TIM9) && HIERODULE_TIM_IsSetFlag_CC1(TIM9))
    {
        Check_IT(TIM9, CC1_Handler_TIM9, &HIERODULE_TIM_ClearFlag_CC1);
    }
    else if(HIERODULE_TIM_IsEnabled_IT_CC2(TIM9) && HIERODULE_TIM_IsSetFlag_CC2(TIM9))
    {
        Check_IT(TIM9, CC2_Handler_TIM9, &HIERODULE_TIM_ClearFlag_CC2);
    }
    #else 
    TIM1_BRK_TIM9_ISR();
    #endif 
}

◆ TIM1_BRK_UP_TRG_COM_IRQHandler()

void TIM1_BRK_UP_TRG_COM_IRQHandler ( void )

extern

Returns: None

Performs a call to Check_IT for each flag set with its interrupt enabled if HIERODULE_TIM_CONVENIENT_IRQ is enabled, uses the plain ISR handler implemented by the user otherwise.

Definition at line 1647 of file hierodule_tim.c.

{
    #ifdef HIERODULE_TIM_CONVENIENT_IRQ 
    if(HIERODULE_TIM_IsEnabled_IT_BRK(TIM1) && HIERODULE_TIM_IsSetFlag_BRK(TIM1))
    {
        Check_IT(TIM1, BRK_Handler_TIM1, &HIERODULE_TIM_ClearFlag_BRK);
    }
    else if(HIERODULE_TIM_IsEnabled_IT_UPD(TIM1) && HIERODULE_TIM_IsSetFlag_UPD(TIM1))
    {
        Check_IT(TIM1, UPD_Handler_TIM1, &HIERODULE_TIM_ClearFlag_UPD);
    }
    #else 
    TIM1_BRK_UP_TRG_COM_ISR();
    #endif 
}

References BRK_Handler_TIM1, Check_IT(), HIERODULE_TIM_ClearFlag_BRK(), HIERODULE_TIM_ClearFlag_UPD(), HIERODULE_TIM_IsEnabled_IT_BRK(), HIERODULE_TIM_IsEnabled_IT_UPD(), HIERODULE_TIM_IsSetFlag_BRK(), HIERODULE_TIM_IsSetFlag_UPD(), TIM1_BRK_UP_TRG_COM_ISR, and UPD_Handler_TIM1.

◆ TIM1_CC_IRQHandler()

void TIM1_CC_IRQHandler ( void )

extern

Returns: None

Performs a call to Check_IT for each flag set with its interrupt enabled if HIERODULE_TIM_CONVENIENT_IRQ is enabled, uses the plain ISR handler implemented by the user otherwise.

Definition at line 1545 of file hierodule_tim.c.

{
    #ifdef HIERODULE_TIM_CONVENIENT_IRQ 
        if(HIERODULE_TIM_IsEnabled_IT_CC1(TIM1) && HIERODULE_TIM_IsSetFlag_CC1(TIM1))
        {
            Check_IT(TIM1, CC1_Handler_TIM1, &HIERODULE_TIM_ClearFlag_CC1);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC2(TIM1) && HIERODULE_TIM_IsSetFlag_CC2(TIM1))
        {
            Check_IT(TIM1, CC2_Handler_TIM1, &HIERODULE_TIM_ClearFlag_CC2);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC3(TIM1) && HIERODULE_TIM_IsSetFlag_CC3(TIM1))
        {
            Check_IT(TIM1, CC3_Handler_TIM1, &HIERODULE_TIM_ClearFlag_CC3);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC4(TIM1) && HIERODULE_TIM_IsSetFlag_CC4(TIM1))
        {
            Check_IT(TIM1, CC4_Handler_TIM1, &HIERODULE_TIM_ClearFlag_CC4);
        }
    #else 
        TIM1_CC_ISR();
    #endif 
}

References CC1_Handler_TIM1, CC2_Handler_TIM1, CC3_Handler_TIM1, CC4_Handler_TIM1, Check_IT(), HIERODULE_TIM_ClearFlag_CC1(), HIERODULE_TIM_ClearFlag_CC2(), HIERODULE_TIM_ClearFlag_CC3(), HIERODULE_TIM_ClearFlag_CC4(), HIERODULE_TIM_IsEnabled_IT_CC1(), HIERODULE_TIM_IsEnabled_IT_CC2(), HIERODULE_TIM_IsEnabled_IT_CC3(), HIERODULE_TIM_IsEnabled_IT_CC4(), HIERODULE_TIM_IsSetFlag_CC1(), HIERODULE_TIM_IsSetFlag_CC2(), HIERODULE_TIM_IsSetFlag_CC3(), HIERODULE_TIM_IsSetFlag_CC4(), and TIM1_CC_ISR.

◆ TIM1_TRG_COM_TIM11_IRQHandler()

void TIM1_TRG_COM_TIM11_IRQHandler ( void )

extern

Returns: None

Performs a call to Check_IT for each flag set with its interrupt enabled if HIERODULE_TIM_CONVENIENT_IRQ is enabled, uses the plain ISR handler implemented by the user otherwise.

Definition at line 1853 of file hierodule_tim.c.

{
    #ifdef HIERODULE_TIM_CONVENIENT_IRQ 
        if(HIERODULE_TIM_IsEnabled_IT_UPD(TIM11) && HIERODULE_TIM_IsSetFlag_UPD(TIM11))
        {
            Check_IT(TIM11, UPD_Handler_TIM11, &HIERODULE_TIM_ClearFlag_UPD);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC1(TIM11) && HIERODULE_TIM_IsSetFlag_CC1(TIM11))
        {
            Check_IT(TIM11, CC1_Handler_TIM11, &HIERODULE_TIM_ClearFlag_CC1);
        }
    #else 
        TIM1_TRG_COM_TIM11_ISR();
    #endif 
}

References CC1_Handler_TIM11, Check_IT(), HIERODULE_TIM_ClearFlag_CC1(), HIERODULE_TIM_ClearFlag_UPD(), HIERODULE_TIM_IsEnabled_IT_CC1(), HIERODULE_TIM_IsEnabled_IT_UPD(), HIERODULE_TIM_IsSetFlag_CC1(), HIERODULE_TIM_IsSetFlag_UPD(), TIM1_TRG_COM_TIM11_ISR, and UPD_Handler_TIM11.

◆ TIM1_UP_IRQHandler()

void TIM1_UP_IRQHandler ( void )

extern

Returns: None

Performs a call to Check_IT for the update interrupt if HIERODULE_TIM_CONVENIENT_IRQ is enabled, uses the plain ISR handler implemented by the user otherwise.

Definition at line 1486 of file hierodule_tim.c.

{
    #ifdef HIERODULE_TIM_CONVENIENT_IRQ 
    Check_IT(TIM1, UPD_Handler_TIM1, &HIERODULE_TIM_ClearFlag_UPD);
    #else 
    TIM1_UP_ISR();
    #endif 
}

References Check_IT(), HIERODULE_TIM_ClearFlag_UPD(), TIM1_UP_ISR, and UPD_Handler_TIM1.

◆ TIM1_UP_TIM10_IRQHandler()

void TIM1_UP_TIM10_IRQHandler ( void )

extern

Returns: None

Performs a call to Check_IT for each flag set with its interrupt enabled if HIERODULE_TIM_CONVENIENT_IRQ is enabled, uses the plain ISR handler implemented by the user otherwise.

Definition at line 1510 of file hierodule_tim.c.

{
    #ifdef HIERODULE_TIM_CONVENIENT_IRQ 
    if(HIERODULE_TIM_IsEnabled_IT_UPD(TIM1) && HIERODULE_TIM_IsSetFlag_UPD(TIM1))
    {
        Check_IT(TIM1, UPD_Handler_TIM1, &HIERODULE_TIM_ClearFlag_UPD);
    }
    else if(HIERODULE_TIM_IsEnabled_IT_UPD(TIM10) && HIERODULE_TIM_IsSetFlag_UPD(TIM10))
    {
        Check_IT(TIM10, UPD_Handler_TIM10, &HIERODULE_TIM_ClearFlag_UPD);
    }
    else if(HIERODULE_TIM_IsEnabled_IT_CC1(TIM10) && HIERODULE_TIM_IsSetFlag_CC1(TIM10))
    {
        Check_IT(TIM10, CC1_Handler_TIM10, &HIERODULE_TIM_ClearFlag_CC1);
    }
    #else 
    TIM1_UP_TIM10_ISR();
    #endif 
}

References CC1_Handler_TIM10, Check_IT(), HIERODULE_TIM_ClearFlag_CC1(), HIERODULE_TIM_ClearFlag_UPD(), HIERODULE_TIM_IsEnabled_IT_CC1(), HIERODULE_TIM_IsEnabled_IT_UPD(), HIERODULE_TIM_IsSetFlag_CC1(), HIERODULE_TIM_IsSetFlag_UPD(), TIM1_UP_TIM10_ISR, UPD_Handler_TIM1, and UPD_Handler_TIM10.

◆ TIM2_IRQHandler()

void TIM2_IRQHandler ( void )

extern

Returns: None

Performs a call to Check_IT for each flag set with its interrupt enabled if HIERODULE_TIM_CONVENIENT_IRQ is enabled, uses the plain ISR handler implemented by the user otherwise.

Definition at line 1680 of file hierodule_tim.c.

{
    #ifdef HIERODULE_TIM_CONVENIENT_IRQ 
        if(HIERODULE_TIM_IsEnabled_IT_UPD(TIM2) && HIERODULE_TIM_IsSetFlag_UPD(TIM2))
        {
            Check_IT(TIM2, UPD_Handler_TIM2, &HIERODULE_TIM_ClearFlag_UPD);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC1(TIM2) && HIERODULE_TIM_IsSetFlag_CC1(TIM2))
        {
            Check_IT(TIM2, CC1_Handler_TIM2, &HIERODULE_TIM_ClearFlag_CC1);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC2(TIM2) && HIERODULE_TIM_IsSetFlag_CC2(TIM2))
        {
            Check_IT(TIM2, CC2_Handler_TIM2, &HIERODULE_TIM_ClearFlag_CC2);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC3(TIM2) && HIERODULE_TIM_IsSetFlag_CC3(TIM2))
        {
            Check_IT(TIM2, CC3_Handler_TIM2, &HIERODULE_TIM_ClearFlag_CC3);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC4(TIM2) && HIERODULE_TIM_IsSetFlag_CC4(TIM2))
        {
            Check_IT(TIM2, CC4_Handler_TIM2, &HIERODULE_TIM_ClearFlag_CC4);
        }
    #else 
        TIM2_ISR();
    #endif 
}

◆ TIM3_IRQHandler()

void TIM3_IRQHandler ( void )

extern

Returns: None

Performs a call to Check_IT for each flag set with its interrupt enabled if HIERODULE_TIM_CONVENIENT_IRQ is enabled, uses the plain ISR handler implemented by the user otherwise.

Definition at line 1722 of file hierodule_tim.c.

{
    #ifdef HIERODULE_TIM_CONVENIENT_IRQ 
        if(HIERODULE_TIM_IsEnabled_IT_UPD(TIM3) && HIERODULE_TIM_IsSetFlag_UPD(TIM3))
        {
            Check_IT(TIM3, UPD_Handler_TIM3, &HIERODULE_TIM_ClearFlag_UPD);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC1(TIM3) && HIERODULE_TIM_IsSetFlag_CC1(TIM3))
        {
            Check_IT(TIM3, CC1_Handler_TIM3, &HIERODULE_TIM_ClearFlag_CC1);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC2(TIM3) && HIERODULE_TIM_IsSetFlag_CC2(TIM3))
        {
            Check_IT(TIM3, CC2_Handler_TIM3, &HIERODULE_TIM_ClearFlag_CC2);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC3(TIM3) && HIERODULE_TIM_IsSetFlag_CC3(TIM3))
        {
            Check_IT(TIM3, CC3_Handler_TIM3, &HIERODULE_TIM_ClearFlag_CC3);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC4(TIM3) && HIERODULE_TIM_IsSetFlag_CC4(TIM3))
        {
            Check_IT(TIM3, CC4_Handler_TIM3, &HIERODULE_TIM_ClearFlag_CC4);
        }
    #else 
        TIM3_ISR();
    #endif 
}

◆ TIM4_IRQHandler()

void TIM4_IRQHandler ( void )

extern

Returns: None

Performs a call to Check_IT for each flag set with its interrupt enabled if HIERODULE_TIM_CONVENIENT_IRQ is enabled, uses the plain ISR handler implemented by the user otherwise.

Definition at line 1766 of file hierodule_tim.c.

{
    #ifdef HIERODULE_TIM_CONVENIENT_IRQ 
        if(HIERODULE_TIM_IsEnabled_IT_UPD(TIM4) && HIERODULE_TIM_IsSetFlag_UPD(TIM4))
        {
            Check_IT(TIM4, UPD_Handler_TIM4, &HIERODULE_TIM_ClearFlag_UPD);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC1(TIM4) && HIERODULE_TIM_IsSetFlag_CC1(TIM4))
        {
            Check_IT(TIM4, CC1_Handler_TIM4, &HIERODULE_TIM_ClearFlag_CC1);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC2(TIM4) && HIERODULE_TIM_IsSetFlag_CC2(TIM4))
        {
            Check_IT(TIM4, CC2_Handler_TIM4, &HIERODULE_TIM_ClearFlag_CC2);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC3(TIM4) && HIERODULE_TIM_IsSetFlag_CC3(TIM4))
        {
            Check_IT(TIM4, CC3_Handler_TIM4, &HIERODULE_TIM_ClearFlag_CC3);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC4(TIM4) && HIERODULE_TIM_IsSetFlag_CC4(TIM4))
        {
            Check_IT(TIM4, CC4_Handler_TIM4, &HIERODULE_TIM_ClearFlag_CC4);
        }
    #else 
        TIM4_ISR();
    #endif 
}

◆ TIM5_IRQHandler()

void TIM5_IRQHandler ( void )

extern

Returns: None

Performs a call to Check_IT for each flag set with its interrupt enabled if HIERODULE_TIM_CONVENIENT_IRQ is enabled, uses the plain ISR handler implemented by the user otherwise.

Definition at line 1811 of file hierodule_tim.c.

{
    #ifdef HIERODULE_TIM_CONVENIENT_IRQ 
        if(HIERODULE_TIM_IsEnabled_IT_UPD(TIM5) && HIERODULE_TIM_IsSetFlag_UPD(TIM5))
        {
            Check_IT(TIM5, UPD_Handler_TIM5, &HIERODULE_TIM_ClearFlag_UPD);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC1(TIM5) && HIERODULE_TIM_IsSetFlag_CC1(TIM5))
        {
            Check_IT(TIM5, CC1_Handler_TIM5, &HIERODULE_TIM_ClearFlag_CC1);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC2(TIM5) && HIERODULE_TIM_IsSetFlag_CC2(TIM5))
        {
            Check_IT(TIM5, CC2_Handler_TIM5, &HIERODULE_TIM_ClearFlag_CC2);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC3(TIM5) && HIERODULE_TIM_IsSetFlag_CC3(TIM5))
        {
            Check_IT(TIM5, CC3_Handler_TIM5, &HIERODULE_TIM_ClearFlag_CC3);
        }
        else if(HIERODULE_TIM_IsEnabled_IT_CC4(TIM5) && HIERODULE_TIM_IsSetFlag_CC4(TIM5))
        {
            Check_IT(TIM5, CC4_Handler_TIM5, &HIERODULE_TIM_ClearFlag_CC4);
        }
    #else 
        TIM5_ISR();
    #endif 
}

Macros

Typedefs

Functions

Detailed Description

Macro Definition Documentation

◆ HIERODULE_TIM_CONVENIENT_IRQ

◆ HIERODULE_TIM_HANDLE_IRQ

◆ HIERODULE_TIM_RESERVED

Typedef Documentation

◆ FUNC_POINTER

Function Documentation

◆ HIERODULE_TIM_Assign_ISR_BRK()

◆ HIERODULE_TIM_Assign_ISR_CC1()

◆ HIERODULE_TIM_Assign_ISR_CC2()

◆ HIERODULE_TIM_Assign_ISR_CC3()

◆ HIERODULE_TIM_Assign_ISR_CC4()

◆ HIERODULE_TIM_Assign_ISR_UPD()

◆ HIERODULE_TIM_Assign_TIM14_ISR()

◆ HIERODULE_TIM_Assign_TIM16_ISR()

◆ HIERODULE_TIM_Assign_TIM17_ISR()

◆ HIERODULE_TIM_Assign_TIM1_BRK_ISR()

◆ HIERODULE_TIM_Assign_TIM1_BRK_TIM9_ISR()

◆ HIERODULE_TIM_Assign_TIM1_BRK_UP_TRG_COM_ISR()

◆ HIERODULE_TIM_Assign_TIM1_CC_ISR()

◆ HIERODULE_TIM_Assign_TIM1_TRG_COM_TIM11_ISR()

◆ HIERODULE_TIM_Assign_TIM1_UP_ISR()

◆ HIERODULE_TIM_Assign_TIM1_UP_TIM10_ISR()

◆ HIERODULE_TIM_Assign_TIM2_ISR()

◆ HIERODULE_TIM_Assign_TIM3_ISR()

◆ HIERODULE_TIM_Assign_TIM4_ISR()

◆ HIERODULE_TIM_Assign_TIM5_ISR()

◆ HIERODULE_TIM_ClearCounter()

◆ HIERODULE_TIM_ClearFlag_BRK()

◆ HIERODULE_TIM_ClearFlag_CC1()

◆ HIERODULE_TIM_ClearFlag_CC2()

◆ HIERODULE_TIM_ClearFlag_CC3()

◆ HIERODULE_TIM_ClearFlag_CC4()

◆ HIERODULE_TIM_ClearFlag_UPD()

◆ HIERODULE_TIM_Disable_IT_BRK()

◆ HIERODULE_TIM_Disable_IT_CC1()

◆ HIERODULE_TIM_Disable_IT_CC2()

◆ HIERODULE_TIM_Disable_IT_CC3()

◆ HIERODULE_TIM_Disable_IT_CC4()

◆ HIERODULE_TIM_Disable_IT_UPD()

◆ HIERODULE_TIM_DisableAutomaticOutput()

◆ HIERODULE_TIM_DisableChannel()

◆ HIERODULE_TIM_DisableCounter()

◆ HIERODULE_TIM_DisableMainOutput()

◆ HIERODULE_TIM_Enable_IT_BRK()

◆ HIERODULE_TIM_Enable_IT_CC1()

◆ HIERODULE_TIM_Enable_IT_CC2()

◆ HIERODULE_TIM_Enable_IT_CC3()

◆ HIERODULE_TIM_Enable_IT_CC4()

◆ HIERODULE_TIM_Enable_IT_UPD()

◆ HIERODULE_TIM_EnableAutomaticOutput()

◆ HIERODULE_TIM_EnableChannel()

◆ HIERODULE_TIM_EnableCounter()

◆ HIERODULE_TIM_EnableMainOutput()

◆ HIERODULE_TIM_GetDutyCycle()

◆ HIERODULE_TIM_GetFrequency()

◆ HIERODULE_TIM_GetPeriod()

◆ HIERODULE_TIM_GetRepetition()

◆ HIERODULE_TIM_IsEnabled_IT_BRK()

◆ HIERODULE_TIM_IsEnabled_IT_CC1()

◆ HIERODULE_TIM_IsEnabled_IT_CC2()

◆ HIERODULE_TIM_IsEnabled_IT_CC3()

◆ HIERODULE_TIM_IsEnabled_IT_CC4()

◆ HIERODULE_TIM_IsEnabled_IT_UPD()

◆ HIERODULE_TIM_IsEnabledChannel()

◆ HIERODULE_TIM_IsEnabledCounter()

◆ HIERODULE_TIM_IsSetFlag_BRK()

◆ HIERODULE_TIM_IsSetFlag_CC1()

◆ HIERODULE_TIM_IsSetFlag_CC2()

◆ HIERODULE_TIM_IsSetFlag_CC3()

◆ HIERODULE_TIM_IsSetFlag_CC4()

◆ HIERODULE_TIM_IsSetFlag_UPD()

◆ HIERODULE_TIM_SetDutyCycle()

◆ HIERODULE_TIM_SetFrequency()

◆ HIERODULE_TIM_SetPeriod()

◆ HIERODULE_TIM_SetRepetition()