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/essemi/es32vf2264/libraries/ALD/ES32VF2264/Source/ald_timer.c

3643 lines
129 KiB
C
Raw Permalink Blame History

/**
*********************************************************************************
*
* @file ald_timer.c
* @brief TIMER module driver.
* This is the common part of the TIMER initialization
*
* @version V1.0
* @date 03 Mar. 2023
* @author AE Team
* @note
* Change Logs:
* Date Author Notes
* 03 Mar. 2023 Lisq The first version
*
* Copyright (C) Shanghai Eastsoft Microelectronics Co. Ltd. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
**********************************************************************************
*/
#include <string.h>
#include "ald_timer.h"
/** @addtogroup ES32VF2264_ALD
* @{
*/
/** @defgroup TIMER TIMER
* @brief TIMER module driver
* @{
*/
/** @defgroup TIMER_Private_Functions TIMER Private Functions
* @{
*/
static void timer_base_set_config(TIMER_TypeDef *TIMERx, ald_timer_base_init_t *init);
static void timer_oc1_set_config(TIMER_TypeDef *TIMERx, ald_timer_oc_init_t *oc_config);
static void timer_oc2_set_config(TIMER_TypeDef *TIMERx, ald_timer_oc_init_t *oc_config);
static void timer_oc3_set_config(TIMER_TypeDef *TIMERx, ald_timer_oc_init_t *oc_config);
static void timer_oc4_set_config(TIMER_TypeDef *TIMERx, ald_timer_oc_init_t *oc_config);
static void timer_ccx_channel_cmd(TIMER_TypeDef* TIMERx, ald_timer_channel_t ch, type_func_t state);
static void timer_ccxn_channel_cmd(TIMER_TypeDef* TIMERx, ald_timer_channel_t ch, type_func_t state);
static void timer_ti1_set_config(TIMER_TypeDef *TIMERx, ald_timer_ic_polarity_t polarity,
ald_timer_ic_select_t sel, uint32_t filter);
static void timer_ti1_set_config_stage(TIMER_TypeDef *TIMERx, ald_timer_ic_polarity_t polarity, uint32_t filter);
static void timer_ti2_set_config(TIMER_TypeDef *TIMERx, ald_timer_ic_polarity_t polarity,
ald_timer_ic_select_t sel, uint32_t filter);
static void timer_ti2_set_config_stage(TIMER_TypeDef *TIMERx, ald_timer_ic_polarity_t polarity, uint32_t filter);
static void timer_ti3_set_config(TIMER_TypeDef *TIMERx, ald_timer_ic_polarity_t polarity,
ald_timer_ic_select_t sel, uint32_t filter);
static void timer_ti4_set_config(TIMER_TypeDef *TIMERx, ald_timer_ic_polarity_t polarity,
ald_timer_ic_select_t sel, uint32_t filter);
static void timer_etr_set_config(TIMER_TypeDef* TIMERx, ald_timer_etr_psc_t psc, ald_timer_clock_polarity_t polarity, uint32_t filter);
static void timer_slave_set_config(ald_timer_handle_t *hperh, ald_timer_slave_config_t *config);
static void timer_dma_oc_cplt(void *arg);
static void timer_dma_capture_cplt(void *arg);
static void timer_dma_period_elapse_cplt(void *arg);
static void timer_dma_msel(TIMER_TypeDef *hperh, ald_dma_config_t *config);
/**
* @}
*/
/** @defgroup TIMER_Public_Functions TIMER Public Functions
* @{
*/
/** @defgroup TIMER_Public_Functions_Group1 TIMER Base functions
* @brief Time Base functions
*
* @verbatim
==============================================================================
##### Timer Base functions #####
==============================================================================
[..]
This section provides functions allowing to:
(+) Initialize and configure the TIMER base.
(+) Reset the TIMER base.
(+) Start the Time Base.
(+) Stop the Time Base.
(+) Start the Time Base and enable interrupt.
(+) Stop the Time Base and disable interrupt.
(+) Start the Time Base and enable DMA transfer.
(+) Stop the Time Base and disable DMA transfer.
@endverbatim
* @{
*/
/**
* @brief Initializes the TIMER Time base Unit according to the specified
* parameters in the timer_handle_t and create the associated handle.
* @param hperh: TIMER base handle
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_base_init(ald_timer_handle_t *hperh)
{
if (hperh == NULL)
return ALD_ERROR;
assert_param(IS_TIMER_INSTANCE(hperh->perh));
assert_param(IS_TIMER_COUNTER_MODE(hperh->init.mode));
assert_param(IS_TIMER_CLOCK_DIVISION(hperh->init.clk_div));
if (hperh->state == ALD_TIMER_STATE_RESET)
hperh->lock = UNLOCK;
hperh->state = ALD_TIMER_STATE_BUSY;
timer_base_set_config(hperh->perh, &hperh->init);
hperh->state = ALD_TIMER_STATE_READY;
return ALD_OK;
}
/**
* @brief Reset the TIMER base peripheral
* @param hperh: TIMER base handle
* @retval Status, see @ref ald_status_t.
*/
void ald_timer_base_reset(ald_timer_handle_t *hperh)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
hperh->state = ALD_TIMER_STATE_BUSY;
ALD_TIMER_DISABLE(hperh);
hperh->state = ALD_TIMER_STATE_RESET;
__UNLOCK(hperh);
return;
}
/**
* @brief Starts the TIMER Base generation.
* @param hperh: TIMER handle
* @retval None
*/
void ald_timer_base_start(ald_timer_handle_t *hperh)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
hperh->state = ALD_TIMER_STATE_BUSY;
ALD_TIMER_ENABLE(hperh);
hperh->state = ALD_TIMER_STATE_READY;
return;
}
/**
* @brief Stops the TIMER Base generation.
* @param hperh: TIMER handle
* @retval None
*/
void ald_timer_base_stop(ald_timer_handle_t *hperh)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
hperh->state = ALD_TIMER_STATE_BUSY;
ALD_TIMER_DISABLE(hperh);
hperh->state = ALD_TIMER_STATE_READY;
return;
}
/**
* @brief Starts the TIMER Base generation in interrupt mode.
* @param hperh: TIMER handle
* @retval None
*/
void ald_timer_base_start_by_it(ald_timer_handle_t *hperh)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_UPDATE, ENABLE);
ALD_TIMER_ENABLE(hperh);
return;
}
/**
* @brief Stops the TIMER Base generation in interrupt mode.
* @param hperh: TIMER handle
* @retval None
*/
void ald_timer_base_stop_by_it(ald_timer_handle_t *hperh)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_UPDATE, DISABLE);
ALD_TIMER_DISABLE(hperh);
return;
}
/**
* @brief Starts the TIMER Base generation in DMA mode.
* @param hperh: TIMER handle
* @param buf: The source Buffer address.
* @param len: The length of buffer to be transferred from memory to TIMER peripheral
* @param dma_ch: Channel of DMA.
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_base_start_by_dma(ald_timer_handle_t *hperh,
uint16_t *buf, uint32_t len, uint8_t dma_ch)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
if ((hperh->state == ALD_TIMER_STATE_BUSY))
return ALD_BUSY;
if ((hperh->state == ALD_TIMER_STATE_READY)) {
if (((uint32_t)buf == 0 ) || (len == 0))
return ALD_ERROR;
}
hperh->state = ALD_TIMER_STATE_BUSY;
if (hperh->hdma1.perh == NULL)
hperh->hdma1.perh = DMA;
hperh->hdma1.cplt_tc_cbk = timer_dma_period_elapse_cplt;
hperh->hdma1.cplt_tc_arg = (void *)hperh;
ald_dma_config_struct(&hperh->hdma1.config);
hperh->hdma1.config.src = (void *)buf;
hperh->hdma1.config.dst = (void *)&hperh->perh->AR;
hperh->hdma1.config.size = len;
hperh->hdma1.config.src_data_width = ALD_DMA_DATA_SIZE_HALFWORD;
hperh->hdma1.config.dst_data_width = ALD_DMA_DATA_SIZE_HALFWORD;
hperh->hdma1.config.src_inc = ALD_DMA_DATA_INC_ENABLE;
hperh->hdma1.config.dst_inc = ALD_DMA_DATA_INC_DISABLE;
hperh->hdma1.config.msigsel = ALD_DMA_MSIGSEL_TIMER_UPDATE;
hperh->hdma1.config.channel = dma_ch;
timer_dma_msel(hperh->perh, &hperh->hdma1.config);
ald_dma_config_basic(&hperh->hdma1);
ald_dma_interrupt_config(dma_ch, ALD_DMA_IT_FLAG_TC, ENABLE);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_UPDATE, ENABLE);
ALD_TIMER_ENABLE(hperh);
return ALD_OK;
}
/**
* @brief Stops the TIMER Base generation in DMA mode.
* @param hperh: TIMER handle
* @retval None
*/
void ald_timer_base_stop_by_dma(ald_timer_handle_t *hperh)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_UPDATE, DISABLE);
ALD_TIMER_DISABLE(hperh);
hperh->state = ALD_TIMER_STATE_READY;
return;
}
/**
* @}
*/
/** @defgroup TIMER_Public_Functions_Group2 TIMER Output Compare functions
* @brief Time Output Compare functions
*
* @verbatim
==============================================================================
##### Time Output Compare functions #####
==============================================================================
[..]
This section provides functions allowing to:
(+) Initialize and configure the TIMER Output Compare.
(+) Start the Time Output Compare.
(+) Stop the Time Output Compare.
(+) Start the Time Output Compare and enable interrupt.
(+) Stop the Time Output Compare and disable interrupt.
(+) Start the Time Output Compare and enable DMA transfer.
(+) Stop the Time Output Compare and disable DMA transfer.
@endverbatim
* @{
*/
/**
* @brief Initializes the TIMER Output Compare according to the specified
* parameters in the timer_handle_t and create the associated handle.
* @param hperh: TIMER handle
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_oc_init(ald_timer_handle_t *hperh)
{
return ald_timer_base_init(hperh);
}
/**
* @brief Starts the TIMER Output Compare signal generation.
* @param hperh: TIMER handle
* @param ch : TIMER Channel to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval None
*/
void ald_timer_oc_start(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CCX_INSTANCE(hperh->perh, ch));
timer_ccx_channel_cmd(hperh->perh, ch, ENABLE);
if (IS_TIMER_BREAK_INSTANCE(hperh->perh) != RESET)
ALD_TIMER_MOE_ENABLE(hperh);
ALD_TIMER_ENABLE(hperh);
return;
}
/**
* @brief Stops the TIMER Output Compare signal generation.
* @param hperh: TIMER handle
* @param ch: TIMER Channel to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval None
*/
void ald_timer_oc_stop(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CCX_INSTANCE(hperh->perh, ch));
timer_ccx_channel_cmd(hperh->perh, ch, DISABLE);
if (IS_TIMER_BREAK_INSTANCE(hperh->perh) != RESET)
ALD_TIMER_MOE_DISABLE(hperh);
ALD_TIMER_DISABLE(hperh);
hperh->state = ALD_TIMER_STATE_READY;
return;
}
/**
* @brief Starts the TIMER Output Compare signal generation in interrupt mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channel to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval None
*/
void ald_timer_oc_start_by_it(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CCX_INSTANCE(hperh->perh, ch));
switch (ch) {
case ALD_TIMER_CHANNEL_1:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC1, ENABLE);
break;
case ALD_TIMER_CHANNEL_2:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC2, ENABLE);
break;
case ALD_TIMER_CHANNEL_3:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC3, ENABLE);
break;
case ALD_TIMER_CHANNEL_4:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC4, ENABLE);
break;
default:
break;
}
timer_ccx_channel_cmd(hperh->perh, ch, ENABLE);
if (IS_TIMER_BREAK_INSTANCE(hperh->perh) != RESET)
ALD_TIMER_MOE_ENABLE(hperh);
ALD_TIMER_ENABLE(hperh);
return;
}
/**
* @brief Stops the TIMER Output Compare signal generation in interrupt mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channel to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval None
*/
void ald_timer_oc_stop_by_it(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CCX_INSTANCE(hperh->perh, ch));
switch (ch) {
case ALD_TIMER_CHANNEL_1:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC1, DISABLE);
break;
case ALD_TIMER_CHANNEL_2:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC2, DISABLE);
break;
case ALD_TIMER_CHANNEL_3:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC3, DISABLE);
break;
case ALD_TIMER_CHANNEL_4:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC4, DISABLE);
break;
default:
break;
}
timer_ccx_channel_cmd(hperh->perh, ch, DISABLE);
if (IS_TIMER_BREAK_INSTANCE(hperh->perh) != RESET)
ALD_TIMER_MOE_DISABLE(hperh);
ALD_TIMER_DISABLE(hperh);
hperh->state = ALD_TIMER_STATE_READY;
return;
}
/**
* @brief Starts the TIMER Output Compare signal generation in DMA mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @param buf: The source Buffer address.
* @param len: The length of buffer to be transferred from memory to TIMER peripheral
* @param dma_ch: Channel of DMA.
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_oc_start_by_dma(ald_timer_handle_t *hperh, ald_timer_channel_t ch,
uint16_t *buf, uint32_t len, uint8_t dma_ch)
{
assert_param(IS_TIMER_CCX_INSTANCE(hperh->perh, ch));
if ((hperh->state == ALD_TIMER_STATE_BUSY))
return ALD_BUSY;
if ((hperh->state == ALD_TIMER_STATE_READY)) {
if (((uint32_t)buf == 0 ) || (len == 0))
return ALD_ERROR;
}
hperh->state = ALD_TIMER_STATE_BUSY;
if (hperh->hdma1.perh == NULL)
hperh->hdma1.perh = DMA;
hperh->hdma1.cplt_tc_cbk = timer_dma_oc_cplt;
hperh->hdma1.cplt_tc_arg = (void *)hperh;
ald_dma_config_struct(&hperh->hdma1.config);
hperh->hdma1.config.src = (void *)buf;
hperh->hdma1.config.size = len;
hperh->hdma1.config.src_data_width = ALD_DMA_DATA_SIZE_HALFWORD;
hperh->hdma1.config.dst_data_width = ALD_DMA_DATA_SIZE_HALFWORD;
hperh->hdma1.config.src_inc = ALD_DMA_DATA_INC_ENABLE;
hperh->hdma1.config.dst_inc = ALD_DMA_DATA_INC_DISABLE;
hperh->hdma1.config.channel = dma_ch;
timer_dma_msel(hperh->perh, &hperh->hdma1.config);
switch (ch) {
case ALD_TIMER_CHANNEL_1:
hperh->hdma1.config.dst = (void *)&hperh->perh->CCVAL1;
hperh->hdma1.config.msigsel = ALD_DMA_MSIGSEL_TIMER_CH1;
ald_dma_config_basic(&hperh->hdma1);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC1, ENABLE);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_1;
break;
case ALD_TIMER_CHANNEL_2:
hperh->hdma1.config.dst = (void *)&hperh->perh->CCVAL2;
hperh->hdma1.config.msigsel = ALD_DMA_MSIGSEL_TIMER_CH2;
ald_dma_config_basic(&hperh->hdma1);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC2, ENABLE);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_2;
break;
case ALD_TIMER_CHANNEL_3:
hperh->hdma1.config.dst = (void *)&hperh->perh->CCVAL3;
hperh->hdma1.config.msigsel = ALD_DMA_MSIGSEL_TIMER_CH3;
ald_dma_config_basic(&hperh->hdma1);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC3, ENABLE);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_3;
break;
case ALD_TIMER_CHANNEL_4:
hperh->hdma1.config.dst = (void *)&hperh->perh->CCVAL4;
hperh->hdma1.config.msigsel = ALD_DMA_MSIGSEL_TIMER_CH4;
ald_dma_config_basic(&hperh->hdma1);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC4, ENABLE);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_4;
break;
default:
break;
}
ald_dma_interrupt_config(dma_ch, ALD_DMA_IT_FLAG_TC, ENABLE);
timer_ccx_channel_cmd(hperh->perh, ch, ENABLE);
if (IS_TIMER_BREAK_INSTANCE(hperh->perh) != RESET)
ALD_TIMER_MOE_ENABLE(hperh);
ALD_TIMER_ENABLE(hperh);
return ALD_OK;
}
/**
* @brief Stops the TIMER Output Compare signal generation in DMA mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval None
*/
void ald_timer_oc_stop_by_dma(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CCX_INSTANCE(hperh->perh, ch));
switch (ch) {
case ALD_TIMER_CHANNEL_1:
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC1, DISABLE);
break;
case ALD_TIMER_CHANNEL_2:
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC2, DISABLE);
break;
case ALD_TIMER_CHANNEL_3:
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC3, DISABLE);
break;
case ALD_TIMER_CHANNEL_4:
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC4, DISABLE);
break;
default:
break;
}
timer_ccx_channel_cmd(hperh->perh, ch, DISABLE);
if (IS_TIMER_BREAK_INSTANCE(hperh->perh) != RESET)
ALD_TIMER_MOE_DISABLE(hperh);
ALD_TIMER_DISABLE(hperh);
hperh->state = ALD_TIMER_STATE_READY;
return;
}
/**
* @}
*/
/** @defgroup TIMER_Public_Functions_Group3 TIMER PWM functions
* @brief TIMER PWM functions
*
* @verbatim
==============================================================================
##### Time PWM functions #####
==============================================================================
[..]
This section provides functions allowing to:
(+) Initialize and configure the TIMER PWM.
(+) Start the Time PWM.
(+) Stop the Time PWM.
(+) Start the Time PWM and enable interrupt.
(+) Stop the Time PWM and disable interrupt.
(+) Start the Time PWM and enable DMA transfer.
(+) Stop the Time PWM and disable DMA transfer.
@endverbatim
* @{
*/
/**
* @brief Initializes the TIMER PWM Time Base according to the specified
* parameters in the timer_handle_t and create the associated handle.
* @param hperh: TIMER handle
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_pwm_init(ald_timer_handle_t *hperh)
{
return ald_timer_base_init(hperh);
}
/**
* @brief Starts the PWM signal generation.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval None
*/
void ald_timer_pwm_start(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
ald_timer_oc_start(hperh, ch);
return;
}
/**
* @brief Stops the PWM signal generation.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval None
*/
void ald_timer_pwm_stop(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
ald_timer_oc_stop(hperh, ch);
return;
}
/**
* @brief Starts the PWM signal generation in interrupt mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channel to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval None
*/
void ald_timer_pwm_start_by_it(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
ald_timer_oc_start_by_it(hperh, ch);
return;
}
/**
* @brief Stops the PWM signal generation in interrupt mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval None
*/
void ald_timer_pwm_stop_by_it(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
ald_timer_oc_stop_by_it(hperh, ch);
return;
}
/**
* @brief Starts the TIMER PWM signal generation in DMA mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @param buf: The source Buffer address.
* @param len: The length of buffer to be transferred from memory to TIMER peripheral
* @param dma_ch: Channel of DMA.
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_pwm_start_by_dma(ald_timer_handle_t *hperh, ald_timer_channel_t ch,
uint16_t *buf, uint32_t len, uint8_t dma_ch)
{
return ald_timer_oc_start_by_dma(hperh, ch, buf, len, dma_ch);
}
/**
* @brief Stops the TIMER PWM signal generation in DMA mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval None
*/
void ald_timer_pwm_stop_by_dma(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
ald_timer_oc_stop_by_dma(hperh, ch);
return;
}
/**
* @brief Set the PWM freq.
* @param hperh: TIMER handle
* @param freq: PWM freq to set
* @retval None
*/
void ald_timer_pwm_set_freq(ald_timer_handle_t *hperh, uint32_t freq)
{
uint32_t _arr;
if (freq == 0)
return;
_arr = ald_cmu_get_pclk_clock() / (hperh->init.prescaler + 1) / freq - 1;
WRITE_REG(hperh->perh->AR, _arr);
hperh->init.period = _arr;
}
/**
* @brief Set the PWM duty.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @param duty: PWM duty to set [0, 100]
* @retval None
*/
void ald_timer_pwm_set_duty(ald_timer_handle_t *hperh, ald_timer_channel_t ch, uint16_t duty)
{
uint32_t tmp = (hperh->init.period + 1) * duty / 100;
if (ch == ALD_TIMER_CHANNEL_1)
WRITE_REG(hperh->perh->CCVAL1, tmp);
else if (ch == ALD_TIMER_CHANNEL_2)
WRITE_REG(hperh->perh->CCVAL2, tmp);
else if (ch == ALD_TIMER_CHANNEL_3)
WRITE_REG(hperh->perh->CCVAL3, tmp);
else if (ch == ALD_TIMER_CHANNEL_4)
WRITE_REG(hperh->perh->CCVAL4, tmp);
}
/**
* @brief Set capture the PWM.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be captured the PWM
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @retval None
*/
void ald_timer_pwm_set_input(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_PWM_INPUT_INSTANCE(hperh->perh, ch));
CLEAR_BIT(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK);
switch (ch) {
case ALD_TIMER_CHANNEL_1:
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_CC1SSEL_MSK, ALD_TIMER_IC_SEL_DIRECT << TIMER_CHMR1_CC1SSEL_POSS);
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_CC2SSEL_MSK, ALD_TIMER_IC_SEL_INDIRECT << TIMER_CHMR1_CC2SSEL_POSS);
MODIFY_REG(hperh->perh->CCEP, TIMER_CCEP_CC1POL_MSK, ALD_TIMER_IC_POLARITY_RISE << TIMER_CCEP_CC1POL_POS);
MODIFY_REG(hperh->perh->CCEP, TIMER_CCEP_CC1NPOL_MSK, ALD_TIMER_IC_POLARITY_RISE << TIMER_CCEP_CC1NPOL_POS);
MODIFY_REG(hperh->perh->CCEP, TIMER_CCEP_CC2POL_MSK, ALD_TIMER_IC_POLARITY_FALL << TIMER_CCEP_CC2POL_POS);
MODIFY_REG(hperh->perh->CCEP, TIMER_CCEP_CC2NPOL_MSK, ALD_TIMER_IC_POLARITY_FALL << TIMER_CCEP_CC2NPOL_POS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_TSSEL_MSK, ALD_TIMER_TS_TI1FP1 << TIMER_SMCON_TSSEL_POSS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK, ALD_TIMER_MODE_RESET << TIMER_SMCON_SMODS_POSS);
break;
case ALD_TIMER_CHANNEL_2:
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_CC1SSEL_MSK, ALD_TIMER_IC_SEL_INDIRECT << TIMER_CHMR1_CC1SSEL_POSS);
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_CC2SSEL_MSK, ALD_TIMER_IC_SEL_DIRECT << TIMER_CHMR1_CC2SSEL_POSS);
MODIFY_REG(hperh->perh->CCEP, TIMER_CCEP_CC1POL_MSK, ALD_TIMER_IC_POLARITY_RISE << TIMER_CCEP_CC1POL_POS);
MODIFY_REG(hperh->perh->CCEP, TIMER_CCEP_CC1NPOL_MSK, ALD_TIMER_IC_POLARITY_FALL << TIMER_CCEP_CC1NPOL_POS);
MODIFY_REG(hperh->perh->CCEP, TIMER_CCEP_CC2POL_MSK, ALD_TIMER_IC_POLARITY_FALL << TIMER_CCEP_CC2POL_POS);
MODIFY_REG(hperh->perh->CCEP, TIMER_CCEP_CC2NPOL_MSK, ALD_TIMER_IC_POLARITY_RISE << TIMER_CCEP_CC2NPOL_POS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_TSSEL_MSK, ALD_TIMER_TS_TI2FP2 << TIMER_SMCON_TSSEL_POSS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK, ALD_TIMER_MODE_RESET << TIMER_SMCON_SMODS_POSS);
break;
default:
break;
}
SET_BIT(hperh->perh->CCEP, TIMER_CCEP_CC1EN_MSK);
SET_BIT(hperh->perh->CCEP, TIMER_CCEP_CC2EN_MSK);
return;
}
/**
* @}
*/
/** @defgroup TIMER_Public_Functions_Group4 TIMER Input Capture functions
* @brief Time Input Capture functions
*
* @verbatim
==============================================================================
##### Time Input Capture functions #####
==============================================================================
[..]
This section provides functions allowing to:
(+) Initialize and configure the TIMER Input Capture.
(+) Start the Time Input Capture.
(+) Stop the Time Input Capture.
(+) Start the Time Input Capture and enable interrupt.
(+) Stop the Time Input Capture and disable interrupt.
(+) Start the Time Input Capture and enable DMA transfer.
(+) Stop the Time Input Capture and disable DMA transfer.
* @endverbatim
* @{
*/
/**
* @brief Initializes the TIMER Input Capture Time base according to the specified
* parameters in the timer_handle_t and create the associated handle.
* @param hperh: TIMER handle
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_ic_init(ald_timer_handle_t *hperh)
{
return ald_timer_base_init(hperh);
}
/**
* @brief Starts the TIMER Input Capture measurement.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval None
*/
void ald_timer_ic_start(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CCX_INSTANCE(hperh->perh, ch));
timer_ccx_channel_cmd(hperh->perh, ch, ENABLE);
ALD_TIMER_ENABLE(hperh);
return;
}
/**
* @brief Stops the TIMER Input Capture measurement.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval None
*/
void ald_timer_ic_stop(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CCX_INSTANCE(hperh->perh, ch));
timer_ccx_channel_cmd(hperh->perh, ch, DISABLE);
ALD_TIMER_DISABLE(hperh);
return;
}
/**
* @brief Starts the TIMER Input Capture measurement in interrupt mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval None
*/
void ald_timer_ic_start_by_it(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CCX_INSTANCE(hperh->perh, ch));
switch (ch) {
case ALD_TIMER_CHANNEL_1:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC1, ENABLE);
break;
case ALD_TIMER_CHANNEL_2:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC2, ENABLE);
break;
case ALD_TIMER_CHANNEL_3:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC3, ENABLE);
break;
case ALD_TIMER_CHANNEL_4:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC4, ENABLE);
break;
default:
break;
}
timer_ccx_channel_cmd(hperh->perh, ch, ENABLE);
ALD_TIMER_ENABLE(hperh);
return;
}
/**
* @brief Stops the TIMER Input Capture measurement in interrupt mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval None
*/
void ald_timer_ic_stop_by_it(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CCX_INSTANCE(hperh->perh, ch));
switch (ch) {
case ALD_TIMER_CHANNEL_1:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC1, DISABLE);
break;
case ALD_TIMER_CHANNEL_2:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC2, DISABLE);
break;
case ALD_TIMER_CHANNEL_3:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC3, DISABLE);
break;
case ALD_TIMER_CHANNEL_4:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC4, DISABLE);
break;
default:
break;
}
timer_ccx_channel_cmd(hperh->perh, ch, DISABLE);
ALD_TIMER_DISABLE(hperh);
return;
}
/**
* @brief Starts the TIMER Input Capture measurement in DMA mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @param buf: The destination Buffer address.
* @param len: The length of buffer to be transferred TIMER peripheral to memory
* @param dma_ch: Channel of DMA.
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_ic_start_by_dma(ald_timer_handle_t *hperh, ald_timer_channel_t ch,
uint16_t *buf, uint32_t len, uint8_t dma_ch)
{
assert_param(IS_TIMER_CCX_INSTANCE(hperh->perh, ch));
if ((hperh->state == ALD_TIMER_STATE_BUSY))
return ALD_BUSY;
if ((hperh->state == ALD_TIMER_STATE_READY)) {
if (((uint32_t)buf == 0 ) || (len == 0))
return ALD_ERROR;
}
hperh->state = ALD_TIMER_STATE_BUSY;
if (hperh->perh == NULL)
hperh->hdma1.perh = DMA;
hperh->hdma1.cplt_tc_cbk = timer_dma_capture_cplt;
hperh->hdma1.cplt_tc_arg = (void *)hperh;
ald_dma_config_struct(&hperh->hdma1.config);
hperh->hdma1.config.dst = (void *)buf;
hperh->hdma1.config.size = len;
hperh->hdma1.config.src_data_width = ALD_DMA_DATA_SIZE_HALFWORD;
hperh->hdma1.config.dst_data_width = ALD_DMA_DATA_SIZE_HALFWORD;
hperh->hdma1.config.src_inc = ALD_DMA_DATA_INC_DISABLE;
hperh->hdma1.config.dst_inc = ALD_DMA_DATA_INC_ENABLE;
hperh->hdma1.config.circle_mode = ENABLE;
hperh->hdma1.config.channel = dma_ch;
timer_dma_msel(hperh->perh, &hperh->hdma1.config);
switch (ch) {
case ALD_TIMER_CHANNEL_1:
hperh->hdma1.config.src = (void *)&hperh->perh->CCVAL1;
hperh->hdma1.config.msigsel = ALD_DMA_MSIGSEL_TIMER_CH1;
ald_dma_config_basic(&hperh->hdma1);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC1, ENABLE);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_1;
break;
case ALD_TIMER_CHANNEL_2:
hperh->hdma1.config.src = (void *)&hperh->perh->CCVAL2;
hperh->hdma1.config.msigsel = ALD_DMA_MSIGSEL_TIMER_CH2;
ald_dma_config_basic(&hperh->hdma1);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC2, ENABLE);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_2;
break;
case ALD_TIMER_CHANNEL_3:
hperh->hdma1.config.src = (void *)&hperh->perh->CCVAL3;
hperh->hdma1.config.msigsel = ALD_DMA_MSIGSEL_TIMER_CH3;
ald_dma_config_basic(&hperh->hdma1);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC3, ENABLE);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_3;
break;
case ALD_TIMER_CHANNEL_4:
hperh->hdma1.config.src = (void *)&hperh->perh->CCVAL4;
hperh->hdma1.config.msigsel = ALD_DMA_MSIGSEL_TIMER_CH4;
ald_dma_config_basic(&hperh->hdma1);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC4, ENABLE);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_4;
break;
default:
break;
}
ald_dma_interrupt_config(dma_ch, ALD_DMA_IT_FLAG_TC, ENABLE);
timer_ccx_channel_cmd(hperh->perh, ch, ENABLE);
ALD_TIMER_ENABLE(hperh);
return ALD_OK;
}
/**
* @brief Stops the TIMER Input Capture measurement in DMA mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval None
*/
void ald_timer_ic_stop_by_dma(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CCX_INSTANCE(hperh->perh, ch));
switch (ch) {
case ALD_TIMER_CHANNEL_1:
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC1, DISABLE);
break;
case ALD_TIMER_CHANNEL_2:
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC2, DISABLE);
break;
case ALD_TIMER_CHANNEL_3:
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC3, DISABLE);
break;
case ALD_TIMER_CHANNEL_4:
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC4, DISABLE);
break;
default:
break;
}
timer_ccx_channel_cmd(hperh->perh, ch, DISABLE);
ALD_TIMER_DISABLE(hperh);
hperh->state = ALD_TIMER_STATE_READY;
return;
}
/**
* @}
*/
/** @defgroup TIMER_Public_Functions_Group5 TIMER One Pulse functions
* @brief Time One Pulse functions
*
* @verbatim
==============================================================================
##### Time One Pulse functions #####
==============================================================================
[..]
This section provides functions allowing to:
(+) Initialize and configure the TIMER One Pulse.
(+) Start the Time One Pulse.
(+) Stop the Time One Pulse.
(+) Start the Time One Pulse and enable interrupt.
(+) Stop the Time One Pulse and disable interrupt.
(+) Start the Time One Pulse and enable DMA transfer.
(+) Stop the Time One Pulse and disable DMA transfer.
* @endverbatim
* @{
*/
/**
* @brief Initializes the TIMER One Pulse Time Base according to the specified
* parameters in the timer_handle_t and create the associated handle.
* @param hperh: TIMER handle
* @param mode: Select the One pulse mode.
* This parameter can be one of the following values:
* @arg TIMER_OP_MODE_SINGLE: Only one pulse will be generated.
* @arg TIMER_OP_MODE_REPEAT: Repetitive pulses wil be generated.
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_one_pulse_init(ald_timer_handle_t *hperh, ald_timer_op_mode_t mode)
{
if (hperh == NULL)
return ALD_ERROR;
assert_param(IS_TIMER_INSTANCE(hperh->perh));
assert_param(IS_TIMER_COUNTER_MODE(hperh->init.mode));
assert_param(IS_TIMER_CLOCK_DIVISION(hperh->init.clk_div));
assert_param(IS_TIMER_OP_MODE(mode));
if (hperh->state == ALD_TIMER_STATE_RESET)
hperh->lock = UNLOCK;
hperh->state = ALD_TIMER_STATE_BUSY;
timer_base_set_config(hperh->perh, &hperh->init);
MODIFY_REG(hperh->perh->CON1, TIMER_CON1_SPMEN_MSK, mode << TIMER_CON1_SPMEN_POS);
hperh->state = ALD_TIMER_STATE_READY;
return ALD_OK;
}
/**
* @brief Starts the TIMER One Pulse signal generation.
* @param hperh: TIMER One Pulse handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_OP_OUTPUT_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_OP_OUTPUT_CHANNEL_2: TIMER Channel 2 selected
* @retval None
*/
void ald_timer_one_pulse_start(ald_timer_handle_t *hperh, ald_timer_op_output_channel_t ch)
{
/* Enable the Capture compare and the Input Capture channels
* (in the OPM Mode the two possible channels that can be used are TIMER_CHANNEL_1 and TIMER_CHANNEL_2)
* if TIMER_CHANNEL_1 is used as output, the TIMER_CHANNEL_2 will be used as input and
* if TIMER_CHANNEL_1 is used as input, the TIMER_CHANNEL_2 will be used as output
* in all combinations, the TIMER_CHANNEL_1 and TIMER_CHANNEL_2 should be enabled together
*/
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, ENABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_2, ENABLE);
if (IS_TIMER_BREAK_INSTANCE(hperh->perh) != RESET)
ALD_TIMER_MOE_ENABLE(hperh);
return;
}
/**
* @brief Stops the TIMER One Pulse signal generation.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_OP_OUTPUT_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_OP_OUTPUT_CHANNEL_2: TIMER Channel 2 selected
* @retval None
*/
void ald_timer_one_pulse_stop(ald_timer_handle_t *hperh, ald_timer_op_output_channel_t ch)
{
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, DISABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_2, DISABLE);
if (IS_TIMER_BREAK_INSTANCE(hperh->perh) != RESET)
ALD_TIMER_MOE_DISABLE(hperh);
ALD_TIMER_DISABLE(hperh);
return;
}
/**
* @brief Starts the TIMER One Pulse signal generation in interrupt mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_OP_OUTPUT_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_OP_OUTPUT_CHANNEL_2: TIMER Channel 2 selected
* @retval None
*/
void ald_timer_one_pulse_start_by_it(ald_timer_handle_t *hperh, ald_timer_op_output_channel_t ch)
{
/* Enable the Capture compare and the Input Capture channels
* (in the OPM Mode the two possible channels that can be used are TIMER_CHANNEL_1 and TIMER_CHANNEL_2)
* if TIMER_CHANNEL_1 is used as output, the TIMER_CHANNEL_2 will be used as input and
* if TIMER_CHANNEL_1 is used as input, the TIMER_CHANNEL_2 will be used as output
* in all combinations, the TIMER_CHANNEL_1 and TIMER_CHANNEL_2 should be enabled together
*/
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC1, ENABLE);
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC2, ENABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, ENABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_2, ENABLE);
if (IS_TIMER_BREAK_INSTANCE(hperh->perh) != RESET)
ALD_TIMER_MOE_ENABLE(hperh);
return;
}
/**
* @brief Stops the TIMER One Pulse signal generation in interrupt mode.
* @param hperh : TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_OP_OUTPUT_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_OP_OUTPUT_CHANNEL_2: TIMER Channel 2 selected
* @retval None
*/
void ald_timer_one_pulse_stop_by_it(ald_timer_handle_t *hperh, ald_timer_op_output_channel_t ch)
{
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC1, DISABLE);
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC2, DISABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, DISABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_2, DISABLE);
if (IS_TIMER_BREAK_INSTANCE(hperh->perh) != RESET)
ALD_TIMER_MOE_DISABLE(hperh);
ALD_TIMER_DISABLE(hperh);
return;
}
/**
* @}
*/
/** @defgroup TIMER_Public_Functions_Group6 TIMER Encoder functions
* @brief TIMER Encoder functions
*
* @verbatim
==============================================================================
##### Time Encoder functions #####
==============================================================================
[..]
This section provides functions allowing to:
(+) Initialize and configure the TIMER Encoder.
(+) Start the Time Encoder.
(+) Stop the Time Encoder.
(+) Start the Time Encoder and enable interrupt.
(+) Stop the Time Encoder and disable interrupt.
(+) Start the Time Encoder and enable DMA transfer.
(+) Stop the Time Encoder and disable DMA transfer.
* @endverbatim
* @{
*/
/**
* @brief Initializes the TIMER Encoder Interface and create the associated handle.
* @param hperh: TIMER handle
* @param config: TIMER Encoder Interface configuration structure
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_encoder_init(ald_timer_handle_t *hperh, ald_timer_encoder_init_t *config)
{
if (hperh == NULL)
return ALD_ERROR;
assert_param(IS_TIMER_CC2_INSTANCE(hperh->perh));
assert_param(IS_TIMER_ENCODER_MODE(config->mode));
assert_param(IS_TIMER_IC_POLARITY(config->ic1_polarity));
assert_param(IS_TIMER_IC_POLARITY(config->ic2_polarity));
assert_param(IS_TIMER_IC_SELECT(config->ic1_sel));
assert_param(IS_TIMER_IC_SELECT(config->ic2_sel));
assert_param(IS_TIMER_IC_PSC(config->ic1_psc));
assert_param(IS_TIMER_IC_PSC(config->ic2_psc));
assert_param(IS_TIMER_IC_FILTER(config->ic1_filter));
assert_param(IS_TIMER_IC_FILTER(config->ic2_filter));
if (hperh->state == ALD_TIMER_STATE_RESET)
hperh->lock = UNLOCK;
hperh->state = ALD_TIMER_STATE_BUSY;
CLEAR_BIT(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK);
timer_base_set_config(hperh->perh, &hperh->init);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK, config->mode << TIMER_SMCON_SMODS_POSS);
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_CC1SSEL_MSK, config->ic1_sel << TIMER_CHMR1_CC1SSEL_POSS);
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_CC2SSEL_MSK, config->ic2_sel << TIMER_CHMR1_CC2SSEL_POSS);
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_IC1PRES_MSK, config->ic1_psc << TIMER_CHMR1_IC1PRES_POSS);
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_IC2PRES_MSK, config->ic2_psc << TIMER_CHMR1_IC2PRES_POSS);
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_I1FLT_MSK, config->ic1_filter << TIMER_CHMR1_I1FLT_POSS);
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_I2FLT_MSK, config->ic2_filter << TIMER_CHMR1_I2FLT_POSS);
MODIFY_REG(hperh->perh->CCEP, TIMER_CCEP_CC1POL_MSK, (config->ic1_polarity & 0x1) << TIMER_CCEP_CC1POL_POS);
MODIFY_REG(hperh->perh->CCEP, TIMER_CCEP_CC1NPOL_MSK, ((config->ic1_polarity >> 1) & 0x1) << TIMER_CCEP_CC1NPOL_POS);
MODIFY_REG(hperh->perh->CCEP, TIMER_CCEP_CC2POL_MSK, (config->ic2_polarity & 0x1) << TIMER_CCEP_CC2POL_POS);
MODIFY_REG(hperh->perh->CCEP, TIMER_CCEP_CC2NPOL_MSK, ((config->ic2_polarity >> 1) & 0x1) << TIMER_CCEP_CC2NPOL_POS);
hperh->state = ALD_TIMER_STATE_READY;
return ALD_OK;
}
/**
* @brief Starts the TIMER Encoder Interface.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_ALL: TIMER Channel 1 and TIMER Channel 2 are selected
* @retval None
*/
void ald_timer_encoder_start(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CC2_INSTANCE(hperh->perh));
switch (ch) {
case ALD_TIMER_CHANNEL_1:
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, ENABLE);
break;
case ALD_TIMER_CHANNEL_2:
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_2, ENABLE);
break;
default:
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, ENABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_2, ENABLE);
break;
}
ALD_TIMER_ENABLE(hperh);
return;
}
/**
* @brief Stops the TIMER Encoder Interface.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_ALL: TIMER Channel 1 and TIMER Channel 2 are selected
* @retval None
*/
void ald_timer_encoder_stop(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CC2_INSTANCE(hperh->perh));
switch (ch) {
case ALD_TIMER_CHANNEL_1:
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, DISABLE);
break;
case ALD_TIMER_CHANNEL_2:
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_2, DISABLE);
break;
default:
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, DISABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_2, DISABLE);
break;
}
ALD_TIMER_DISABLE(hperh);
return;
}
/**
* @brief Starts the TIMER Encoder Interface in interrupt mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_ALL: TIMER Channel 1 and TIMER Channel 2 are selected
* @retval None
*/
void ald_timer_encoder_start_by_it(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CC2_INSTANCE(hperh->perh));
switch (ch) {
case ALD_TIMER_CHANNEL_1:
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, ENABLE);
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC1, ENABLE);
break;
case ALD_TIMER_CHANNEL_2:
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_2, ENABLE);
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC2, ENABLE);
break;
default:
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, ENABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_2, ENABLE);
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC1, ENABLE);
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC2, ENABLE);
break;
}
ALD_TIMER_ENABLE(hperh);
return;
}
/**
* @brief Stops the TIMER Encoder Interface in interrupt mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_ALL: TIMER Channel 1 and TIMER Channel 2 are selected
* @retval None
*/
void ald_timer_encoder_stop_by_it(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CC2_INSTANCE(hperh->perh));
switch (ch) {
case ALD_TIMER_CHANNEL_1:
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, DISABLE);
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC1, DISABLE);
break;
case ALD_TIMER_CHANNEL_2:
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_2, DISABLE);
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC2, DISABLE);
break;
default:
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, DISABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_2, DISABLE);
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC1, DISABLE);
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC2, DISABLE);
break;
}
ALD_TIMER_DISABLE(hperh);
hperh->state = ALD_TIMER_STATE_READY;
return;
}
/**
* @brief Starts the TIMER Encoder Interface in DMA mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_ALL: TIMER Channel 1 and TIMER Channel 2 are selected
* @param buf1: The destination Buffer address. Reading data from CCR1.
* @param buf2: The destination Buffer address. Reading data from CCR2.
* @param len: The length of buffer to be transferred TIMER peripheral to memory
* @param dma_ch1: Channel of DMA.
* @param dma_ch2: Channel of DMA.
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_encoder_start_by_dma(ald_timer_handle_t *hperh, ald_timer_channel_t ch,
uint16_t *buf1, uint16_t *buf2, uint32_t len,
uint8_t dma_ch1, uint8_t dma_ch2)
{
assert_param(IS_TIMER_CC2_INSTANCE(hperh->perh));
if ((hperh->state == ALD_TIMER_STATE_BUSY))
return ALD_BUSY;
if ((hperh->state == ALD_TIMER_STATE_READY)) {
if (((uint32_t)buf1 == 0) || ((uint32_t)buf2 == 0) || (len == 0))
return ALD_ERROR;
}
if (hperh->hdma1.perh == NULL)
hperh->hdma1.perh = DMA;
if (hperh->hdma2.perh == NULL)
hperh->hdma2.perh = DMA;
hperh->state = ALD_TIMER_STATE_BUSY;
hperh->hdma1.cplt_tc_cbk = timer_dma_capture_cplt;
hperh->hdma1.cplt_tc_arg = (void *)hperh;
ald_dma_config_struct(&hperh->hdma1.config);
hperh->hdma1.config.size = len;
hperh->hdma1.config.src_data_width = ALD_DMA_DATA_SIZE_HALFWORD;
hperh->hdma1.config.dst_data_width = ALD_DMA_DATA_SIZE_HALFWORD;
hperh->hdma1.config.src_inc = ALD_DMA_DATA_INC_DISABLE;
hperh->hdma1.config.dst_inc = ALD_DMA_DATA_INC_ENABLE;
timer_dma_msel(hperh->perh, &hperh->hdma1.config);
switch (ch) {
case ALD_TIMER_CHANNEL_1:
hperh->hdma1.config.src = (void *)&hperh->perh->CCVAL1;
hperh->hdma1.config.dst = (void *)buf1;
hperh->hdma1.config.msigsel = ALD_DMA_MSIGSEL_TIMER_CH1;
hperh->hdma1.config.channel = dma_ch1;
ald_dma_config_basic(&hperh->hdma1);
ald_dma_interrupt_config(dma_ch1, ALD_DMA_IT_FLAG_TC, ENABLE);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC1, ENABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, ENABLE);
ALD_TIMER_ENABLE(hperh);
break;
case ALD_TIMER_CHANNEL_2:
hperh->hdma1.config.src = (void *)&hperh->perh->CCVAL2;
hperh->hdma1.config.dst = (void *)buf2;
hperh->hdma1.config.msigsel = ALD_DMA_MSIGSEL_TIMER_CH2;
hperh->hdma1.config.channel = dma_ch2;
ald_dma_config_basic(&hperh->hdma1);
ald_dma_interrupt_config(dma_ch2, ALD_DMA_IT_FLAG_TC, ENABLE);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC2, ENABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_2, ENABLE);
ALD_TIMER_ENABLE(hperh);
break;
default:
hperh->hdma2.cplt_tc_cbk = timer_dma_capture_cplt;
hperh->hdma2.cplt_tc_arg = (void *)hperh;
memcpy(&hperh->hdma2.config, &hperh->hdma1.config, sizeof(ald_dma_config_t));
hperh->hdma1.config.src = (void *)&hperh->perh->CCVAL1;
hperh->hdma1.config.dst = (void *)buf1;
hperh->hdma1.config.msigsel = ALD_DMA_MSIGSEL_TIMER_CH1;
hperh->hdma1.config.channel = dma_ch1;
ald_dma_config_basic(&hperh->hdma1);
ald_dma_interrupt_config(dma_ch1, ALD_DMA_IT_FLAG_TC, ENABLE);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC1, ENABLE);
hperh->hdma2.config.src = (void *)&hperh->perh->CCVAL2;
hperh->hdma2.config.dst = (void *)buf2;
hperh->hdma2.config.msigsel = ALD_DMA_MSIGSEL_TIMER_CH2;
hperh->hdma2.config.channel = dma_ch2;
ald_dma_config_basic(&hperh->hdma2);
ald_dma_interrupt_config(dma_ch2, ALD_DMA_IT_FLAG_TC, ENABLE);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC2, ENABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, ENABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_2, ENABLE);
ALD_TIMER_ENABLE(hperh);
break;
}
return ALD_OK;
}
/**
* @brief Stops the TIMER Encoder Interface in DMA mode.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_ALL: TIMER Channel 1 and TIMER Channel 2 are selected
* @retval None
*/
void ald_timer_encoder_stop_by_dma(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CC2_INSTANCE(hperh->perh));
switch (ch) {
case ALD_TIMER_CHANNEL_1:
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, DISABLE);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC1, DISABLE);
break;
case ALD_TIMER_CHANNEL_2:
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_2, DISABLE);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC2, DISABLE);
break;
default:
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, DISABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_2, DISABLE);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC1, DISABLE);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC2, DISABLE);
break;
}
ALD_TIMER_DISABLE(hperh);
hperh->state = ALD_TIMER_STATE_READY;
return;
}
/**
* @}
*/
/** @defgroup TIMER_Public_Functions_Group7 TIMER Hall Sensor functions
* @brief TIMER Hall Sensor functions
*
* @verbatim
==============================================================================
##### Time Hall Sensor functions #####
==============================================================================
[..]
This section provides functions allowing to:
(+) Initialize and configure the TIMER hall sensor.
(+) Start the hall sensor.
(+) Stop the hall sensor.
(+) Start the hall sensor and enable interrupt.
(+) Stop the hall sensor and disable interrupt.
(+) Start the hall sensor and enable DMA transfer.
(+) Stop the hal sensor and disable DMA transfer.
* @endverbatim
* @{
*/
/**
* @brief Initializes the TIMER Encoder Interface and create the associated handle.
* @param hperh: TIMER handle
* @param config: TIMER Encoder Interface configuration structure
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_hall_sensor_init(ald_timer_handle_t *hperh, ald_timer_hall_sensor_init_t *config)
{
ald_timer_oc_init_t oc;
assert_param(IS_TIMER_XOR_INSTANCE(hperh->perh));
assert_param(IS_TIMER_COUNTER_MODE(hperh->init.mode));
assert_param(IS_TIMER_CLOCK_DIVISION(hperh->init.clk_div));
assert_param(IS_TIMER_IC_POLARITY(config->polarity));
assert_param(IS_TIMER_IC_PSC(config->psc));
assert_param(IS_TIMER_IC_FILTER(config->filter));
if (hperh->state == ALD_TIMER_STATE_RESET)
hperh->lock = UNLOCK;
hperh->state = ALD_TIMER_STATE_READY;
timer_base_set_config(hperh->perh, &hperh->init);
timer_ti1_set_config(hperh->perh, config->polarity, ALD_TIMER_IC_SEL_TRC, config->filter);
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_IC1PRES_MSK, config->psc << TIMER_CHMR1_IC1PRES_POSS);
SET_BIT(hperh->perh->CON2, TIMER_CON2_I1FSEL_MSK);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_TSSEL_MSK, ALD_TIMER_TS_TI1F_ED << TIMER_SMCON_TSSEL_POSS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK, ALD_TIMER_MODE_RESET << TIMER_SMCON_SMODS_POSS);
oc.oc_mode = ALD_TIMER_OC_MODE_PWM2;
oc.pulse = config->delay;
oc.oc_polarity = ALD_TIMER_OC_POLARITY_HIGH;
oc.ocn_polarity = ALD_TIMER_OCN_POLARITY_HIGH;
oc.oc_fast_en = DISABLE;
oc.oc_idle = ALD_TIMER_OC_IDLE_RESET;
oc.ocn_idle = ALD_TIMER_OCN_IDLE_RESET;
timer_oc2_set_config(hperh->perh, &oc);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK, ALD_TIMER_TRGO_OC2REF << TIMER_SMCON_SMODS_POSS);
return ALD_OK;
}
/**
* @brief Starts the TIMER hall sensor interface.
* @param hperh: TIMER handle
* @retval None
*/
void ald_timer_hall_sensor_start(ald_timer_handle_t *hperh)
{
assert_param(IS_TIMER_XOR_INSTANCE(hperh->perh));
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, ENABLE);
ALD_TIMER_ENABLE(hperh);
return;
}
/**
* @brief Stops the TIMER hall sensor interface.
* @param hperh: TIMER handle
* @retval None
*/
void ald_timer_hall_sensor_stop(ald_timer_handle_t *hperh)
{
assert_param(IS_TIMER_XOR_INSTANCE(hperh->perh));
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, DISABLE);
ALD_TIMER_DISABLE(hperh);
return;
}
/**
* @brief Starts the TIMER hall sensor interface in interrupt mode.
* @param hperh: TIMER handle
* @retval None
*/
void ald_timer_hall_sensor_start_by_it(ald_timer_handle_t *hperh)
{
assert_param(IS_TIMER_XOR_INSTANCE(hperh->perh));
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC1, ENABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, ENABLE);
ALD_TIMER_ENABLE(hperh);
return;
}
/**
* @brief Stops the TIMER hall sensor interface in interrupt mode.
* @param hperh: TIMER handle
* @retval None
*/
void ald_timer_hall_sensor_stop_by_it(ald_timer_handle_t *hperh)
{
assert_param(IS_TIMER_XOR_INSTANCE(hperh->perh));
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, DISABLE);
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC1, DISABLE);
ALD_TIMER_DISABLE(hperh);
return;
}
/**
* @brief Starts the TIMER hall sensor interface in DMA mode.
* @param hperh: TIMER handle
* @param buf: The destination Buffer address. Reading data from CCR1.
* @param len: The length of buffer to be transferred TIMER peripheral to memory
* @param dma_ch: Channel of DMA.
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_hall_sensor_start_by_dma(ald_timer_handle_t *hperh,
uint16_t *buf, uint32_t len, uint8_t dma_ch)
{
assert_param(IS_TIMER_XOR_INSTANCE(hperh->perh));
if ((hperh->state == ALD_TIMER_STATE_BUSY))
return ALD_BUSY;
if ((hperh->state == ALD_TIMER_STATE_READY)) {
if (((uint32_t)buf == 0) || (len == 0))
return ALD_ERROR;
}
if (hperh->hdma1.perh == NULL)
hperh->hdma1.perh = DMA;
hperh->state = ALD_TIMER_STATE_BUSY;
hperh->hdma1.cplt_tc_cbk = timer_dma_capture_cplt;
hperh->hdma1.cplt_tc_arg = (void *)hperh;
ald_dma_config_struct(&hperh->hdma1.config);
hperh->hdma1.config.size = len;
hperh->hdma1.config.src_data_width = ALD_DMA_DATA_SIZE_HALFWORD;
hperh->hdma1.config.dst_data_width = ALD_DMA_DATA_SIZE_HALFWORD;
hperh->hdma1.config.src_inc = ALD_DMA_DATA_INC_DISABLE;
hperh->hdma1.config.dst_inc = ALD_DMA_DATA_INC_ENABLE;
timer_dma_msel(hperh->perh, &hperh->hdma1.config);
hperh->hdma1.config.src = (void *)&hperh->perh->CCVAL1;
hperh->hdma1.config.dst = (void *)buf;
hperh->hdma1.config.msigsel = ALD_DMA_MSIGSEL_TIMER_CH1;
hperh->hdma1.config.channel = dma_ch;
ald_dma_config_basic(&hperh->hdma1);
ald_dma_interrupt_config(dma_ch, ALD_DMA_IT_FLAG_TC, ENABLE);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC1, ENABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, ENABLE);
ALD_TIMER_ENABLE(hperh);
return ALD_OK;
}
/**
* @brief Stops the TIMER hall sensor interface in DMA mode.
* @param hperh: TIMER handle
* @retval None
*/
void ald_timer_hall_sensor_stop_by_dma(ald_timer_handle_t *hperh)
{
assert_param(IS_TIMER_XOR_INSTANCE(hperh->perh));
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC1, DISABLE);
timer_ccx_channel_cmd(hperh->perh, ALD_TIMER_CHANNEL_1, DISABLE);
ALD_TIMER_DISABLE(hperh);
return;
}
/**
* @}
*/
/** @defgroup TIMER_Public_Functions_Group8 TIMER complementary output compare functions
* @brief TIMER complementary output compare functions
*
* @verbatim
==============================================================================
##### Time complementary output compare functions #####
==============================================================================
[..]
This section provides functions allowing to:
(+) Start the Time complementary output compare.
(+) Stop the Time complementary output compare.
(+) Start the Time complementary output compare and enable interrupt.
(+) Stop the Time complementary output compare and disable interrupt.
(+) Start the Time complementary output compare and enable DMA transfer.
(+) Stop the Time complementary output compare and disable DMA transfer.
* @endverbatim
* @{
*/
/**
* @brief Starts the TIMER output compare signal generation on the complementary output.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @retval None
*/
void ald_timer_ocn_start(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CCXN_INSTANCE(hperh->perh, ch));
timer_ccxn_channel_cmd(hperh->perh, ch, ENABLE);
ALD_TIMER_MOE_ENABLE(hperh);
ALD_TIMER_ENABLE(hperh);
return;
}
/**
* @brief Stops the TIMER output compare signal generation on the complementary output.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @retval None
*/
void ald_timer_ocn_stop(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CCXN_INSTANCE(hperh->perh, ch));
timer_ccxn_channel_cmd(hperh->perh, ch, DISABLE);
ALD_TIMER_MOE_DISABLE(hperh);
ALD_TIMER_DISABLE(hperh);
return;
}
/**
* @brief Starts the TIMER output compare signal generation on the complementary output.
* in interrupt mode
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @retval None
*/
void ald_timer_ocn_start_by_it(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CCXN_INSTANCE(hperh->perh, ch));
switch (ch) {
case ALD_TIMER_CHANNEL_1:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC1, ENABLE);
break;
case ALD_TIMER_CHANNEL_2:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC2, ENABLE);
break;
case ALD_TIMER_CHANNEL_3:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC3, ENABLE);
break;
default:
break;
}
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_BREAK, ENABLE);
timer_ccxn_channel_cmd(hperh->perh, ch, ENABLE);
ALD_TIMER_MOE_ENABLE(hperh);
ALD_TIMER_ENABLE(hperh);
return;
}
/**
* @brief Stops the TIMER output compare signal generation on the complementary output.
* in interrupt mode
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @retval None
*/
void ald_timer_ocn_stop_by_it(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CCXN_INSTANCE(hperh->perh, ch));
switch (ch) {
case ALD_TIMER_CHANNEL_1:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC1, DISABLE);
break;
case ALD_TIMER_CHANNEL_2:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC2, DISABLE);
break;
case ALD_TIMER_CHANNEL_3:
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_CC3, DISABLE);
break;
default:
break;
}
if ((!(READ_BIT(hperh->perh->CCEP, TIMER_CCEP_CC1NE_MSK)))
&& (!(READ_BIT(hperh->perh->CCEP, TIMER_CCEP_CC2NE_MSK)))
&& (!(READ_BIT(hperh->perh->CCEP, TIMER_CCEP_CC3NE_MSK)))) {
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_BREAK, DISABLE);
}
timer_ccxn_channel_cmd(hperh->perh, ch, DISABLE);
ALD_TIMER_MOE_DISABLE(hperh);
ALD_TIMER_DISABLE(hperh);
return;
}
/**
* @brief Starts the TIMER output compare signal generation on the complementary output.
* in DMA mode
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @param buf: The destination Buffer address. Reading data from CCRx.
* @param len: The length of buffer to be transferred TIMER peripheral to memory
* @param dma_ch: Channel of DMA.
* @retval None
*/
ald_status_t ald_timer_ocn_start_by_dma(ald_timer_handle_t *hperh,
ald_timer_channel_t ch, uint16_t *buf, uint32_t len, uint8_t dma_ch)
{
assert_param(IS_TIMER_CCXN_INSTANCE(hperh->perh, ch));
if ((hperh->state == ALD_TIMER_STATE_BUSY))
return ALD_BUSY;
if ((hperh->state == ALD_TIMER_STATE_READY)) {
if (((uint32_t)buf == 0 ) || (len == 0))
return ALD_ERROR;
}
hperh->state = ALD_TIMER_STATE_BUSY;
if (hperh->hdma1.perh == NULL)
hperh->hdma1.perh = DMA;
hperh->hdma1.cplt_tc_cbk = timer_dma_oc_cplt;
hperh->hdma1.cplt_tc_arg = (void *)hperh;
ald_dma_config_struct(&hperh->hdma1.config);
hperh->hdma1.config.src = (void *)buf;
hperh->hdma1.config.size = len;
hperh->hdma1.config.src_data_width = ALD_DMA_DATA_SIZE_HALFWORD;
hperh->hdma1.config.dst_data_width = ALD_DMA_DATA_SIZE_HALFWORD;
hperh->hdma1.config.src_inc = ALD_DMA_DATA_INC_ENABLE;
hperh->hdma1.config.dst_inc = ALD_DMA_DATA_INC_DISABLE;
hperh->hdma1.config.channel = dma_ch;
hperh->hdma1.config.msel = ALD_DMA_MSEL_AD16C4T;
switch (ch) {
case ALD_TIMER_CHANNEL_1:
hperh->hdma1.config.dst = (void *)&hperh->perh->CCVAL1;
hperh->hdma1.config.msigsel = ALD_DMA_MSIGSEL_TIMER_CH1;
ald_dma_config_basic(&hperh->hdma1);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC1, ENABLE);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_1;
break;
case ALD_TIMER_CHANNEL_2:
hperh->hdma1.config.dst = (void *)&hperh->perh->CCVAL2;
hperh->hdma1.config.msigsel = ALD_DMA_MSIGSEL_TIMER_CH2;
ald_dma_config_basic(&hperh->hdma1);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC2, ENABLE);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_2;
break;
case ALD_TIMER_CHANNEL_3:
hperh->hdma1.config.dst = (void *)&hperh->perh->CCVAL3;
hperh->hdma1.config.msigsel = ALD_DMA_MSIGSEL_TIMER_CH3;
ald_dma_config_basic(&hperh->hdma1);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC3, ENABLE);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_3;
break;
default:
break;
}
ald_dma_interrupt_config(dma_ch, ALD_DMA_IT_FLAG_TC, ENABLE);
timer_ccx_channel_cmd(hperh->perh, ch, ENABLE);
ALD_TIMER_MOE_ENABLE(hperh);
ALD_TIMER_ENABLE(hperh);
return ALD_OK;
}
/**
* @brief Starts the TIMER output compare signal generation on the complementary output.
* in DMA mode
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @retval None
*/
void ald_timer_ocn_stop_by_dma(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CCXN_INSTANCE(hperh->perh, ch));
switch (ch) {
case ALD_TIMER_CHANNEL_1:
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC1, DISABLE);
break;
case ALD_TIMER_CHANNEL_2:
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC2, DISABLE);
break;
case ALD_TIMER_CHANNEL_3:
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_CC3, DISABLE);
break;
default:
break;
}
timer_ccxn_channel_cmd(hperh->perh, ch, DISABLE);
ALD_TIMER_MOE_DISABLE(hperh);
ALD_TIMER_DISABLE(hperh);
return;
}
/**
* @}
*/
/** @defgroup TIMER_Public_Functions_Group9 TIMER complementary PWM functions
* @brief TIMER complementary PWM functions
*
* @verbatim
==============================================================================
##### Time complementary PWM functions #####
==============================================================================
[..]
This section provides functions allowing to:
(+) Start the Time complementary PWM.
(+) Stop the Time complementary PWM.
(+) Start the Time complementary PWM and enable interrupt.
(+) Stop the Time complementary PWM and disable interrupt.
(+) Start the Time complementary PWM and enable DMA transfer.
(+) Stop the Time complementary PWM and disable DMA transfer.
* @endverbatim
* @{
*/
/**
* @brief Starts the TIMER PWM signal generation on the complementary output.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @retval None
*/
void ald_timer_pwmn_start(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
ald_timer_ocn_start(hperh, ch);
}
/**
* @brief Stops the TIMER PWM signal generation on the complementary output.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @retval None
*/
void ald_timer_pwmn_stop(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
ald_timer_ocn_stop(hperh, ch);
}
/**
* @brief Starts the TIMER PWM signal generation on the complementary output.
* in interrupt mode
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @retval None
*/
void ald_timer_pwmn_start_by_it(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
ald_timer_ocn_start_by_it(hperh, ch);
}
/**
* @brief Stops the TIMER PWM signal generation on the complementary output.
* in interrupt mode
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @retval None
*/
void ald_timer_pwmn_stop_by_it(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
ald_timer_ocn_stop_by_it(hperh, ch);
}
/**
* @brief Starts the TIMER PWM signal generation on the complementary output.
* in DMA mode
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @param buf: The destination Buffer address. Reading data from CCRx.
* @param len: The length of buffer to be transferred TIMER peripheral to memory
* @param dma_ch: Channel of DMA.
* @retval None
*/
ald_status_t ald_timer_pwmn_start_by_dma(ald_timer_handle_t *hperh,
ald_timer_channel_t ch, uint16_t *buf, uint32_t len, uint8_t dma_ch)
{
return ald_timer_ocn_start_by_dma(hperh, ch, buf, len, dma_ch);
}
/**
* @brief Starts the TIMER PWM signal generation on the complementary output.
* in DMA mode
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @retval None
*/
void ald_timer_pwmn_stop_by_dma(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
ald_timer_ocn_stop_by_dma(hperh, ch);
}
/**
* @}
*/
/** @defgroup TIMER_Public_Functions_Group10 TIMER complementary one pulse functions
* @brief TIMER complementary one pulse functions
*
* @verbatim
==============================================================================
##### Time complementary one pulse functions #####
==============================================================================
[..]
This section provides functions allowing to:
(+) Start the Time complementary one pulse.
(+) Stop the Time complementary one pulse.
(+) Start the Time complementary one pulse and enable interrupt.
(+) Stop the Time complementary one pulse and disable interrupt.
* @endverbatim
* @{
*/
/**
* @brief Starts the TIMER one pulse signal generation on the complementary output.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @retval None
*/
void ald_timer_one_pulse_n_start(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
ald_timer_ocn_start(hperh, ch);
}
/**
* @brief Stops the TIMER one pulse signal generation on the complementary output.
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @retval None
*/
void ald_timer_one_pulse_n_stop(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
ald_timer_ocn_stop(hperh, ch);
}
/**
* @brief Starts the TIMER one pulse signal generation on the complementary output.
* in interrupt mode
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @retval None
*/
void ald_timer_one_pulse_n_start_by_it(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
ald_timer_ocn_start_by_it(hperh, ch);
}
/**
* @brief Stops the TIMER one pulse signal generation on the complementary output.
* in interrupt mode
* @param hperh: TIMER handle
* @param ch: TIMER Channels to be disabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @retval None
*/
void ald_timer_one_pulse_n_stop_by_it(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
ald_timer_ocn_stop_by_it(hperh, ch);
}
/**
* @}
*/
/** @defgroup TIMER_Public_Functions_Group11 Peripheral Control functions
* @brief Peripheral Control functions
*
* @verbatim
==============================================================================
##### Peripheral Control functions #####
==============================================================================
[..]
This section provides functions allowing to:
(+) Configure The Input Output channels for OC, PWM, IC or One Pulse mode.
(+) Configure External Clock source.
(+) Configure Complementary channels, break features and dead timere.
(+) Configure Master and the Slave synchronization.
(+) Handle TIMER interrupt.
(+) Get TIMER compare register's vale.
(+) Configure TIMER interrupt ENABLE/DISABLE.
(+) Get TIMER interrupt source status.
(+) Get TIMER interrupt flag status.
(+) Clear TIMER interrupt flag.
@endverbatim
* @{
*/
/**
* @brief Initializes the TIMER Output Compare Channels according to the specified
* parameters in the timer_oc_init_t.
* @param hperh: TIMER handle
* @param config: TIMER Output Compare configuration structure
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_oc_config_channel(ald_timer_handle_t *hperh, ald_timer_oc_init_t* config, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CCX_INSTANCE(hperh->perh, ch));
assert_param(IS_TIMER_OC_MODE(config->oc_mode));
assert_param(IS_TIMER_OC_POLARITY(config->oc_polarity));
__LOCK(hperh);
hperh->state = ALD_TIMER_STATE_BUSY;
switch (ch) {
case ALD_TIMER_CHANNEL_1:
timer_oc1_set_config(hperh->perh, config);
break;
case ALD_TIMER_CHANNEL_2:
timer_oc2_set_config(hperh->perh, config);
break;
case ALD_TIMER_CHANNEL_3:
timer_oc3_set_config(hperh->perh, config);
break;
case ALD_TIMER_CHANNEL_4:
timer_oc4_set_config(hperh->perh, config);
break;
default:
break;
}
hperh->state = ALD_TIMER_STATE_READY;
__UNLOCK(hperh);
return ALD_OK;
}
/**
* @brief Initializes the TIMER Input Capture Channels according to the specified
* parameters in the timer_ic_init_t.
* @param hperh: TIMER handle
* @param config: TIMER Input Capture configuration structure
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3: TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4: TIMER Channel 4 selected
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_ic_config_channel(ald_timer_handle_t *hperh, ald_timer_ic_init_t* config, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CC2_INSTANCE(hperh->perh));
assert_param(IS_TIMER_IC_POLARITY(config->polarity));
assert_param(IS_TIMER_IC_SELECT(config->sel));
assert_param(IS_TIMER_IC_PSC(config->psc));
assert_param(IS_TIMER_IC_FILTER(config->filter));
__LOCK(hperh);
hperh->state = ALD_TIMER_STATE_BUSY;
switch (ch) {
case ALD_TIMER_CHANNEL_1:
timer_ti1_set_config(hperh->perh, config->polarity, config->sel, config->filter);
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_IC1PRES_MSK, config->psc << TIMER_CHMR1_IC1PRES_POSS);
break;
case ALD_TIMER_CHANNEL_2:
timer_ti2_set_config(hperh->perh, config->polarity, config->sel, config->filter);
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_IC2PRES_MSK, config->psc << TIMER_CHMR1_IC2PRES_POSS);
break;
case ALD_TIMER_CHANNEL_3:
timer_ti3_set_config(hperh->perh, config->polarity, config->sel, config->filter);
MODIFY_REG(hperh->perh->CHMR2, TIMER_CHMR2_IC3PRES_MSK, config->psc << TIMER_CHMR2_IC3PRES_POSS);
break;
case ALD_TIMER_CHANNEL_4:
timer_ti4_set_config(hperh->perh, config->polarity, config->sel, config->filter);
MODIFY_REG(hperh->perh->CHMR2, TIMER_CHMR2_IC4PRES_MSK, config->psc << TIMER_CHMR2_IC4PRES_POSS);
break;
default:
break;
}
hperh->state = ALD_TIMER_STATE_READY;
__UNLOCK(hperh);
return ALD_OK;
}
/**
* @brief Initializes the TIMER One Pulse Channels according to the specified
* parameters in the timer_one_pulse_init_t.
* @param hperh: TIMER handle
* @param config: TIMER One Pulse configuration structure
* @param ch_out: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @param ch_in: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2: TIMER Channel 2 selected
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_one_pulse_config_channel(ald_timer_handle_t *hperh, ald_timer_one_pulse_init_t *config,
ald_timer_channel_t ch_out, ald_timer_channel_t ch_in)
{
ald_timer_oc_init_t tmp;
assert_param(IS_TIMER_CC2_INSTANCE(hperh->perh));
assert_param(IS_TIMER_OC_MODE(config->mode));
assert_param(IS_TIMER_OC_POLARITY(config->oc_polarity));
assert_param(IS_TIMER_OCN_POLARITY(config->ocn_polarity));
assert_param(IS_TIMER_OCIDLE_STATE(config->oc_idle));
assert_param(IS_TIMER_OCNIDLE_STATE(config->ocn_idle));
assert_param(IS_TIMER_IC_POLARITY(config->polarity));
assert_param(IS_TIMER_IC_SELECT(config->sel));
assert_param(IS_TIMER_IC_FILTER(config->filter));
if (ch_out == ch_in)
return ALD_ERROR;
__LOCK(hperh);
hperh->state = ALD_TIMER_STATE_BUSY;
tmp.oc_mode = config->mode;
tmp.pulse = config->pulse;
tmp.oc_polarity = config->oc_polarity;
tmp.ocn_polarity = config->ocn_polarity;
tmp.oc_idle = config->oc_idle;
tmp.ocn_idle = config->ocn_idle;
switch (ch_out) {
case ALD_TIMER_CHANNEL_1:
timer_oc1_set_config(hperh->perh, &tmp);
break;
case ALD_TIMER_CHANNEL_2:
timer_oc2_set_config(hperh->perh, &tmp);
break;
default:
break;
}
switch (ch_in) {
case ALD_TIMER_CHANNEL_1:
timer_ti1_set_config(hperh->perh, config->polarity, config->sel, config->filter);
CLEAR_BIT(hperh->perh->CHMR1, TIMER_CHMR1_IC1PRES_MSK);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_TSSEL_MSK, ALD_TIMER_TS_TI1FP1 << TIMER_SMCON_TSSEL_POSS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK, ALD_TIMER_MODE_TRIG << TIMER_SMCON_SMODS_POSS);
break;
case ALD_TIMER_CHANNEL_2:
timer_ti2_set_config(hperh->perh, config->polarity, config->sel, config->filter);
CLEAR_BIT(hperh->perh->CHMR1, TIMER_CHMR1_IC2PRES_MSK);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_TSSEL_MSK, ALD_TIMER_TS_TI2FP2 << TIMER_SMCON_TSSEL_POSS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK, ALD_TIMER_MODE_TRIG << TIMER_SMCON_SMODS_POSS);
break;
default:
break;
}
hperh->state = ALD_TIMER_STATE_READY;
__UNLOCK(hperh);
return ALD_OK;
}
/**
* @brief Configures the OCRef clear feature
* @param hperh: TIMER handle
* @param config: pointer to a TIMER_ClearInputConfigTypeDef structure that
* contains the OCREF clear feature and parameters for the TIMER peripheral.
* @param ch: specifies the TIMER Channel
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1
* @arg TIMER_CHANNEL_2: TIMER Channel 2
* @arg TIMER_CHANNEL_3: TIMER Channel 3
* @arg TIMER_CHANNEL_4: TIMER Channel 4
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_config_oc_ref_clear(ald_timer_handle_t *hperh, ald_timer_clear_input_config_t *config, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CC2_INSTANCE(hperh->perh));
assert_param(IS_FUNC_STATE(config->state));
assert_param(IS_TIMER_CLEAR_INPUT_SOURCE(config->source));
assert_param(IS_TIMER_CLEAR_INPUT_POLARITY(config->polarity));
assert_param(IS_TIMER_ETR_PSC(config->psc));
assert_param(IS_TIMER_CHNREF_CLEAR(config->clrsel));
assert_param(IS_TIMER_IC_FILTER(config->filter));
if (config->source == ALD_TIMER_INPUT_NONE) {
timer_etr_set_config(hperh->perh, ALD_TIMER_ETR_PSC_DIV1, ALD_TIMER_CLK_POLARITY_NO_INV, 0);
}
else {
timer_etr_set_config(hperh->perh, config->psc,
(ald_timer_clock_polarity_t)config->polarity, config->filter);
}
if (config->clrsel == ALD_TIMER_CHNREF_CLR_CMP_IN) {
CLEAR_BIT(hperh->perh->SMCON, TIMER_SMCON_OCCS_MSK);
}
else {
SET_BIT(hperh->perh->SMCON, TIMER_SMCON_OCCS_MSK);
}
switch (ch) {
case ALD_TIMER_CHANNEL_1:
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_CH1OCLREN_MSK, config->state << TIMER_CHMR1_CH1OCLREN_POS);
break;
case ALD_TIMER_CHANNEL_2:
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_CH2OCLREN_MSK, config->state << TIMER_CHMR1_CH2OCLREN_POS);
break;
case ALD_TIMER_CHANNEL_3:
assert_param(IS_TIMER_CC4_INSTANCE(hperh->perh));
MODIFY_REG(hperh->perh->CHMR2, TIMER_CHMR2_CH3OCLREN_MSK, config->state << TIMER_CHMR2_CH3OCLREN_POS);
break;
case ALD_TIMER_CHANNEL_4:
assert_param(IS_TIMER_CC4_INSTANCE(hperh->perh));
MODIFY_REG(hperh->perh->CHMR2, TIMER_CHMR2_CH4OCLREN_MSK, config->state << TIMER_CHMR2_CH4OCLREN_POS);
break;
default:
break;
}
return ALD_OK;
}
/**
* @brief Configures the clock source to be used
* @param hperh: TIMER handle
* @param config: pointer to a timer_clock_config_t structure that
* contains the clock source information for the TIMER peripheral.
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_config_clock_source(ald_timer_handle_t *hperh, ald_timer_clock_config_t *config)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
assert_param(IS_TIMER_CLOCK_SOURCE(config->source));
assert_param(IS_TIMER_CLOCK_POLARITY(config->polarity));
assert_param(IS_TIMER_ETR_PSC(config->psc));
assert_param(IS_TIMER_IC_FILTER(config->filter));
__LOCK(hperh);
hperh->state = ALD_TIMER_STATE_BUSY;
WRITE_REG(hperh->perh->SMCON, 0x0);
switch (config->source) {
case ALD_TIMER_SRC_INTER:
CLEAR_BIT(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK);
break;
case ALD_TIMER_SRC_ETRMODE1:
timer_etr_set_config(hperh->perh, config->psc, config->polarity, config->filter);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_TSSEL_MSK, ALD_TIMER_TS_ETRF << TIMER_SMCON_TSSEL_POSS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK, ALD_TIMER_MODE_EXTERNAL1 << TIMER_SMCON_SMODS_POSS);
break;
case ALD_TIMER_SRC_ETRMODE2:
timer_etr_set_config(hperh->perh, config->psc, config->polarity, config->filter);
SET_BIT(hperh->perh->SMCON, TIMER_SMCON_ECM2EN_MSK);
break;
case ALD_TIMER_SRC_TI1:
timer_ti1_set_config_stage(hperh->perh, (ald_timer_ic_polarity_t)config->polarity, config->filter);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_TSSEL_MSK, ALD_TIMER_TS_TI1FP1 << TIMER_SMCON_TSSEL_POSS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK, ALD_TIMER_MODE_EXTERNAL1 << TIMER_SMCON_SMODS_POSS);
break;
case ALD_TIMER_SRC_TI2:
timer_ti2_set_config_stage(hperh->perh, (ald_timer_ic_polarity_t)config->polarity, config->filter);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_TSSEL_MSK, ALD_TIMER_TS_TI2FP2 << TIMER_SMCON_TSSEL_POSS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK, ALD_TIMER_MODE_EXTERNAL1 << TIMER_SMCON_SMODS_POSS);
break;
case ALD_TIMER_SRC_TI1ED:
timer_ti1_set_config_stage(hperh->perh, (ald_timer_ic_polarity_t)config->polarity, config->filter);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_TSSEL_MSK, ALD_TIMER_TS_TI1F_ED << TIMER_SMCON_TSSEL_POSS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK, ALD_TIMER_MODE_EXTERNAL1 << TIMER_SMCON_SMODS_POSS);
break;
case ALD_TIMER_SRC_ITR0:
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_TSSEL_MSK, ALD_TIMER_TS_ITR0 << TIMER_SMCON_TSSEL_POSS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK, ALD_TIMER_MODE_EXTERNAL1 << TIMER_SMCON_SMODS_POSS);
break;
case ALD_TIMER_SRC_ITR1:
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_TSSEL_MSK, ALD_TIMER_TS_ITR1 << TIMER_SMCON_TSSEL_POSS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK, ALD_TIMER_MODE_EXTERNAL1 << TIMER_SMCON_SMODS_POSS);
break;
case ALD_TIMER_SRC_ITR2:
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_TSSEL_MSK, ALD_TIMER_TS_ITR2 << TIMER_SMCON_TSSEL_POSS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK, ALD_TIMER_MODE_EXTERNAL1 << TIMER_SMCON_SMODS_POSS);
break;
case ALD_TIMER_SRC_ITR3:
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_TSSEL_MSK, ALD_TIMER_TS_ITR3 << TIMER_SMCON_TSSEL_POSS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK, ALD_TIMER_MODE_EXTERNAL1 << TIMER_SMCON_SMODS_POSS);
break;
default:
break;
}
hperh->state = ALD_TIMER_STATE_READY;
__UNLOCK(hperh);
return ALD_OK;
}
/**
* @brief Selects the signal connected to the TI1 input: direct from CH1_input
* or a XOR combination between CH1_input, CH2_input & CH3_input
* @param hperh: TIMER handle.
* @param ti1_select: Indicate whether or not channel 1 is connected to the
* output of a XOR gate.
* This parameter can be one of the following values:
* @arg 0: The TIMERx_CH1 pin is connected to TI1 input
* @arg 1: The TIMERx_CH1, CH2 and CH3
* pins are connected to the TI1 input (XOR combination)
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_config_ti1_input(ald_timer_handle_t *hperh, uint32_t ti1_select)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
MODIFY_REG(hperh->perh->CON2, TIMER_CON2_I1FSEL_MSK, ti1_select << TIMER_CON2_I1FSEL_POS);
return ALD_OK;
}
/**
* @brief Configures the TIMER in Slave mode
* @param hperh: TIMER handle.
* @param config: pointer to a timer_slave_config_t structure that
* contains the selected trigger (internal trigger input, filtered
* timerer input or external trigger input) and the Slave
* mode (Disable, Reset, Gated, Trigger, External clock mode 1).
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_slave_config_sync(ald_timer_handle_t *hperh, ald_timer_slave_config_t *config)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
assert_param(IS_TIMER_SLAVE_MODE(config->mode));
assert_param(IS_TIMER_TS(config->input));
assert_param(IS_TIMER_CLOCK_POLARITY(config->polarity));
assert_param(IS_TIMER_ETR_PSC(config->psc));
assert_param(IS_TIMER_IC_FILTER(config->filter));
__LOCK(hperh);
hperh->state = ALD_TIMER_STATE_BUSY;
timer_slave_set_config(hperh, config);
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_TRIGGER, DISABLE);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_TRIGGER, DISABLE);
hperh->state = ALD_TIMER_STATE_READY;
__UNLOCK(hperh);
return ALD_OK;
}
/**
* @brief Configures the TIMER in Slave mode in interrupt mode
* @param hperh: TIMER handle.
* @param config: pointer to a timer_slave_config_t structure that
* contains the selected trigger (internal trigger input, filtered
* timerer input or external trigger input) and the ) and the Slave
* mode (Disable, Reset, Gated, Trigger, External clock mode 1).
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_slave_config_sync_by_it(ald_timer_handle_t *hperh, ald_timer_slave_config_t *config)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
assert_param(IS_TIMER_SLAVE_MODE(config->mode));
assert_param(IS_TIMER_TS(config->input));
assert_param(IS_TIMER_CLOCK_POLARITY(config->polarity));
assert_param(IS_TIMER_ETR_PSC(config->psc));
assert_param(IS_TIMER_IC_FILTER(config->filter));
__LOCK(hperh);
hperh->state = ALD_TIMER_STATE_BUSY;
timer_slave_set_config(hperh, config);
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_TRIGGER, ENABLE);
ald_timer_dma_req_config(hperh, ALD_TIMER_DMA_TRIGGER, DISABLE);
hperh->state = ALD_TIMER_STATE_READY;
__UNLOCK(hperh);
return ALD_OK;
}
/**
* @brief Generate a software event
* @param hperh: TIMER handle
* @param event: specifies the event source.
* @retval Status, see @ref ald_status_t.
*/
ald_status_t ald_timer_generate_event(ald_timer_handle_t *hperh, ald_timer_event_source_t event)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
assert_param(IS_TIMER_EVENT_SOURCE(event));
__LOCK(hperh);
hperh->state = ALD_TIMER_STATE_BUSY;
WRITE_REG(hperh->perh->SGE, event);
hperh->state = ALD_TIMER_STATE_READY;
__UNLOCK(hperh);
return ALD_OK;
}
/**
* @brief Read the captured value from Capture Compare unit
* @param hperh: TIMER handle.
* @param ch: TIMER Channels to be enabled
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1 : TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2 : TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3 : TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4 : TIMER Channel 4 selected
* @retval Captured value
*/
uint32_t ald_timer_read_capture_value(ald_timer_handle_t *hperh, ald_timer_channel_t ch)
{
uint32_t tmp;
__LOCK(hperh);
hperh->state = ALD_TIMER_STATE_BUSY;
switch (ch) {
case ALD_TIMER_CHANNEL_1:
tmp = hperh->perh->CCVAL1;
break;
case ALD_TIMER_CHANNEL_2:
tmp = hperh->perh->CCVAL2;
break;
case ALD_TIMER_CHANNEL_3:
tmp = hperh->perh->CCVAL3;
break;
case ALD_TIMER_CHANNEL_4:
tmp = hperh->perh->CCVAL4;
break;
default:
tmp = hperh->perh->CCVAL1;
break;
}
hperh->state = ALD_TIMER_STATE_READY;
__UNLOCK(hperh);
return tmp;
}
/**
* @brief Sets TIMER output mode.
* @param hperh: TIMER handle.
* @param mode: TIMER output mode.
* @param ch: TIMER Channels.
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1 : TIMER Channel 1 selected
* @arg TIMER_CHANNEL_2 : TIMER Channel 2 selected
* @arg TIMER_CHANNEL_3 : TIMER Channel 3 selected
* @arg TIMER_CHANNEL_4 : TIMER Channel 4 selected
* @retval None
*/
void ald_timer_set_output_mode(ald_timer_handle_t *hperh, ald_timer_oc_mode_t mode, ald_timer_channel_t ch)
{
assert_param(IS_TIMER_CC2_INSTANCE(hperh->perh));
assert_param(IS_TIMER_OC_MODE(mode));
assert_param(IS_TIMER_CHANNELS(ch));
switch (ch) {
case ALD_TIMER_CHANNEL_1:
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_CH1OMOD_MSK, mode << TIMER_CHMR1_CH1OMOD_POSS);
break;
case ALD_TIMER_CHANNEL_2:
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_CH2OMOD_MSK, mode << TIMER_CHMR1_CH2OMOD_POSS);
break;
case ALD_TIMER_CHANNEL_3:
MODIFY_REG(hperh->perh->CHMR2, TIMER_CHMR2_CH3OMOD_MSK, mode << TIMER_CHMR2_CH3OMOD_POSS);
break;
case ALD_TIMER_CHANNEL_4:
MODIFY_REG(hperh->perh->CHMR2, TIMER_CHMR2_CH4OMOD_MSK, mode << TIMER_CHMR2_CH4OMOD_POSS);
break;
default:
break;
}
return;
}
/**
* @brief Configure the channel in commutation event.
* @param hperh: TIMER handel
* @param config: Parameters of the channel.
* @retval None
*/
void ald_timer_com_change_config(ald_timer_handle_t *hperh, ald_timer_com_channel_config_t *config)
{
uint32_t cm1, cm2, cce;
assert_param(IS_TIMER_COM_EVENT_INSTANCE(hperh->perh));
assert_param(IS_FUNC_STATE(config->ch[0].en));
assert_param(IS_FUNC_STATE(config->ch[0].n_en));
assert_param(IS_TIMER_OC_MODE(config->ch[0].mode));
assert_param(IS_FUNC_STATE(config->ch[1].en));
assert_param(IS_FUNC_STATE(config->ch[1].n_en));
assert_param(IS_TIMER_OC_MODE(config->ch[1].mode));
assert_param(IS_FUNC_STATE(config->ch[2].en));
assert_param(IS_FUNC_STATE(config->ch[2].n_en));
assert_param(IS_TIMER_OC_MODE(config->ch[2].mode));
ALD_TIMER_MOE_DISABLE(hperh);
ALD_TIMER_DISABLE(hperh);
cm1 = hperh->perh->CHMR1;
cm2 = hperh->perh->CHMR2;
cce = hperh->perh->CCEP;
MODIFY_REG(cm1, (0x7 << 4), (config->ch[0].mode << 4));
MODIFY_REG(cm1, (0x7 << 12), (config->ch[1].mode << 12));
MODIFY_REG(cm2, (0x7 << 4), (config->ch[2].mode << 4));
MODIFY_REG(cce, (0x1 << 0), (config->ch[0].en << 0));
MODIFY_REG(cce, (0x1 << 2), (config->ch[0].n_en << 2));
MODIFY_REG(cce, (0x1 << 4), (config->ch[1].en << 4));
MODIFY_REG(cce, (0x1 << 6), (config->ch[1].n_en << 6));
MODIFY_REG(cce, (0x1 << 8), (config->ch[2].en << 8));
MODIFY_REG(cce, (0x1 << 10), (config->ch[2].n_en << 10));
WRITE_REG(hperh->perh->CHMR1, cm1);
WRITE_REG(hperh->perh->CHMR2, cm2);
WRITE_REG(hperh->perh->CCEP, cce);
ALD_TIMER_MOE_ENABLE(hperh);
ALD_TIMER_ENABLE(hperh);
return;
}
/**
* @brief Configure the TIMER commutation event sequence.
* @param hperh: TIMER handel
* @param ts: the internal trigger corresponding to the timerer interfacing
* with the hall sensor.
* This parameter can be one of the following values:
* @arg TIMER_TS_ITR0
* @arg TIMER_TS_ITR1
* @arg TIMER_TS_ITR2
* @arg TIMER_TS_ITR3
* @param trgi: the commutation event source.
* This parameter can be one of the following values:
* @arg ENABLE: Commutation event source is TRGI
* @arg DISABLE: Commutation event source is set by software using the COMG bit
* @retval None
*/
void ald_timer_com_event_config(ald_timer_handle_t *hperh, ald_timer_ts_t ts, type_func_t trgi)
{
assert_param(IS_TIMER_COM_EVENT_INSTANCE(hperh->perh));
assert_param(IS_TIMER_TS(ts));
assert_param(IS_FUNC_STATE(trgi));
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_TSSEL_MSK, ts << TIMER_SMCON_TSSEL_POSS);
SET_BIT(hperh->perh->CON2, TIMER_CON2_CCPCEN_MSK);
MODIFY_REG(hperh->perh->CON2, TIMER_CON2_CCUSEL_MSK, trgi << TIMER_CON2_CCUSEL_POS);
return;
}
/**
* @brief Configure the TIMER commutation event sequence with interrupt.
* @param hperh: TIMER handel
* @param ts: the internal trigger corresponding to the timerer interfacing
* with the hall sensor.
* This parameter can be one of the following values:
* @arg TIMER_TS_ITR0
* @arg TIMER_TS_ITR1
* @arg TIMER_TS_ITR2
* @arg TIMER_TS_ITR3
* @param trgi: the commutation event source.
* This parameter can be one of the following values:
* @arg ENABLE: Commutation event source is TRGI
* @arg DISABLE: Commutation event source is set by software using the COMG bit
* @retval None
*/
void ald_timer_com_event_config_it(ald_timer_handle_t *hperh, ald_timer_ts_t ts, type_func_t trgi)
{
ald_timer_com_event_config(hperh, ts, trgi);
ald_timer_interrupt_config(hperh, ALD_TIMER_IT_COM, ENABLE);
}
/**
* @brief Configure the break, dead timere, lock level state.
* @param hperh: TIMER handle
* @param config: Pointer to the timer_break_dead_timere_t structure.
* @retval None
*/
void ald_timer_break_dead_time_config(ald_timer_handle_t *hperh, ald_timer_break_dead_time_t *config)
{
uint32_t tmp;
assert_param(IS_TIMER_BREAK_INSTANCE(hperh->perh));
assert_param(IS_FUNC_STATE(config->off_run));
assert_param(IS_FUNC_STATE(config->off_idle));
assert_param(IS_TIMER_CLOCK_LEVEL(config->lock_level));
assert_param(IS_TIMER_DEAD_TIMERE(config->dead_time));
assert_param(IS_FUNC_STATE(config->break_state));
assert_param(IS_TIMER_BREAK_POLARITY(config->polarity));
assert_param(IS_FUNC_STATE(config->auto_out));
tmp = READ_REG(hperh->perh->BDCFG);
MODIFY_REG(tmp, TIMER_BDCFG_OFFSSR_MSK, config->off_run << TIMER_BDCFG_OFFSSR_POS);
MODIFY_REG(tmp, TIMER_BDCFG_OFFSSI_MSK, config->off_idle << TIMER_BDCFG_OFFSSI_POS);
MODIFY_REG(tmp, TIMER_BDCFG_LOCKLVL_MSK, config->lock_level << TIMER_BDCFG_LOCKLVL_POSS);
MODIFY_REG(tmp, TIMER_BDCFG_DT_MSK, config->dead_time << TIMER_BDCFG_DT_POSS);
MODIFY_REG(tmp, TIMER_BDCFG_BRKEN_MSK, config->break_state << TIMER_BDCFG_BRKEN_POS);
MODIFY_REG(tmp, TIMER_BDCFG_BRKP_MSK, config->polarity << TIMER_BDCFG_BRKP_POS);
MODIFY_REG(tmp, TIMER_BDCFG_AOEN_MSK, config->auto_out << TIMER_BDCFG_AOEN_POS);
WRITE_REG(hperh->perh->BDCFG, tmp);
hperh->state = ALD_TIMER_STATE_READY;
return;
}
/**
* @brief Configure the master mode
* @param hperh: TIMER handle
* @param config: Pointer to the timer_master_config_t structure.
* @retval None
*/
void ald_timer_master_sync_config(ald_timer_handle_t *hperh, ald_timer_master_config_t *config)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
assert_param(IS_TIMER_MASTER_MODE_SEL(config->sel));
assert_param(IS_FUNC_STATE(config->master_en));
hperh->state = ALD_TIMER_STATE_BUSY;
MODIFY_REG(hperh->perh->CON2, TIMER_CON2_TRGOSEL_MSK, config->sel << TIMER_CON2_TRGOSEL_POSS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_MSCFG_MSK, config->master_en << TIMER_SMCON_MSCFG_POS);
hperh->state = ALD_TIMER_STATE_READY;
return;
}
/**
* @brief This function handles TIMER interrupts requests.
* @param hperh: TIMER handle
* @retval None
*/
void ald_timer_irq_handler(ald_timer_handle_t *hperh)
{
uint32_t reg = hperh->perh->IFM;
/* Capture or compare 1 event */
if (READ_BIT(reg, ALD_TIMER_FLAG_CC1)) {
ald_timer_clear_flag_status(hperh, ALD_TIMER_FLAG_CC1);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_1;
/* Input capture event */
if (READ_BIT(hperh->perh->CHMR1, TIMER_CHMR1_CC1SSEL_MSK)) {
if (hperh->capture_cbk)
hperh->capture_cbk(hperh);
}
else { /* Output compare event */
if (hperh->delay_elapse_cbk)
hperh->delay_elapse_cbk(hperh);
if (hperh->pwm_pulse_finish_cbk)
hperh->pwm_pulse_finish_cbk(hperh);
}
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_CLEARED;
}
/* Capture or compare 2 event */
if (READ_BIT(reg, ALD_TIMER_FLAG_CC2)) {
ald_timer_clear_flag_status(hperh, ALD_TIMER_FLAG_CC2);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_2;
/* Input capture event */
if (READ_BIT(hperh->perh->CHMR1, TIMER_CHMR1_CC2SSEL_MSK)) {
if (hperh->capture_cbk)
hperh->capture_cbk(hperh);
}
else { /* Output compare event */
if (hperh->delay_elapse_cbk)
hperh->delay_elapse_cbk(hperh);
if (hperh->pwm_pulse_finish_cbk)
hperh->pwm_pulse_finish_cbk(hperh);
}
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_CLEARED;
}
/* Capture or compare 3 event */
if (READ_BIT(reg, ALD_TIMER_FLAG_CC3)) {
ald_timer_clear_flag_status(hperh, ALD_TIMER_FLAG_CC3);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_3;
/* Input capture event */
if (READ_BIT(hperh->perh->CHMR2, TIMER_CHMR2_CC3SSEL_MSK)) {
if (hperh->capture_cbk)
hperh->capture_cbk(hperh);
}
else { /* Output compare event */
if (hperh->delay_elapse_cbk)
hperh->delay_elapse_cbk(hperh);
if (hperh->pwm_pulse_finish_cbk)
hperh->pwm_pulse_finish_cbk(hperh);
}
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_CLEARED;
}
/* Capture or compare 4 event */
if (READ_BIT(reg, ALD_TIMER_FLAG_CC4)) {
ald_timer_clear_flag_status(hperh, ALD_TIMER_FLAG_CC4);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_4;
/* Input capture event */
if (READ_BIT(hperh->perh->CHMR2, TIMER_CHMR2_CC4SSEL_MSK)) {
if (hperh->capture_cbk)
hperh->capture_cbk(hperh);
}
else { /* Output compare event */
if (hperh->delay_elapse_cbk)
hperh->delay_elapse_cbk(hperh);
if (hperh->pwm_pulse_finish_cbk)
hperh->pwm_pulse_finish_cbk(hperh);
}
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_CLEARED;
}
/* TIMER Update event */
if (READ_BIT(reg, ALD_TIMER_FLAG_UPDATE)) {
ald_timer_clear_flag_status(hperh, ALD_TIMER_FLAG_UPDATE);
if (hperh->period_elapse_cbk)
hperh->period_elapse_cbk(hperh);
}
/* TIMER Break input event */
if (READ_BIT(reg, ALD_TIMER_FLAG_BREAK)) {
ald_timer_clear_flag_status(hperh, ALD_TIMER_FLAG_BREAK);
if (hperh->break_cbk)
hperh->break_cbk(hperh);
}
/* TIMER Trigger detection event */
if (READ_BIT(reg, ALD_TIMER_FLAG_TRIGGER)) {
ald_timer_clear_flag_status(hperh, ALD_TIMER_FLAG_TRIGGER);
if (hperh->trigger_cbk)
hperh->trigger_cbk(hperh);
}
/* TIMER commutation event */
if (READ_BIT(reg, ALD_TIMER_FLAG_COM)) {
ald_timer_clear_flag_status(hperh, ALD_TIMER_FLAG_COM);
if (hperh->com_cbk)
hperh->com_cbk(hperh);
}
return;
}
/**
* @brief Configure DMA request source.
* @param hperh: TIMER handle
* @param req: DMA request source.
* @param state: New state of the specified DMA request.
* @retval None
*/
void ald_timer_dma_req_config(ald_timer_handle_t *hperh, ald_timer_dma_req_t req, type_func_t state)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
assert_param(IS_TIMER_DMA_REQ(req));
assert_param(IS_FUNC_STATE(state));
if (state == ENABLE)
SET_BIT(hperh->perh->DMAEN, req);
else
CLEAR_BIT(hperh->perh->DMAEN, req);
return;
}
/**
* @brief Enable/disable the specified TIMER interrupts.
* @param hperh: Pointer to a timer_handle_t structure.
* @param it: Specifies the timer interrupt sources to be enabled or disabled.
* This parameter can be one of the @ref timer_it_t.
* @param state: New state of the specified TIMER interrupts.
* This parameter can be:
* @arg ENABLE
* @arg DISABLE
* @retval None
*/
void ald_timer_interrupt_config(ald_timer_handle_t *hperh, ald_timer_it_t it, type_func_t state)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
assert_param(IS_TIMER_IT(it));
assert_param(IS_FUNC_STATE(state));
if (state == ENABLE)
SET_BIT(hperh->perh->IER, it);
else
SET_BIT(hperh->perh->IDR, it);
return;
}
/**
* @brief Get the status of TIMER interrupt source.
* @param hperh: Pointer to a timer_handle_t structure.
* @param it: Specifies the TIMER interrupt source.
* This parameter can be one of the @ref timer_it_t.
* @retval Status:
* - 0: RESET
* - 1: SET
*/
it_status_t ald_timer_get_it_status(ald_timer_handle_t *hperh, ald_timer_it_t it)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
assert_param(IS_TIMER_IT(it));
if (hperh->perh->IVS & it)
return SET;
return RESET;
}
/**
* @brief Get the status of TIMER interrupt flag.
* @param hperh: Pointer to a timer_handle_t structure.
* @param flag: Specifies the TIMER interrupt flag.
* This parameter can be one of the @ref timer_flag_t.
* @retval Status:
* - 0: RESET
* - 1: SET
*/
flag_status_t ald_timer_get_flag_status(ald_timer_handle_t *hperh, ald_timer_flag_t flag)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
assert_param(IS_TIMER_FLAG(flag));
if (hperh->perh->RIF & flag)
return SET;
return RESET;
}
/**
* @brief Clear the TIMER interrupt flag.
* @param hperh: Pointer to a timer_handle_t structure.
* @param flag: Specifies the TIMER interrupt flag.
* This parameter can be one of the @ref timer_flag_t.
* @retval None
*/
void ald_timer_clear_flag_status(ald_timer_handle_t *hperh, ald_timer_flag_t flag)
{
assert_param(IS_TIMER_INSTANCE(hperh->perh));
assert_param(IS_TIMER_FLAG(flag));
hperh->perh->ICR = flag;
return;
}
/**
* @}
*/
/** @defgroup TIMER_Public_Functions_Group12 Peripheral State functions
* @brief Peripheral State functions
*
* @verbatim
==============================================================================
##### Peripheral State functions #####
==============================================================================
[..]
This subsection permit to get in run-timere the status of the peripheral
and the data flow.
@endverbatim
* @{
*/
/**
* @brief Return the TIMER Base state
* @param hperh: TIMER handle
* @retval TIMER peripheral state
*/
ald_timer_state_t ald_timer_get_state(ald_timer_handle_t *hperh)
{
return hperh->state;
}
/**
* @}
*/
/**
* @}
*/
/** @addtogroup TIMER_Private_Functions
* @{
*/
/**
* @brief TIMER DMA out compare complete callback.
* @param arg: pointer to TIMER handle.
* @retval None
*/
void timer_dma_oc_cplt(void *arg)
{
ald_timer_handle_t *hperh = (ald_timer_handle_t *)arg;
if (hperh->delay_elapse_cbk)
hperh->delay_elapse_cbk(hperh);
if (hperh->pwm_pulse_finish_cbk)
hperh->pwm_pulse_finish_cbk(hperh);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_CLEARED;
return;
}
/**
* @brief TIMER DMA Capture complete callback.
* @param arg: pointer to TIMER handle.
* @retval None
*/
void timer_dma_capture_cplt(void *arg)
{
ald_timer_handle_t *hperh = (ald_timer_handle_t *)arg;
if (hperh->capture_cbk)
hperh->capture_cbk(hperh);
hperh->ch = ALD_TIMER_ACTIVE_CHANNEL_CLEARED;
return;
}
/**
* @brief TIMER DMA Period Elapse complete callback.
* @param arg: pointer to TIMER handle.
* @retval None
*/
void timer_dma_period_elapse_cplt(void *arg)
{
ald_timer_handle_t *hperh = (ald_timer_handle_t *)arg;
if (hperh->period_elapse_cbk)
hperh->period_elapse_cbk(hperh);
hperh->state = ALD_TIMER_STATE_READY;
return;
}
/**
* @brief Time Base configuration
* @param TIMERx: TIMER periheral
* @param init: TIMER Base configuration structure
* @retval None
*/
static void timer_base_set_config(TIMER_TypeDef *TIMERx, ald_timer_base_init_t *init)
{
assert_param(IS_TIMER_COUNTER_MODE(init->mode));
assert_param(IS_TIMER_CLOCK_DIVISION(init->clk_div));
if (init->mode == ALD_TIMER_CNT_MODE_UP || init->mode == ALD_TIMER_CNT_MODE_DOWN) {
CLEAR_BIT(TIMERx->CON1, TIMER_CON1_CMSEL_MSK);
MODIFY_REG(TIMERx->CON1, TIMER_CON1_DIRSEL_MSK, init->mode << TIMER_CON1_DIRSEL_POS);
}
else {
MODIFY_REG(TIMERx->CON1, TIMER_CON1_CMSEL_MSK, (init->mode - 1) << TIMER_CON1_CMSEL_POSS);
}
if (IS_TIMER_CLOCK_DIVISION_INSTANCE(TIMERx))
MODIFY_REG(TIMERx->CON1, TIMER_CON1_DFCKSEL_MSK, init->clk_div << TIMER_CON1_DFCKSEL_POSS);
WRITE_REG(TIMERx->AR, init->period);
WRITE_REG(TIMERx->PRES, init->prescaler);
if (IS_TIMER_REPETITION_COUNTER_INSTANCE(TIMERx))
WRITE_REG(TIMERx->REPAR, init->re_cnt);
return;
}
/**
* @brief Time Ouput Compare 1 configuration
* @param TIMERx: Select the TIMER peripheral
* @param oc_config: The ouput configuration structure
* @retval None
*/
static void timer_oc1_set_config(TIMER_TypeDef *TIMERx, ald_timer_oc_init_t *oc_config)
{
CLEAR_BIT(TIMERx->CCEP, TIMER_CCEP_CC1EN_MSK);
CLEAR_BIT(TIMERx->CHMR1, TIMER_CHMR1_CH1OMOD_MSK);
CLEAR_BIT(TIMERx->CHMR1, TIMER_CHMR1_CC1SSEL_MSK);
MODIFY_REG(TIMERx->CHMR1, TIMER_CHMR1_CH1OMOD_MSK, oc_config->oc_mode << TIMER_CHMR1_CH1OMOD_POSS);
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC1POL_MSK, oc_config->oc_polarity << TIMER_CCEP_CC1POL_POS);
if (IS_TIMER_CCXN_INSTANCE(TIMERx, ALD_TIMER_CHANNEL_1)) {
assert_param(IS_TIMER_OCN_POLARITY(oc_config->ocn_polarity));
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC1NPOL_MSK, oc_config->ocn_polarity << TIMER_CCEP_CC1NPOL_POS);
CLEAR_BIT(TIMERx->CCEP, TIMER_CCEP_CC1NE_MSK);
}
if (IS_TIMER_BREAK_INSTANCE(TIMERx)) {
assert_param(IS_TIMER_OCNIDLE_STATE(oc_config->ocn_idle));
assert_param(IS_TIMER_OCIDLE_STATE(oc_config->oc_idle));
MODIFY_REG(TIMERx->CON2, TIMER_CON2_OISS1_MSK, oc_config->oc_idle << TIMER_CON2_OISS1_POS);
MODIFY_REG(TIMERx->CON2, TIMER_CON2_OISS1N_MSK, oc_config->ocn_idle << TIMER_CON2_OISS1N_POS);
}
WRITE_REG(TIMERx->CCVAL1, oc_config->pulse);
}
/**
* @brief Time Ouput Compare 2 configuration
* @param TIMERx: Select the TIMER peripheral
* @param oc_config: The ouput configuration structure
* @retval None
*/
static void timer_oc2_set_config(TIMER_TypeDef *TIMERx, ald_timer_oc_init_t *oc_config)
{
CLEAR_BIT(TIMERx->CCEP, TIMER_CCEP_CC2EN_MSK);
CLEAR_BIT(TIMERx->CHMR1, TIMER_CHMR1_CH2OMOD_MSK);
CLEAR_BIT(TIMERx->CHMR1, TIMER_CHMR1_CC2SSEL_MSK);
MODIFY_REG(TIMERx->CHMR1, TIMER_CHMR1_CH2OMOD_MSK, oc_config->oc_mode << TIMER_CHMR1_CH2OMOD_POSS);
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC2POL_MSK, oc_config->oc_polarity << TIMER_CCEP_CC2POL_POS);
if (IS_TIMER_CCXN_INSTANCE(TIMERx, ALD_TIMER_CHANNEL_2)) {
assert_param(IS_TIMER_OCN_POLARITY(oc_config->ocn_polarity));
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC2NPOL_MSK, oc_config->ocn_polarity << TIMER_CCEP_CC2NPOL_POS);
CLEAR_BIT(TIMERx->CCEP, TIMER_CCEP_CC2NE_MSK);
}
if (IS_TIMER_BREAK_INSTANCE(TIMERx)) {
assert_param(IS_TIMER_OCNIDLE_STATE(oc_config->ocn_idle));
assert_param(IS_TIMER_OCIDLE_STATE(oc_config->oc_idle));
MODIFY_REG(TIMERx->CON2, TIMER_CON2_OISS2_MSK, oc_config->oc_idle << TIMER_CON2_OISS2_POS);
MODIFY_REG(TIMERx->CON2, TIMER_CON2_OISS2N_MSK, oc_config->ocn_idle << TIMER_CON2_OISS2N_POS);
}
WRITE_REG(TIMERx->CCVAL2, oc_config->pulse);
}
/**
* @brief Time Ouput Compare 3 configuration
* @param TIMERx: Select the TIMER peripheral
* @param oc_config: The ouput configuration structure
* @retval None
*/
static void timer_oc3_set_config(TIMER_TypeDef *TIMERx, ald_timer_oc_init_t *oc_config)
{
CLEAR_BIT(TIMERx->CCEP, TIMER_CCEP_CC3EN_MSK);
CLEAR_BIT(TIMERx->CHMR2, TIMER_CHMR2_CH3OMOD_MSK);
CLEAR_BIT(TIMERx->CHMR2, TIMER_CHMR2_CC3SSEL_MSK);
MODIFY_REG(TIMERx->CHMR2, TIMER_CHMR2_CH3OMOD_MSK, oc_config->oc_mode << TIMER_CHMR2_CH3OMOD_POSS);
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC3POL_MSK, oc_config->oc_polarity << TIMER_CCEP_CC3POL_POS);
if (IS_TIMER_CCXN_INSTANCE(TIMERx, ALD_TIMER_CHANNEL_3)) {
assert_param(IS_TIMER_OCN_POLARITY(oc_config->ocn_polarity));
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC3NPOL_MSK, oc_config->ocn_polarity << TIMER_CCEP_CC3NPOL_POS);
CLEAR_BIT(TIMERx->CCEP, TIMER_CCEP_CC3NE_MSK);
}
if (IS_TIMER_BREAK_INSTANCE(TIMERx)) {
assert_param(IS_TIMER_OCNIDLE_STATE(oc_config->ocn_idle));
assert_param(IS_TIMER_OCIDLE_STATE(oc_config->oc_idle));
MODIFY_REG(TIMERx->CON2, TIMER_CON2_OISS3_MSK, oc_config->oc_idle << TIMER_CON2_OISS3_POS);
MODIFY_REG(TIMERx->CON2, TIMER_CON2_OISS3N_MSK, oc_config->ocn_idle << TIMER_CON2_OISS3N_POS);
}
WRITE_REG(TIMERx->CCVAL3, oc_config->pulse);
}
/**
* @brief Time Ouput Compare 4 configuration
* @param TIMERx: Select the TIMER peripheral
* @param oc_config: The ouput configuration structure
* @retval None
*/
static void timer_oc4_set_config(TIMER_TypeDef *TIMERx, ald_timer_oc_init_t *oc_config)
{
CLEAR_BIT(TIMERx->CCEP, TIMER_CCEP_CC4EN_MSK);
CLEAR_BIT(TIMERx->CHMR2, TIMER_CHMR2_CH4OMOD_MSK);
CLEAR_BIT(TIMERx->CHMR2, TIMER_CHMR2_CC4SSEL_MSK);
MODIFY_REG(TIMERx->CHMR2, TIMER_CHMR2_CH4OMOD_MSK, oc_config->oc_mode << TIMER_CHMR2_CH4OMOD_POSS);
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC4POL_MSK, oc_config->oc_polarity << TIMER_CCEP_CC4POL_POS);
if (IS_TIMER_BREAK_INSTANCE(TIMERx)) {
assert_param(IS_TIMER_OCIDLE_STATE(oc_config->oc_idle));
MODIFY_REG(TIMERx->CON2, TIMER_CON2_OISS4_MSK, oc_config->oc_idle << TIMER_CON2_OISS4_POS);
}
WRITE_REG(TIMERx->CCVAL4, oc_config->pulse);
}
/**
* @brief Enables or disables the TIMER Capture Compare Channel x.
* @param TIMERx: Select the TIMER peripheral
* @param ch: specifies the TIMER Channel
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1
* @arg TIMER_CHANNEL_2: TIMER Channel 2
* @arg TIMER_CHANNEL_3: TIMER Channel 3
* @arg TIMER_CHANNEL_4: TIMER Channel 4
* @param state: specifies the TIMER Channel CCxE bit new state.
* @retval None
*/
static void timer_ccx_channel_cmd(TIMER_TypeDef* TIMERx, ald_timer_channel_t ch, type_func_t state)
{
assert_param(IS_TIMER_CC2_INSTANCE(TIMERx));
assert_param(IS_TIMER_CHANNELS(ch));
switch (ch) {
case ALD_TIMER_CHANNEL_1:
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC1EN_MSK, state << TIMER_CCEP_CC1EN_POS);
break;
case ALD_TIMER_CHANNEL_2:
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC2EN_MSK, state << TIMER_CCEP_CC2EN_POS);
break;
case ALD_TIMER_CHANNEL_3:
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC3EN_MSK, state << TIMER_CCEP_CC3EN_POS);
break;
case ALD_TIMER_CHANNEL_4:
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC4EN_MSK, state << TIMER_CCEP_CC4EN_POS);
break;
default:
break;
}
}
/**
* @brief Enables or disables the TIMER Capture Compare Channel xN.
* @param TIMERx: Select the TIMER peripheral
* @param ch: specifies the TIMER Channel
* This parameter can be one of the following values:
* @arg TIMER_CHANNEL_1: TIMER Channel 1
* @arg TIMER_CHANNEL_2: TIMER Channel 2
* @arg TIMER_CHANNEL_3: TIMER Channel 3
* @param state: specifies the TIMER Channel CCxNE bit new state.
* @retval None
*/
static void timer_ccxn_channel_cmd(TIMER_TypeDef* TIMERx, ald_timer_channel_t ch, type_func_t state)
{
switch (ch) {
case ALD_TIMER_CHANNEL_1:
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC1NE_MSK, state << TIMER_CCEP_CC1NE_POS);
break;
case ALD_TIMER_CHANNEL_2:
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC2NE_MSK, state << TIMER_CCEP_CC2NE_POS);
break;
case ALD_TIMER_CHANNEL_3:
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC3NE_MSK, state << TIMER_CCEP_CC3NE_POS);
break;
default:
break;
}
}
/**
* @brief Configure the TI1 as Input.
* @param TIMERx: Select the TIMER peripheral.
* @param polarity: The Input Polarity.
* @param sel: specifies the input to be used.
* @param filter: Specifies the Input Capture Filter.
* This parameter must be a value between 0x00 and 0x0F.
* @retval None
*/
static void timer_ti1_set_config(TIMER_TypeDef *TIMERx, ald_timer_ic_polarity_t polarity,
ald_timer_ic_select_t sel, uint32_t filter)
{
CLEAR_BIT(TIMERx->CCEP, TIMER_CCEP_CC1EN_MSK);
MODIFY_REG(TIMERx->CHMR1, TIMER_CHMR1_CC1SSEL_MSK, sel << TIMER_CHMR1_CC1SSEL_POSS);
MODIFY_REG(TIMERx->CHMR1, TIMER_CHMR1_I1FLT_MSK, filter << TIMER_CHMR1_I1FLT_POSS);
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC1POL_MSK, polarity << TIMER_CCEP_CC1POL_POS);
return;
}
/**
* @brief Configure the Polarity and Filter for TI1.
* @param TIMERx: Select the TIMER peripheral.
* @param polarity: The Input Polarity.
* @param filter: Specifies the Input Capture Filter.
* This parameter must be a value between 0x00 and 0x0F.
* @retval None
*/
static void timer_ti1_set_config_stage(TIMER_TypeDef *TIMERx, ald_timer_ic_polarity_t polarity, uint32_t filter)
{
MODIFY_REG(TIMERx->CHMR1, TIMER_CHMR1_I1FLT_MSK, filter << TIMER_CHMR1_I1FLT_POSS);
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC1POL_MSK, polarity << TIMER_CCEP_CC1POL_POS);
return;
}
/**
* @brief Configure the TI2 as Input.
* @param TIMERx: Select the TIMER peripheral.
* @param polarity: The Input Polarity.
* @param sel: specifies the input to be used.
* @param filter: Specifies the Input Capture Filter.
* This parameter must be a value between 0x00 and 0x0F.
* @retval None
*/
static void timer_ti2_set_config(TIMER_TypeDef *TIMERx, ald_timer_ic_polarity_t polarity,
ald_timer_ic_select_t sel, uint32_t filter)
{
CLEAR_BIT(TIMERx->CCEP, TIMER_CCEP_CC2EN_MSK);
MODIFY_REG(TIMERx->CHMR1, TIMER_CHMR1_CC2SSEL_MSK, sel << TIMER_CHMR1_CC2SSEL_POSS);
MODIFY_REG(TIMERx->CHMR1, TIMER_CHMR1_I2FLT_MSK, filter << TIMER_CHMR1_I2FLT_POSS);
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC2POL_MSK, polarity << TIMER_CCEP_CC2POL_POS);
return;
}
/**
* @brief Configure the Polarity and Filter for TI2.
* @param TIMERx: Select the TIMER peripheral.
* @param polarity: The Input Polarity.
* @param filter: Specifies the Input Capture Filter.
* This parameter must be a value between 0x00 and 0x0F.
* @retval None
*/
static void timer_ti2_set_config_stage(TIMER_TypeDef *TIMERx, ald_timer_ic_polarity_t polarity, uint32_t filter)
{
MODIFY_REG(TIMERx->CHMR1, TIMER_CHMR1_I2FLT_MSK, filter << TIMER_CHMR1_I2FLT_POSS);
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC2POL_MSK, polarity << TIMER_CCEP_CC2POL_POS);
return;
}
/**
* @brief Configure the TI3 as Input.
* @param TIMERx: Select the TIMER peripheral.
* @param polarity: The Input Polarity.
* @param sel: specifies the input to be used.
* @param filter: Specifies the Input Capture Filter.
* This parameter must be a value between 0x00 and 0x0F.
* @retval None
*/
static void timer_ti3_set_config(TIMER_TypeDef *TIMERx, ald_timer_ic_polarity_t polarity,
ald_timer_ic_select_t sel, uint32_t filter)
{
CLEAR_BIT(TIMERx->CCEP, TIMER_CCEP_CC3EN_MSK);
MODIFY_REG(TIMERx->CHMR2, TIMER_CHMR2_CC3SSEL_MSK, sel << TIMER_CHMR2_CC3SSEL_POSS);
MODIFY_REG(TIMERx->CHMR2, TIMER_CHMR2_I3FLT_MSK, filter << TIMER_CHMR2_I3FLT_POSS);
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC3POL_MSK, polarity << TIMER_CCEP_CC3POL_POS);
return;
}
/**
* @brief Configure the TI4 as Input.
* @param TIMERx: Select the TIMER peripheral.
* @param polarity: The Input Polarity.
* @param sel: specifies the input to be used.
* @param filter: Specifies the Input Capture Filter.
* This parameter must be a value between 0x00 and 0x0F.
* @retval None
*/
static void timer_ti4_set_config(TIMER_TypeDef *TIMERx, ald_timer_ic_polarity_t polarity,
ald_timer_ic_select_t sel, uint32_t filter)
{
CLEAR_BIT(TIMERx->CCEP, TIMER_CCEP_CC4EN_MSK);
MODIFY_REG(TIMERx->CHMR2, TIMER_CHMR2_CC4SSEL_MSK, sel << TIMER_CHMR2_CC4SSEL_POSS);
MODIFY_REG(TIMERx->CHMR2, TIMER_CHMR2_I4FLT_MSK, filter << TIMER_CHMR2_I4FLT_POSS);
MODIFY_REG(TIMERx->CCEP, TIMER_CCEP_CC4POL_MSK, polarity << TIMER_CCEP_CC4POL_POS);
return;
}
/**
* @brief Configures the TIMERx External Trigger (ETR).
* @param TIMERx: Select the TIMER peripheral
* @param psc: The external Trigger Prescaler.
* @param polarity: The external Trigger Polarity.
* @param filter: External Trigger Filter.
* This parameter must be a value between 0x00 and 0x0F
* @retval None
*/
static void timer_etr_set_config(TIMER_TypeDef* TIMERx, ald_timer_etr_psc_t psc, ald_timer_clock_polarity_t polarity, uint32_t filter)
{
MODIFY_REG(TIMERx->SMCON, TIMER_SMCON_ETFLT_MSK, filter << TIMER_SMCON_ETFLT_POSS);
MODIFY_REG(TIMERx->SMCON, TIMER_SMCON_ETPSEL_MSK, psc << TIMER_SMCON_ETPSEL_POSS);
CLEAR_BIT(TIMERx->SMCON, TIMER_SMCON_ECM2EN_MSK);
MODIFY_REG(TIMERx->SMCON, TIMER_SMCON_ETPOL_MSK, polarity << TIMER_SMCON_ETPOL_POS);
return;
}
/**
* @brief Time Slave configuration
* @param hperh: pointer to a timer_handle_t structure that contains
* the configuration information for TIMER module.
* @param config: The slave configuration structure
* @retval None
*/
static void timer_slave_set_config(ald_timer_handle_t *hperh, ald_timer_slave_config_t *config)
{
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_TSSEL_MSK, config->input << TIMER_SMCON_TSSEL_POSS);
MODIFY_REG(hperh->perh->SMCON, TIMER_SMCON_SMODS_MSK, config->mode << TIMER_SMCON_SMODS_POSS);
switch (config->input) {
case ALD_TIMER_TS_ETRF:
timer_etr_set_config(hperh->perh, config->psc, config->polarity, config->filter);
break;
case ALD_TIMER_TS_TI1F_ED:
CLEAR_BIT(hperh->perh->CCEP, TIMER_CCEP_CC1EN_MSK);
MODIFY_REG(hperh->perh->CHMR1, TIMER_CHMR1_I1FLT_MSK, config->filter << TIMER_CHMR1_I1FLT_POSS);
break;
case ALD_TIMER_TS_TI1FP1:
timer_ti1_set_config_stage(hperh->perh, (ald_timer_ic_polarity_t)config->polarity, config->filter);
break;
case ALD_TIMER_TS_TI2FP2:
timer_ti2_set_config_stage(hperh->perh, (ald_timer_ic_polarity_t)config->polarity, config->filter);
break;
default:
break;
}
}
/**
* @brief Timer DMA msel signal configuration
* @param hperh: pointer to a timer_handle_t structure that contains
* the configuration information for TIMER module.
* @param config: DMA configuration structure
* @retval None
*/
static void timer_dma_msel(TIMER_TypeDef *hperh, ald_dma_config_t *config)
{
if (hperh == AD16C4T)
config->msel = ALD_DMA_MSEL_AD16C4T;
if (hperh == BS16T)
config->msel = ALD_DMA_MSEL_BS16T;
if (hperh == GP16C4T0)
config->msel = ALD_DMA_MSEL_GP16C4T0;
if (hperh == GP16C4T1)
config->msel = ALD_DMA_MSEL_GP16C4T1;
if (hperh == GP16C4T2)
config->msel = ALD_DMA_MSEL_GP16C4T2;
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
View Git Blame Copy Permalink