444 lines
16 KiB
C
444 lines
16 KiB
C
/* Copyright Statement:
|
|
*
|
|
* This software/firmware and related documentation ("AutoChips Software") are
|
|
* protected under relevant copyright laws. The information contained herein is
|
|
* confidential and proprietary to AutoChips Inc. and/or its licensors. Without
|
|
* the prior written permission of AutoChips inc. and/or its licensors, any
|
|
* reproduction, modification, use or disclosure of AutoChips Software, and
|
|
* information contained herein, in whole or in part, shall be strictly
|
|
* prohibited.
|
|
*
|
|
* AutoChips Inc. (C) 2021. All rights reserved.
|
|
*
|
|
* BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
|
|
* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("AUTOCHIPS SOFTWARE")
|
|
* RECEIVED FROM AUTOCHIPS AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
|
|
* ON AN "AS-IS" BASIS ONLY. AUTOCHIPS EXPRESSLY DISCLAIMS ANY AND ALL
|
|
* WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
|
|
* NONINFRINGEMENT. NEITHER DOES AUTOCHIPS PROVIDE ANY WARRANTY WHATSOEVER WITH
|
|
* RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
|
|
* INCORPORATED IN, OR SUPPLIED WITH THE AUTOCHIPS SOFTWARE, AND RECEIVER AGREES
|
|
* TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
|
|
* RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
|
|
* OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN AUTOCHIPS
|
|
* SOFTWARE. AUTOCHIPS SHALL ALSO NOT BE RESPONSIBLE FOR ANY AUTOCHIPS SOFTWARE
|
|
* RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
|
|
* STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND AUTOCHIPS'S
|
|
* ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE AUTOCHIPS SOFTWARE
|
|
* RELEASED HEREUNDER WILL BE, AT AUTOCHIPS'S OPTION, TO REVISE OR REPLACE THE
|
|
* AUTOCHIPS SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
|
|
* CHARGE PAID BY RECEIVER TO AUTOCHIPS FOR SUCH AUTOCHIPS SOFTWARE AT ISSUE.
|
|
*/
|
|
|
|
/*!
|
|
* @file pwm_input.h
|
|
*
|
|
* @brief This file provides pwm input integration functions.
|
|
*
|
|
*/
|
|
|
|
/* PRQA S 3630 EOF */ /* struct/union type will be used by user app. */
|
|
|
|
#ifndef PWM_INPUT_H
|
|
#define PWM_INPUT_H
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif /* __cplusplus */
|
|
|
|
/* =========================================== Includes =========================================== */
|
|
#include "pwm_common.h"
|
|
|
|
/* ============================================ Define ============================================ */
|
|
|
|
/* =========================================== Typedef ============================================ */
|
|
/*!
|
|
* @brief PWM input capture edge mode enumeration.
|
|
*/
|
|
typedef enum
|
|
{
|
|
PWM_INPUTCAP_SINGLE_EDGE = 0U, /*!< Signle edge capture mode */
|
|
PWM_INPUTCAP_DUAL_EDGE /*!< Dual edge capture mode */
|
|
} pwm_input_capture_edge_mode_t;
|
|
|
|
/*!
|
|
* @brief PWM input capture single edge detect enumeration.
|
|
*/
|
|
typedef enum
|
|
{
|
|
PWM_RISING_EDGE_DETECT = 1U, /*!< Rising edge detect */
|
|
PWM_FALLING_EDGE_DETECT, /*!< Falling Edge detect */
|
|
PWM_BOTH_EDGE_DETECT /*!< Rising or falling edge detect */
|
|
} pwm_input_single_edge_detect_type_t;
|
|
|
|
/*!
|
|
* @brief PWM input capture dual edge measure enumeration.
|
|
*/
|
|
typedef enum
|
|
{
|
|
PWM_POSITIVE_PLUSE_WIDTH_MEASURE = 0U, /*!< Positive Pluse width measurement */
|
|
PWM_NEGATIVE_PLUSE_WIDTH_MEASURE, /*!< Negative Pluse width measurement */
|
|
PWM_RISING_EDGE_PERIOD_MEASURE, /*!< Period measurement between two consecutive rising edges */
|
|
PWM_FALLING_EDGE_PERIOD_MEASURE /*!< Period measurement between two consecutive falling edges */
|
|
} pwm_input_dual_edge_measure_type_t;
|
|
|
|
/*!
|
|
* @brief PWM input capture mode enumeration.
|
|
*/
|
|
typedef enum
|
|
{
|
|
PWM_INPUTCAP_ONESHOT = 0U, /*!< Dual edge capture with one shot mode */
|
|
PWM_INPUTCAP_CONTINUOUS /*!< Dual edge capture with continuous mode */
|
|
} pwm_dual_once_mode_type_t;
|
|
|
|
/*!
|
|
* @brief PWM input capture event prescaler enumeration.
|
|
*/
|
|
typedef enum
|
|
{
|
|
PWM_EVENT_PSC_1 = 0U, /*!< 1 event trigger input capture */
|
|
PWM_EVENT_PSC_2, /*!< 2 event trigger input capture */
|
|
PWM_EVENT_PSC_4, /*!< 4 event trigger input capture */
|
|
PWM_EVENT_PSC_8 /*!< 8 event trigger input capture */
|
|
} pwm_input_event_psc_type_t;
|
|
|
|
/*!
|
|
* @brief PWM input capture event prescaler enumeration.
|
|
*/
|
|
typedef enum
|
|
{
|
|
PWM_CHANNEL_INPUT_FILTER_PS_1 = 0U, /*!< Capture filter psc is 1 */
|
|
PWM_CHANNEL_INPUT_FILTER_PS_2, /*!< Capture filter psc is 2 */
|
|
PWM_CHANNEL_INPUT_FILTER_PS_4, /*!< Capture filter psc is 4 */
|
|
PWM_CHANNEL_INPUT_FILTER_PS_8, /*!< Capture filter psc is 8 */
|
|
PWM_CHANNEL_INPUT_FILTER_PS_16, /*!< Capture filter psc is 16 */
|
|
PWM_CHANNEL_INPUT_FILTER_PS_32, /*!< Capture filter psc is 32 */
|
|
PWM_CHANNEL_INPUT_FILTER_PS_64, /*!< Capture filter psc is 64 */
|
|
PWM_CHANNEL_INPUT_FILTER_PS_128, /*!< Capture filter psc is 128 */
|
|
PWM_CHANNEL_INPUT_FILTER_PS_256, /*!< Capture filter psc is 256 */
|
|
PWM_CHANNEL_INPUT_FILTER_PS_1024, /*!< Capture filter psc is 1024 */
|
|
PWM_CHANNEL_INPUT_FILTER_PS_2048, /*!< Capture filter psc is 2048 */
|
|
PWM_CHANNEL_INPUT_FILTER_PS_4096 /*!< Capture filter psc is 4096 */
|
|
} pwm_channel_input_filter_psc_type_t;
|
|
|
|
/*!
|
|
* @brief PWM fault channel input polarity active enumeration.
|
|
*/
|
|
typedef enum
|
|
{
|
|
PWM_INPUT_POLARITY_ACTIVE_HIGH = 0U, /*!< The fault channel polarity is active high */
|
|
PWM_INPUT_POLARITY_ACTIVE_LOW /*!< The fault channel polarity is active low */
|
|
} pwm_fault_input_polarity_active_type_t;
|
|
|
|
/*!
|
|
* @brief PWM Input capture channel configuration structure.
|
|
*/
|
|
typedef struct
|
|
{
|
|
pwm_channel_type_t channel; /*!< Channel number */
|
|
pwm_input_capture_edge_mode_t mode; /*!< Input channel operation mode */
|
|
/* single mode parameters */
|
|
pwm_input_single_edge_detect_type_t detectType; /*!< In single mode, channel edge detect type */
|
|
pwm_input_event_psc_type_t eventPsc; /*!< Event prescaler */
|
|
/* dual mode parameters */
|
|
pwm_input_dual_edge_measure_type_t measureType; /*!< In dual mode, channel measure type */
|
|
pwm_dual_once_mode_type_t onceMode; /*!< Enable/disable Continuous mode */
|
|
/* General parameters */
|
|
bool filterEn; /*!< Enable/disable Input capture filter */
|
|
uint8_t filterValue; /*!< Filter value */
|
|
bool interruptEn; /*!< Enable/disable channel interrupt */
|
|
bool pulseWidthMeasureEn; /*!< Enable/disable pulseWidth measurement */
|
|
bool chEventDmaEn; /*!< Enable/disable channel event dma request*/
|
|
bool chCountRst; /*!< Enable/disable channel counter reset when input capture*/
|
|
} pwm_input_ch_config_type_t;
|
|
|
|
/*!
|
|
* @brief PWM input capture mode configuration structure.
|
|
*/
|
|
typedef struct
|
|
{
|
|
uint8_t channelNum; /*!< Number of output compare channels */
|
|
pwm_channel_input_filter_psc_type_t filterPsc; /*!< Filter prescaler */
|
|
bool hallEn; /*!< Hall enable */
|
|
pwm_input_ch_config_type_t *channelConfig; /*!< Input capture channels configuration */
|
|
} pwm_input_capture_config_t;
|
|
|
|
/*!
|
|
* @brief PWM channel fault control mode enumeration.
|
|
*/
|
|
typedef enum
|
|
{
|
|
PWM_FAULT_CTRL_NONE = 0U, /*!< No Fault control */
|
|
PWM_FAULT_CTRL_MANUAL_EVEN, /*!< Fault control is enabled for even channels and manual fault clearing */
|
|
PWM_FAULT_CTRL_MANUAL_ALL, /*!< Fault control is enabled for all channels and manual fault clearing */
|
|
PWM_FAULT_CTRL_AUTO /*!< Fault control is enabled for all channels and automatic fault clearing */
|
|
} pwm_fault_ctrl_mode_t;
|
|
|
|
/*!
|
|
* @brief PWM Fault channel configuration structure.
|
|
*/
|
|
typedef struct
|
|
{
|
|
bool faultInputEn; /*!< Fault input channel state */
|
|
bool faultFilterEn; /*!< Fault channel filter state */
|
|
pwm_fault_input_polarity_active_type_t faultPolarity; /*!< Fault channel input polarity active */
|
|
} pwm_fault_ch_config_t;
|
|
|
|
/*!
|
|
* @brief PWM Fault configuration structure.
|
|
*/
|
|
typedef struct
|
|
{
|
|
pwm_fault_ctrl_mode_t mode; /*!< Fault mode */
|
|
pwm_fault_ch_config_t channelConfig[PWM_FAULT_CH_MAX]; /*!< Fault input channels configuration */
|
|
uint8_t filterValue; /*!< Fault filter value */
|
|
pwm_channel_input_filter_psc_type_t filterPsc; /*!< Fault filter psc */
|
|
bool faultCtrlOutputEn[PWM_PAIR_CHANNEL_NUM]; /*!< Fault control channel output state */
|
|
bool interruptEn; /*!< Enable PWM fault interrupt */
|
|
bool HizEnable; /*!< Enable PWM fault Hiz Output */
|
|
pwm_callback_t faultCallback;
|
|
} pwm_fault_config_t;
|
|
|
|
/*!
|
|
* @brief PWM quadrature decode mode enumeration.
|
|
*/
|
|
typedef enum
|
|
{
|
|
PWM_QUAD_PHASE_ENCODE = 0U, /*!< Phase encoding mode */
|
|
PWM_QUAD_COUNT_DIR /*!< Counter and direction encoding mode */
|
|
} pwm_quad_decoder_mode_t;
|
|
|
|
/*!
|
|
* @brief PWM quadrature phase polarity enumeration.
|
|
*/
|
|
typedef enum
|
|
{
|
|
PWM_QUAD_PHASE_NORMAL = 0U, /*!< Phase input signal is not inverted */
|
|
PWM_QUAD_PHASE_INVERT /*!< Phase input signal is inverted */
|
|
} pwm_quad_phase_polarity_type_t;
|
|
|
|
/*!
|
|
* @brief PWM quadrature decoder phase input configuration structure.
|
|
*
|
|
*/
|
|
typedef struct
|
|
{
|
|
pwm_quad_phase_polarity_type_t polarity; /*!< PhaseA Polarity */
|
|
bool filterEn; /*!< Filter Enable */
|
|
uint8_t filterVal; /*!< Filter value */
|
|
} pwm_quad_phase_config_t;
|
|
|
|
/*!
|
|
* @brief PWM quadrature configuration structure.
|
|
*/
|
|
typedef struct
|
|
{
|
|
pwm_quad_decoder_mode_t mode; /*!< PWM quadrature decode mode */
|
|
pwm_quad_phase_config_t phaseAConfig; /*!< PhaseA config */
|
|
pwm_quad_phase_config_t phaseBConfig; /*!< PhaseB config */
|
|
pwm_quad_phase_config_t phaseZConfig; /*!< PhaseZ config */
|
|
bool quadEn; /*!< Enable quadrature decode mode */
|
|
pwm_channel_input_filter_psc_type_t filterPsc; /*!< Input Capture Filter psc */
|
|
bool phaseZResetEn;
|
|
} pwm_quad_decoder_config_t;
|
|
|
|
/* ========================================== Variables =========================================== */
|
|
|
|
/* ==================================== Functions declaration ===================================== */
|
|
/*!
|
|
* @brief Set pwm module work in input capture mode.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
* @param[in] config: pointer to configuration structure
|
|
* @return none
|
|
*/
|
|
void PWM_DRV_SetInputCaptureMode(const uint8_t instance, const pwm_input_capture_config_t *config);
|
|
|
|
/*!
|
|
* @brief Set pwm input capture filter psc & filter value.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
* @param[in] channel: pwm channel.
|
|
* @param[in] psc: filter psc(0 ~ 111)
|
|
* @param[in] value: filter value(0~15)
|
|
* @return none
|
|
*/
|
|
void PWM_DRV_SetChannelInputFilter(const uint8_t instance, pwm_channel_type_t channel,
|
|
pwm_channel_input_filter_psc_type_t psc, uint8_t value);
|
|
|
|
/*!
|
|
* @brief Init fault control.
|
|
*
|
|
* Use only in PWM Modulation mode,Called after PWM_Init function.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
* @param[in] config: pointer to configuration structure
|
|
* @return none
|
|
*/
|
|
void PWM_DRV_InitFaultControl(const uint8_t instance, const pwm_fault_config_t *config);
|
|
|
|
/*!
|
|
* @brief Set fault input activity.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
* @param[in] channel: fault input channel
|
|
* - PWM_FAULT_CH_0
|
|
* - PWM_FAULT_CH_1
|
|
* - PWM_FAULT_CH_2
|
|
* @param[in] state: enabling state
|
|
* - ENABLE
|
|
* - DISABLE
|
|
* @return none
|
|
*/
|
|
void PWM_DRV_SetFaultInput(const uint8_t instance, pwm_fault_channel_type_t channel, bool state);
|
|
|
|
/*!
|
|
* @brief Set fault input filter enable/disable.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
* @param[in] channel: fault input channel
|
|
* - PWM_FAULT_CH_0
|
|
* - PWM_FAULT_CH_1
|
|
* - PWM_FAULT_CH_2
|
|
* @param[in] state: enabling state
|
|
* - ENABLE
|
|
* - DISABLE
|
|
* @return none
|
|
*/
|
|
void PWM_DRV_SetFaultInputFilter(const uint8_t instance, pwm_fault_channel_type_t channel, bool state);
|
|
|
|
/*!
|
|
* @brief Set fault input polarity.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
* @param[in] channel: fault input channel
|
|
* - PWM_FAULT_CH_0
|
|
* - PWM_FAULT_CH_1
|
|
* - PWM_FAULT_CH_2
|
|
* @param[in] polarity: output polarity
|
|
* - PWM_INPUT_POLARITY_ACTIVE_HIGH: fault input polarity is active high
|
|
* - PWM_INPUT_POLARITY_ACTIVE_LOW: fault input polarity is active low
|
|
* @return none
|
|
*/
|
|
void PWM_DRV_SetFaultInputPolarity(const uint8_t instance, pwm_fault_channel_type_t channel,
|
|
pwm_fault_input_polarity_active_type_t polarity);
|
|
|
|
/*!
|
|
* @brief Get fault channel detection flag.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
* @param[in] channel: fault input channel
|
|
* - PWM_FAULT_CH_0
|
|
* - PWM_FAULT_CH_1
|
|
* - PWM_FAULT_CH_2
|
|
* - PWM_FAULT_CH_3
|
|
* @return fault channel detection flag
|
|
*/
|
|
uint32_t PWM_DRV_GetFaultChannelFlag(const uint8_t instance, pwm_fault_channel_type_t channel);
|
|
|
|
/*!
|
|
* @brief Clear fault channel detection flag.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
* @param[in] channel: fault input channel
|
|
* - PWM_FAULT_CH_0
|
|
* - PWM_FAULT_CH_1
|
|
* - PWM_FAULT_CH_2
|
|
* - PWM_FAULT_CH_3
|
|
* @return none
|
|
*/
|
|
void PWM_DRV_ClearFaultChannelFlag(const uint8_t instance, pwm_fault_channel_type_t channel);
|
|
|
|
/*!
|
|
* @brief Get the flag about the OR of all fault.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
* @return the flag about the OR of all fault
|
|
*/
|
|
uint32_t PWM_DRV_GetFaultFlag(const uint8_t instance);
|
|
|
|
/*!
|
|
* @brief Clear the flag about the OR of all fault.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
* @return none
|
|
*/
|
|
void PWM_DRV_ClearFaultFlag(const uint8_t instance);
|
|
|
|
/*!
|
|
* @brief Get the quadrature timer counting direction.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
* @return quadrature counting direction
|
|
*/
|
|
uint32_t PWM_DRV_GetQuadCountDir(const uint8_t instance);
|
|
|
|
/*!
|
|
* @brief Get the quadrature timer overflow direction.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
* @return quad time overflow direction flag
|
|
*/
|
|
uint32_t PWM_DRV_GetQuadOverflowDir(const uint8_t instance);
|
|
|
|
/*!
|
|
* @brief Get the phaseZ flag.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
*
|
|
* @return phaseZ Flag
|
|
*/
|
|
uint32_t PWM_DRV_GetPhaseZFlag(const uint8_t instance);
|
|
|
|
/*!
|
|
* @brief Clear the phase Z flag.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
*
|
|
* @return none
|
|
*/
|
|
void PWM_DRV_ClearPhaseZFlag(const uint8_t instance);
|
|
|
|
/*!
|
|
* @brief Set pwm module work in quadrature decoder mode.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
* @param[in] config: pointer to configuration structure
|
|
* @return none
|
|
*/
|
|
void PWM_DRV_SetQuadDecodeMode(const uint8_t instance, const pwm_quad_decoder_config_t *config);
|
|
|
|
/*!
|
|
* @brief Get pwm hall status.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
* @return hall status
|
|
*/
|
|
uint32_t PWM_DRV_GetHallStatus(const uint8_t instance);
|
|
|
|
/*!
|
|
* @brief Install pwm fault interrupt callback function.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
* @param[in] func: The pwm callback function
|
|
* @return none
|
|
*/
|
|
void PWM_DRV_InstallFaultCallback(const uint8_t instance, const pwm_callback_t func);
|
|
|
|
/*!
|
|
* @brief PWM fault common interrupt service routine.
|
|
*
|
|
* @param[in] instance: The pwm instance number
|
|
* @return none
|
|
*/
|
|
void PWM_DRV_Fault_IRQHandler(uint8_t instance);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif /* __cplusplus */
|
|
|
|
#endif /* PWM_INPUT_H */
|
|
|
|
/* ============================================= EOF ============================================== */
|