1354 lines
44 KiB
C
1354 lines
44 KiB
C
/**
|
|
******************************************************************************
|
|
* @file stm32h7xx_hal_cordic.c
|
|
* @author MCD Application Team
|
|
* @brief CORDIC HAL module driver.
|
|
* This file provides firmware functions to manage the following
|
|
* functionalities of the CORDIC peripheral:
|
|
* + Initialization and de-initialization functions
|
|
* + Peripheral Control functions
|
|
* + Callback functions
|
|
* + IRQ handler management
|
|
* + Peripheral State functions
|
|
*
|
|
******************************************************************************
|
|
* @attention
|
|
*
|
|
* Copyright (c) 2017 STMicroelectronics.
|
|
* All rights reserved.
|
|
*
|
|
* This software is licensed under terms that can be found in the LICENSE file
|
|
* in the root directory of this software component.
|
|
* If no LICENSE file comes with this software, it is provided AS-IS.
|
|
*
|
|
******************************************************************************
|
|
@verbatim
|
|
================================================================================
|
|
##### How to use this driver #####
|
|
================================================================================
|
|
[..]
|
|
The CORDIC HAL driver can be used as follows:
|
|
|
|
(#) Initialize the CORDIC low level resources by implementing the HAL_CORDIC_MspInit():
|
|
(++) Enable the CORDIC interface clock using __HAL_RCC_CORDIC_CLK_ENABLE()
|
|
(++) In case of using interrupts (e.g. HAL_CORDIC_Calculate_IT())
|
|
(+++) Configure the CORDIC interrupt priority using HAL_NVIC_SetPriority()
|
|
(+++) Enable the CORDIC IRQ handler using HAL_NVIC_EnableIRQ()
|
|
(+++) In CORDIC IRQ handler, call HAL_CORDIC_IRQHandler()
|
|
(++) In case of using DMA to control data transfer (e.g. HAL_CORDIC_Calculate_DMA())
|
|
(+++) Enable the DMA2 interface clock using
|
|
__HAL_RCC_DMA2_CLK_ENABLE()
|
|
(+++) Configure and enable two DMA channels one for managing data transfer from
|
|
memory to peripheral (input channel) and another channel for managing data
|
|
transfer from peripheral to memory (output channel)
|
|
(+++) Associate the initialized DMA handle to the CORDIC DMA handle
|
|
using __HAL_LINKDMA()
|
|
(+++) Configure the priority and enable the NVIC for the transfer complete
|
|
interrupt on the two DMA channels.
|
|
Resort to HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ()
|
|
|
|
(#) Initialize the CORDIC HAL using HAL_CORDIC_Init(). This function
|
|
(++) resorts to HAL_CORDIC_MspInit() for low-level initialization,
|
|
|
|
(#) Configure CORDIC processing (calculation) using HAL_CORDIC_Configure().
|
|
This function configures:
|
|
(++) Processing functions: Cosine, Sine, Phase, Modulus, Arctangent,
|
|
Hyperbolic cosine, Hyperbolic sine, Hyperbolic arctangent,
|
|
Natural log, Square root
|
|
(++) Scaling factor: 1 to 2exp(-7)
|
|
(++) Width of input data: 32 bits input data size (Q1.31 format) or 16 bits
|
|
input data size (Q1.15 format)
|
|
(++) Width of output data: 32 bits output data size (Q1.31 format) or 16 bits
|
|
output data size (Q1.15 format)
|
|
(++) Number of 32-bit write expected for one calculation: One 32-bits write
|
|
or Two 32-bit write
|
|
(++) Number of 32-bit read expected after one calculation: One 32-bits read
|
|
or Two 32-bit read
|
|
(++) Precision: 1 to 15 cycles for calculation (the more cycles, the better precision)
|
|
|
|
(#) Four processing (calculation) functions are available:
|
|
(++) Polling mode: processing API is blocking function
|
|
i.e. it processes the data and wait till the processing is finished
|
|
API is HAL_CORDIC_Calculate
|
|
(++) Polling Zero-overhead mode: processing API is blocking function
|
|
i.e. it processes the data and wait till the processing is finished
|
|
A bit faster than standard polling mode, but blocking also AHB bus
|
|
API is HAL_CORDIC_CalculateZO
|
|
(++) Interrupt mode: processing API is not blocking functions
|
|
i.e. it processes the data under interrupt
|
|
API is HAL_CORDIC_Calculate_IT
|
|
(++) DMA mode: processing API is not blocking functions and the CPU is
|
|
not used for data transfer,
|
|
i.e. the data transfer is ensured by DMA
|
|
API is HAL_CORDIC_Calculate_DMA
|
|
|
|
(#) Call HAL_CORDIC_DeInit() to de-initialize the CORDIC peripheral. This function
|
|
(++) resorts to HAL_CORDIC_MspDeInit() for low-level de-initialization,
|
|
|
|
*** Callback registration ***
|
|
=============================================
|
|
|
|
The compilation define USE_HAL_CORDIC_REGISTER_CALLBACKS when set to 1
|
|
allows the user to configure dynamically the driver callbacks.
|
|
Use Function HAL_CORDIC_RegisterCallback() to register an interrupt callback.
|
|
|
|
Function HAL_CORDIC_RegisterCallback() allows to register following callbacks:
|
|
(+) ErrorCallback : Error Callback.
|
|
(+) CalculateCpltCallback : Calculate complete Callback.
|
|
(+) MspInitCallback : CORDIC MspInit.
|
|
(+) MspDeInitCallback : CORDIC MspDeInit.
|
|
This function takes as parameters the HAL peripheral handle, the Callback ID
|
|
and a pointer to the user callback function.
|
|
|
|
Use function HAL_CORDIC_UnRegisterCallback() to reset a callback to the default
|
|
weak function.
|
|
HAL_CORDIC_UnRegisterCallback takes as parameters the HAL peripheral handle,
|
|
and the Callback ID.
|
|
This function allows to reset following callbacks:
|
|
(+) ErrorCallback : Error Callback.
|
|
(+) CalculateCpltCallback : Calculate complete Callback.
|
|
(+) MspInitCallback : CORDIC MspInit.
|
|
(+) MspDeInitCallback : CORDIC MspDeInit.
|
|
|
|
By default, after the HAL_CORDIC_Init() and when the state is HAL_CORDIC_STATE_RESET,
|
|
all callbacks are set to the corresponding weak functions:
|
|
examples HAL_CORDIC_ErrorCallback(), HAL_CORDIC_CalculateCpltCallback().
|
|
Exception done for MspInit and MspDeInit functions that are
|
|
reset to the legacy weak function in the HAL_CORDIC_Init()/ HAL_CORDIC_DeInit() only when
|
|
these callbacks are null (not registered beforehand).
|
|
if not, MspInit or MspDeInit are not null, the HAL_CORDIC_Init()/ HAL_CORDIC_DeInit()
|
|
keep and use the user MspInit/MspDeInit callbacks (registered beforehand)
|
|
|
|
Callbacks can be registered/unregistered in HAL_CORDIC_STATE_READY state only.
|
|
Exception done MspInit/MspDeInit that can be registered/unregistered
|
|
in HAL_CORDIC_STATE_READY or HAL_CORDIC_STATE_RESET state,
|
|
thus registered (user) MspInit/DeInit callbacks can be used during the Init/DeInit.
|
|
In that case first register the MspInit/MspDeInit user callbacks
|
|
using HAL_CORDIC_RegisterCallback() before calling HAL_CORDIC_DeInit()
|
|
or HAL_CORDIC_Init() function.
|
|
|
|
When The compilation define USE_HAL_CORDIC_REGISTER_CALLBACKS is set to 0 or
|
|
not defined, the callback registration feature is not available and all callbacks
|
|
are set to the corresponding weak functions.
|
|
|
|
@endverbatim
|
|
******************************************************************************
|
|
*/
|
|
|
|
/* Includes ------------------------------------------------------------------*/
|
|
#include "stm32h7xx_hal.h"
|
|
|
|
#if defined(CORDIC)
|
|
#ifdef HAL_CORDIC_MODULE_ENABLED
|
|
|
|
/** @addtogroup STM32H7xx_HAL_Driver
|
|
* @{
|
|
*/
|
|
|
|
/** @defgroup CORDIC CORDIC
|
|
* @brief CORDIC HAL driver modules.
|
|
* @{
|
|
*/
|
|
|
|
/* Private typedef -----------------------------------------------------------*/
|
|
/* Private define ------------------------------------------------------------*/
|
|
/* Private macro -------------------------------------------------------------*/
|
|
/* Private variables ---------------------------------------------------------*/
|
|
/* Private function prototypes -----------------------------------------------*/
|
|
|
|
/** @defgroup CORDIC_Private_Functions CORDIC Private Functions
|
|
* @{
|
|
*/
|
|
static void CORDIC_WriteInDataIncrementPtr(CORDIC_HandleTypeDef *hcordic, int32_t **ppInBuff);
|
|
static void CORDIC_ReadOutDataIncrementPtr(CORDIC_HandleTypeDef *hcordic, int32_t **ppOutBuff);
|
|
static void CORDIC_DMAInCplt(DMA_HandleTypeDef *hdma);
|
|
static void CORDIC_DMAOutCplt(DMA_HandleTypeDef *hdma);
|
|
static void CORDIC_DMAError(DMA_HandleTypeDef *hdma);
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/* Exported functions --------------------------------------------------------*/
|
|
|
|
/** @defgroup CORDIC_Exported_Functions CORDIC Exported Functions
|
|
* @{
|
|
*/
|
|
|
|
/** @defgroup CORDIC_Exported_Functions_Group1 Initialization and de-initialization functions
|
|
* @brief Initialization and Configuration functions.
|
|
*
|
|
@verbatim
|
|
==============================================================================
|
|
##### Initialization and de-initialization functions #####
|
|
==============================================================================
|
|
[..] This section provides functions allowing to:
|
|
(+) Initialize the CORDIC peripheral and the associated handle
|
|
(+) DeInitialize the CORDIC peripheral
|
|
(+) Initialize the CORDIC MSP (MCU Specific Package)
|
|
(+) De-Initialize the CORDIC MSP
|
|
|
|
[..]
|
|
|
|
@endverbatim
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* @brief Initialize the CORDIC peripheral and the associated handle.
|
|
* @param hcordic pointer to a CORDIC_HandleTypeDef structure.
|
|
* @retval HAL status
|
|
*/
|
|
HAL_StatusTypeDef HAL_CORDIC_Init(CORDIC_HandleTypeDef *hcordic)
|
|
{
|
|
/* Check the CORDIC handle allocation */
|
|
if (hcordic == NULL)
|
|
{
|
|
/* Return error status */
|
|
return HAL_ERROR;
|
|
}
|
|
|
|
/* Check the instance */
|
|
assert_param(IS_CORDIC_ALL_INSTANCE(hcordic->Instance));
|
|
|
|
#if USE_HAL_CORDIC_REGISTER_CALLBACKS == 1
|
|
if (hcordic->State == HAL_CORDIC_STATE_RESET)
|
|
{
|
|
/* Allocate lock resource and initialize it */
|
|
hcordic->Lock = HAL_UNLOCKED;
|
|
|
|
/* Reset callbacks to legacy functions */
|
|
hcordic->ErrorCallback = HAL_CORDIC_ErrorCallback; /* Legacy weak ErrorCallback */
|
|
hcordic->CalculateCpltCallback = HAL_CORDIC_CalculateCpltCallback; /* Legacy weak CalculateCpltCallback */
|
|
|
|
if (hcordic->MspInitCallback == NULL)
|
|
{
|
|
hcordic->MspInitCallback = HAL_CORDIC_MspInit; /* Legacy weak MspInit */
|
|
}
|
|
|
|
/* Initialize the low level hardware */
|
|
hcordic->MspInitCallback(hcordic);
|
|
}
|
|
#else
|
|
if (hcordic->State == HAL_CORDIC_STATE_RESET)
|
|
{
|
|
/* Allocate lock resource and initialize it */
|
|
hcordic->Lock = HAL_UNLOCKED;
|
|
|
|
/* Initialize the low level hardware */
|
|
HAL_CORDIC_MspInit(hcordic);
|
|
}
|
|
#endif /* (USE_HAL_CORDIC_REGISTER_CALLBACKS) */
|
|
|
|
/* Set CORDIC error code to none */
|
|
hcordic->ErrorCode = HAL_CORDIC_ERROR_NONE;
|
|
|
|
/* Reset pInBuff and pOutBuff */
|
|
hcordic->pInBuff = NULL;
|
|
hcordic->pOutBuff = NULL;
|
|
|
|
/* Reset NbCalcToOrder and NbCalcToGet */
|
|
hcordic->NbCalcToOrder = 0U;
|
|
hcordic->NbCalcToGet = 0U;
|
|
|
|
/* Reset DMADirection */
|
|
hcordic->DMADirection = CORDIC_DMA_DIR_NONE;
|
|
|
|
/* Change CORDIC peripheral state */
|
|
hcordic->State = HAL_CORDIC_STATE_READY;
|
|
|
|
/* Return function status */
|
|
return HAL_OK;
|
|
}
|
|
|
|
/**
|
|
* @brief DeInitialize the CORDIC peripheral.
|
|
* @param hcordic pointer to a CORDIC_HandleTypeDef structure.
|
|
* @retval HAL status
|
|
*/
|
|
HAL_StatusTypeDef HAL_CORDIC_DeInit(CORDIC_HandleTypeDef *hcordic)
|
|
{
|
|
/* Check the CORDIC handle allocation */
|
|
if (hcordic == NULL)
|
|
{
|
|
/* Return error status */
|
|
return HAL_ERROR;
|
|
}
|
|
|
|
/* Check the parameters */
|
|
assert_param(IS_CORDIC_ALL_INSTANCE(hcordic->Instance));
|
|
|
|
/* Change CORDIC peripheral state */
|
|
hcordic->State = HAL_CORDIC_STATE_BUSY;
|
|
|
|
#if USE_HAL_CORDIC_REGISTER_CALLBACKS == 1
|
|
if (hcordic->MspDeInitCallback == NULL)
|
|
{
|
|
hcordic->MspDeInitCallback = HAL_CORDIC_MspDeInit;
|
|
}
|
|
|
|
/* De-Initialize the low level hardware */
|
|
hcordic->MspDeInitCallback(hcordic);
|
|
#else
|
|
/* De-Initialize the low level hardware: CLOCK, NVIC, DMA */
|
|
HAL_CORDIC_MspDeInit(hcordic);
|
|
#endif /* USE_HAL_CORDIC_REGISTER_CALLBACKS */
|
|
|
|
/* Set CORDIC error code to none */
|
|
hcordic->ErrorCode = HAL_CORDIC_ERROR_NONE;
|
|
|
|
/* Reset pInBuff and pOutBuff */
|
|
hcordic->pInBuff = NULL;
|
|
hcordic->pOutBuff = NULL;
|
|
|
|
/* Reset NbCalcToOrder and NbCalcToGet */
|
|
hcordic->NbCalcToOrder = 0U;
|
|
hcordic->NbCalcToGet = 0U;
|
|
|
|
/* Reset DMADirection */
|
|
hcordic->DMADirection = CORDIC_DMA_DIR_NONE;
|
|
|
|
/* Change CORDIC peripheral state */
|
|
hcordic->State = HAL_CORDIC_STATE_RESET;
|
|
|
|
/* Reset Lock */
|
|
hcordic->Lock = HAL_UNLOCKED;
|
|
|
|
/* Return function status */
|
|
return HAL_OK;
|
|
}
|
|
|
|
/**
|
|
* @brief Initialize the CORDIC MSP.
|
|
* @param hcordic CORDIC handle
|
|
* @retval None
|
|
*/
|
|
__weak void HAL_CORDIC_MspInit(CORDIC_HandleTypeDef *hcordic)
|
|
{
|
|
/* Prevent unused argument(s) compilation warning */
|
|
UNUSED(hcordic);
|
|
|
|
/* NOTE : This function should not be modified, when the callback is needed,
|
|
the HAL_CORDIC_MspInit can be implemented in the user file
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* @brief DeInitialize the CORDIC MSP.
|
|
* @param hcordic CORDIC handle
|
|
* @retval None
|
|
*/
|
|
__weak void HAL_CORDIC_MspDeInit(CORDIC_HandleTypeDef *hcordic)
|
|
{
|
|
/* Prevent unused argument(s) compilation warning */
|
|
UNUSED(hcordic);
|
|
|
|
/* NOTE : This function should not be modified, when the callback is needed,
|
|
the HAL_CORDIC_MspDeInit can be implemented in the user file
|
|
*/
|
|
}
|
|
|
|
#if USE_HAL_CORDIC_REGISTER_CALLBACKS == 1
|
|
/**
|
|
* @brief Register a CORDIC CallBack.
|
|
* To be used instead of the weak predefined callback.
|
|
* @param hcordic pointer to a CORDIC_HandleTypeDef structure that contains
|
|
* the configuration information for CORDIC module
|
|
* @param CallbackID ID of the callback to be registered
|
|
* This parameter can be one of the following values:
|
|
* @arg @ref HAL_CORDIC_ERROR_CB_ID error Callback ID
|
|
* @arg @ref HAL_CORDIC_CALCULATE_CPLT_CB_ID calculate complete Callback ID
|
|
* @arg @ref HAL_CORDIC_MSPINIT_CB_ID MspInit callback ID
|
|
* @arg @ref HAL_CORDIC_MSPDEINIT_CB_ID MspDeInit callback ID
|
|
* @param pCallback pointer to the Callback function
|
|
* @retval HAL status
|
|
*/
|
|
HAL_StatusTypeDef HAL_CORDIC_RegisterCallback(CORDIC_HandleTypeDef *hcordic, HAL_CORDIC_CallbackIDTypeDef CallbackID,
|
|
void (* pCallback)(CORDIC_HandleTypeDef *_hcordic))
|
|
{
|
|
HAL_StatusTypeDef status = HAL_OK;
|
|
|
|
if (pCallback == NULL)
|
|
{
|
|
/* Update the error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_INVALID_CALLBACK;
|
|
|
|
/* Return error status */
|
|
return HAL_ERROR;
|
|
}
|
|
|
|
if (hcordic->State == HAL_CORDIC_STATE_READY)
|
|
{
|
|
switch (CallbackID)
|
|
{
|
|
case HAL_CORDIC_ERROR_CB_ID :
|
|
hcordic->ErrorCallback = pCallback;
|
|
break;
|
|
|
|
case HAL_CORDIC_CALCULATE_CPLT_CB_ID :
|
|
hcordic->CalculateCpltCallback = pCallback;
|
|
break;
|
|
|
|
case HAL_CORDIC_MSPINIT_CB_ID :
|
|
hcordic->MspInitCallback = pCallback;
|
|
break;
|
|
|
|
case HAL_CORDIC_MSPDEINIT_CB_ID :
|
|
hcordic->MspDeInitCallback = pCallback;
|
|
break;
|
|
|
|
default :
|
|
/* Update the error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_INVALID_CALLBACK;
|
|
|
|
/* Return error status */
|
|
status = HAL_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
else if (hcordic->State == HAL_CORDIC_STATE_RESET)
|
|
{
|
|
switch (CallbackID)
|
|
{
|
|
case HAL_CORDIC_MSPINIT_CB_ID :
|
|
hcordic->MspInitCallback = pCallback;
|
|
break;
|
|
|
|
case HAL_CORDIC_MSPDEINIT_CB_ID :
|
|
hcordic->MspDeInitCallback = pCallback;
|
|
break;
|
|
|
|
default :
|
|
/* Update the error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_INVALID_CALLBACK;
|
|
|
|
/* Return error status */
|
|
status = HAL_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Update the error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_INVALID_CALLBACK;
|
|
|
|
/* Return error status */
|
|
status = HAL_ERROR;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
#endif /* USE_HAL_CORDIC_REGISTER_CALLBACKS */
|
|
|
|
#if USE_HAL_CORDIC_REGISTER_CALLBACKS == 1
|
|
/**
|
|
* @brief Unregister a CORDIC CallBack.
|
|
* CORDIC callback is redirected to the weak predefined callback.
|
|
* @param hcordic pointer to a CORDIC_HandleTypeDef structure that contains
|
|
* the configuration information for CORDIC module
|
|
* @param CallbackID ID of the callback to be unregistered
|
|
* This parameter can be one of the following values:
|
|
* @arg @ref HAL_CORDIC_ERROR_CB_ID error Callback ID
|
|
* @arg @ref HAL_CORDIC_CALCULATE_CPLT_CB_ID calculate complete Callback ID
|
|
* @arg @ref HAL_CORDIC_MSPINIT_CB_ID MspInit callback ID
|
|
* @arg @ref HAL_CORDIC_MSPDEINIT_CB_ID MspDeInit callback ID
|
|
* @retval HAL status
|
|
*/
|
|
HAL_StatusTypeDef HAL_CORDIC_UnRegisterCallback(CORDIC_HandleTypeDef *hcordic, HAL_CORDIC_CallbackIDTypeDef CallbackID)
|
|
{
|
|
HAL_StatusTypeDef status = HAL_OK;
|
|
|
|
if (hcordic->State == HAL_CORDIC_STATE_READY)
|
|
{
|
|
switch (CallbackID)
|
|
{
|
|
case HAL_CORDIC_ERROR_CB_ID :
|
|
hcordic->ErrorCallback = HAL_CORDIC_ErrorCallback;
|
|
break;
|
|
|
|
case HAL_CORDIC_CALCULATE_CPLT_CB_ID :
|
|
hcordic->CalculateCpltCallback = HAL_CORDIC_CalculateCpltCallback;
|
|
break;
|
|
|
|
case HAL_CORDIC_MSPINIT_CB_ID :
|
|
hcordic->MspInitCallback = HAL_CORDIC_MspInit;
|
|
break;
|
|
|
|
case HAL_CORDIC_MSPDEINIT_CB_ID :
|
|
hcordic->MspDeInitCallback = HAL_CORDIC_MspDeInit;
|
|
break;
|
|
|
|
default :
|
|
/* Update the error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_INVALID_CALLBACK;
|
|
|
|
/* Return error status */
|
|
status = HAL_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
else if (hcordic->State == HAL_CORDIC_STATE_RESET)
|
|
{
|
|
switch (CallbackID)
|
|
{
|
|
case HAL_CORDIC_MSPINIT_CB_ID :
|
|
hcordic->MspInitCallback = HAL_CORDIC_MspInit;
|
|
break;
|
|
|
|
case HAL_CORDIC_MSPDEINIT_CB_ID :
|
|
hcordic->MspDeInitCallback = HAL_CORDIC_MspDeInit;
|
|
break;
|
|
|
|
default :
|
|
/* Update the error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_INVALID_CALLBACK;
|
|
|
|
/* Return error status */
|
|
status = HAL_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Update the error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_INVALID_CALLBACK;
|
|
|
|
/* Return error status */
|
|
status = HAL_ERROR;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
#endif /* USE_HAL_CORDIC_REGISTER_CALLBACKS */
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/** @defgroup CORDIC_Exported_Functions_Group2 Peripheral Control functions
|
|
* @brief Control functions.
|
|
*
|
|
@verbatim
|
|
==============================================================================
|
|
##### Peripheral Control functions #####
|
|
==============================================================================
|
|
[..] This section provides functions allowing to:
|
|
(+) Configure the CORDIC peripheral: function, precision, scaling factor,
|
|
number of input data and output data, size of input data and output data.
|
|
(+) Calculate output data of CORDIC processing on input date, using the
|
|
existing CORDIC configuration
|
|
[..] Four processing functions are available for calculation:
|
|
(+) Polling mode
|
|
(+) Polling mode, with Zero-Overhead register access
|
|
(+) Interrupt mode
|
|
(+) DMA mode
|
|
|
|
@endverbatim
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* @brief Configure the CORDIC processing according to the specified
|
|
parameters in the CORDIC_ConfigTypeDef structure.
|
|
* @param hcordic pointer to a CORDIC_HandleTypeDef structure that contains
|
|
* the configuration information for CORDIC module
|
|
* @param sConfig pointer to a CORDIC_ConfigTypeDef structure that
|
|
* contains the CORDIC configuration information.
|
|
* @retval HAL status
|
|
*/
|
|
HAL_StatusTypeDef HAL_CORDIC_Configure(CORDIC_HandleTypeDef *hcordic, CORDIC_ConfigTypeDef *sConfig)
|
|
{
|
|
HAL_StatusTypeDef status = HAL_OK;
|
|
|
|
/* Check the parameters */
|
|
assert_param(IS_CORDIC_FUNCTION(sConfig->Function));
|
|
assert_param(IS_CORDIC_PRECISION(sConfig->Precision));
|
|
assert_param(IS_CORDIC_SCALE(sConfig->Scale));
|
|
assert_param(IS_CORDIC_NBWRITE(sConfig->NbWrite));
|
|
assert_param(IS_CORDIC_NBREAD(sConfig->NbRead));
|
|
assert_param(IS_CORDIC_INSIZE(sConfig->InSize));
|
|
assert_param(IS_CORDIC_OUTSIZE(sConfig->OutSize));
|
|
|
|
/* Check handle state is ready */
|
|
if (hcordic->State == HAL_CORDIC_STATE_READY)
|
|
{
|
|
/* Apply all configuration parameters in CORDIC control register */
|
|
MODIFY_REG(hcordic->Instance->CSR, \
|
|
(CORDIC_CSR_FUNC | CORDIC_CSR_PRECISION | CORDIC_CSR_SCALE | \
|
|
CORDIC_CSR_NARGS | CORDIC_CSR_NRES | CORDIC_CSR_ARGSIZE | CORDIC_CSR_RESSIZE), \
|
|
(sConfig->Function | sConfig->Precision | sConfig->Scale | \
|
|
sConfig->NbWrite | sConfig->NbRead | sConfig->InSize | sConfig->OutSize));
|
|
}
|
|
else
|
|
{
|
|
/* Set CORDIC error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_NOT_READY;
|
|
|
|
/* Return error status */
|
|
status = HAL_ERROR;
|
|
}
|
|
|
|
/* Return function status */
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Carry out data of CORDIC processing in polling mode,
|
|
* according to the existing CORDIC configuration.
|
|
* @param hcordic pointer to a CORDIC_HandleTypeDef structure that contains
|
|
* the configuration information for CORDIC module.
|
|
* @param pInBuff Pointer to buffer containing input data for CORDIC processing.
|
|
* @param pOutBuff Pointer to buffer where output data of CORDIC processing will be stored.
|
|
* @param NbCalc Number of CORDIC calculation to process.
|
|
* @param Timeout Specify Timeout value
|
|
* @retval HAL status
|
|
*/
|
|
HAL_StatusTypeDef HAL_CORDIC_Calculate(CORDIC_HandleTypeDef *hcordic, int32_t *pInBuff, int32_t *pOutBuff,
|
|
uint32_t NbCalc, uint32_t Timeout)
|
|
{
|
|
uint32_t tickstart;
|
|
uint32_t index;
|
|
int32_t *p_tmp_in_buff = pInBuff;
|
|
int32_t *p_tmp_out_buff = pOutBuff;
|
|
|
|
/* Check parameters setting */
|
|
if ((pInBuff == NULL) || (pOutBuff == NULL) || (NbCalc == 0U))
|
|
{
|
|
/* Update the error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_PARAM;
|
|
|
|
/* Return error status */
|
|
return HAL_ERROR;
|
|
}
|
|
|
|
/* Check handle state is ready */
|
|
if (hcordic->State == HAL_CORDIC_STATE_READY)
|
|
{
|
|
/* Reset CORDIC error code */
|
|
hcordic->ErrorCode = HAL_CORDIC_ERROR_NONE;
|
|
|
|
/* Change the CORDIC state */
|
|
hcordic->State = HAL_CORDIC_STATE_BUSY;
|
|
|
|
/* Get tick */
|
|
tickstart = HAL_GetTick();
|
|
|
|
/* Write of input data in Write Data register, and increment input buffer pointer */
|
|
CORDIC_WriteInDataIncrementPtr(hcordic, &p_tmp_in_buff);
|
|
|
|
/* Calculation is started.
|
|
Provide next set of input data, until number of calculation is achieved */
|
|
for (index = (NbCalc - 1U); index > 0U; index--)
|
|
{
|
|
/* Write of input data in Write Data register, and increment input buffer pointer */
|
|
CORDIC_WriteInDataIncrementPtr(hcordic, &p_tmp_in_buff);
|
|
|
|
/* Wait for RRDY flag to be raised */
|
|
do
|
|
{
|
|
/* Check for the Timeout */
|
|
if (Timeout != HAL_MAX_DELAY)
|
|
{
|
|
if ((HAL_GetTick() - tickstart) > Timeout)
|
|
{
|
|
/* Set CORDIC error code */
|
|
hcordic->ErrorCode = HAL_CORDIC_ERROR_TIMEOUT;
|
|
|
|
/* Change the CORDIC state */
|
|
hcordic->State = HAL_CORDIC_STATE_READY;
|
|
|
|
/* Return function status */
|
|
return HAL_ERROR;
|
|
}
|
|
}
|
|
} while (HAL_IS_BIT_CLR(hcordic->Instance->CSR, CORDIC_CSR_RRDY));
|
|
|
|
/* Read output data from Read Data register, and increment output buffer pointer */
|
|
CORDIC_ReadOutDataIncrementPtr(hcordic, &p_tmp_out_buff);
|
|
}
|
|
|
|
/* Read output data from Read Data register, and increment output buffer pointer */
|
|
CORDIC_ReadOutDataIncrementPtr(hcordic, &p_tmp_out_buff);
|
|
|
|
/* Change the CORDIC state */
|
|
hcordic->State = HAL_CORDIC_STATE_READY;
|
|
|
|
/* Return function status */
|
|
return HAL_OK;
|
|
}
|
|
else
|
|
{
|
|
/* Set CORDIC error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_NOT_READY;
|
|
|
|
/* Return function status */
|
|
return HAL_ERROR;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Carry out data of CORDIC processing in Zero-Overhead mode (output data being read
|
|
* soon as input data are written), according to the existing CORDIC configuration.
|
|
* @param hcordic pointer to a CORDIC_HandleTypeDef structure that contains
|
|
* the configuration information for CORDIC module.
|
|
* @param pInBuff Pointer to buffer containing input data for CORDIC processing.
|
|
* @param pOutBuff Pointer to buffer where output data of CORDIC processing will be stored.
|
|
* @param NbCalc Number of CORDIC calculation to process.
|
|
* @param Timeout Specify Timeout value
|
|
* @retval HAL status
|
|
*/
|
|
HAL_StatusTypeDef HAL_CORDIC_CalculateZO(CORDIC_HandleTypeDef *hcordic, int32_t *pInBuff, int32_t *pOutBuff,
|
|
uint32_t NbCalc, uint32_t Timeout)
|
|
{
|
|
uint32_t tickstart;
|
|
uint32_t index;
|
|
int32_t *p_tmp_in_buff = pInBuff;
|
|
int32_t *p_tmp_out_buff = pOutBuff;
|
|
|
|
/* Check parameters setting */
|
|
if ((pInBuff == NULL) || (pOutBuff == NULL) || (NbCalc == 0U))
|
|
{
|
|
/* Update the error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_PARAM;
|
|
|
|
/* Return error status */
|
|
return HAL_ERROR;
|
|
}
|
|
|
|
/* Check handle state is ready */
|
|
if (hcordic->State == HAL_CORDIC_STATE_READY)
|
|
{
|
|
/* Reset CORDIC error code */
|
|
hcordic->ErrorCode = HAL_CORDIC_ERROR_NONE;
|
|
|
|
/* Change the CORDIC state */
|
|
hcordic->State = HAL_CORDIC_STATE_BUSY;
|
|
|
|
/* Get tick */
|
|
tickstart = HAL_GetTick();
|
|
|
|
/* Write of input data in Write Data register, and increment input buffer pointer */
|
|
CORDIC_WriteInDataIncrementPtr(hcordic, &p_tmp_in_buff);
|
|
|
|
/* Calculation is started.
|
|
Provide next set of input data, until number of calculation is achieved */
|
|
for (index = (NbCalc - 1U); index > 0U; index--)
|
|
{
|
|
/* Write of input data in Write Data register, and increment input buffer pointer */
|
|
CORDIC_WriteInDataIncrementPtr(hcordic, &p_tmp_in_buff);
|
|
|
|
/* Read output data from Read Data register, and increment output buffer pointer
|
|
The reading is performed in Zero-Overhead mode:
|
|
reading is ordered immediately without waiting result ready flag */
|
|
CORDIC_ReadOutDataIncrementPtr(hcordic, &p_tmp_out_buff);
|
|
|
|
/* Check for the Timeout */
|
|
if (Timeout != HAL_MAX_DELAY)
|
|
{
|
|
if ((HAL_GetTick() - tickstart) > Timeout)
|
|
{
|
|
/* Set CORDIC error code */
|
|
hcordic->ErrorCode = HAL_CORDIC_ERROR_TIMEOUT;
|
|
|
|
/* Change the CORDIC state */
|
|
hcordic->State = HAL_CORDIC_STATE_READY;
|
|
|
|
/* Return function status */
|
|
return HAL_ERROR;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Read output data from Read Data register, and increment output buffer pointer
|
|
The reading is performed in Zero-Overhead mode:
|
|
reading is ordered immediately without waiting result ready flag */
|
|
CORDIC_ReadOutDataIncrementPtr(hcordic, &p_tmp_out_buff);
|
|
|
|
/* Change the CORDIC state */
|
|
hcordic->State = HAL_CORDIC_STATE_READY;
|
|
|
|
/* Return function status */
|
|
return HAL_OK;
|
|
}
|
|
else
|
|
{
|
|
/* Set CORDIC error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_NOT_READY;
|
|
|
|
/* Return function status */
|
|
return HAL_ERROR;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Carry out data of CORDIC processing in interrupt mode,
|
|
* according to the existing CORDIC configuration.
|
|
* @param hcordic pointer to a CORDIC_HandleTypeDef structure that contains
|
|
* the configuration information for CORDIC module.
|
|
* @param pInBuff Pointer to buffer containing input data for CORDIC processing.
|
|
* @param pOutBuff Pointer to buffer where output data of CORDIC processing will be stored.
|
|
* @param NbCalc Number of CORDIC calculation to process.
|
|
* @retval HAL status
|
|
*/
|
|
HAL_StatusTypeDef HAL_CORDIC_Calculate_IT(CORDIC_HandleTypeDef *hcordic, int32_t *pInBuff, int32_t *pOutBuff,
|
|
uint32_t NbCalc)
|
|
{
|
|
int32_t *tmp_pInBuff = pInBuff;
|
|
|
|
/* Check parameters setting */
|
|
if ((pInBuff == NULL) || (pOutBuff == NULL) || (NbCalc == 0U))
|
|
{
|
|
/* Update the error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_PARAM;
|
|
|
|
/* Return error status */
|
|
return HAL_ERROR;
|
|
}
|
|
|
|
/* Check handle state is ready */
|
|
if (hcordic->State == HAL_CORDIC_STATE_READY)
|
|
{
|
|
/* Reset CORDIC error code */
|
|
hcordic->ErrorCode = HAL_CORDIC_ERROR_NONE;
|
|
|
|
/* Change the CORDIC state */
|
|
hcordic->State = HAL_CORDIC_STATE_BUSY;
|
|
|
|
/* Store the buffers addresses and number of calculations in handle,
|
|
provisioning initial write of input data that will be done */
|
|
if (HAL_IS_BIT_SET(hcordic->Instance->CSR, CORDIC_CSR_NARGS))
|
|
{
|
|
/* Two writes of input data are expected */
|
|
tmp_pInBuff++;
|
|
tmp_pInBuff++;
|
|
}
|
|
else
|
|
{
|
|
/* One write of input data is expected */
|
|
tmp_pInBuff++;
|
|
}
|
|
hcordic->pInBuff = tmp_pInBuff;
|
|
hcordic->pOutBuff = pOutBuff;
|
|
hcordic->NbCalcToOrder = NbCalc - 1U;
|
|
hcordic->NbCalcToGet = NbCalc;
|
|
|
|
/* Enable Result Ready Interrupt */
|
|
__HAL_CORDIC_ENABLE_IT(hcordic, CORDIC_IT_IEN);
|
|
|
|
/* Set back pointer to start of input data buffer */
|
|
tmp_pInBuff = pInBuff;
|
|
|
|
/* Initiate the processing by providing input data
|
|
in the Write Data register */
|
|
WRITE_REG(hcordic->Instance->WDATA, (uint32_t)*tmp_pInBuff);
|
|
|
|
/* Check if second write of input data is expected */
|
|
if (HAL_IS_BIT_SET(hcordic->Instance->CSR, CORDIC_CSR_NARGS))
|
|
{
|
|
/* Increment pointer to input data */
|
|
tmp_pInBuff++;
|
|
|
|
/* Perform second write of input data */
|
|
WRITE_REG(hcordic->Instance->WDATA, (uint32_t)*tmp_pInBuff);
|
|
}
|
|
|
|
/* Return function status */
|
|
return HAL_OK;
|
|
}
|
|
else
|
|
{
|
|
/* Set CORDIC error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_NOT_READY;
|
|
|
|
/* Return function status */
|
|
return HAL_ERROR;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Carry out input and/or output data of CORDIC processing in DMA mode,
|
|
* according to the existing CORDIC configuration.
|
|
* @param hcordic pointer to a CORDIC_HandleTypeDef structure that contains
|
|
* the configuration information for CORDIC module.
|
|
* @param pInBuff Pointer to buffer containing input data for CORDIC processing.
|
|
* @param pOutBuff Pointer to buffer where output data of CORDIC processing will be stored.
|
|
* @param NbCalc Number of CORDIC calculation to process.
|
|
* @param DMADirection Direction of DMA transfers.
|
|
* This parameter can be one of the following values:
|
|
* @arg @ref CORDIC_DMA_Direction CORDIC DMA direction
|
|
* @note pInBuff or pOutBuff is unused in case of unique DMADirection transfer, and can
|
|
* be set to NULL value in this case.
|
|
* @note pInBuff and pOutBuff buffers must be 32-bit aligned to ensure a correct
|
|
* DMA transfer to and from the Peripheral.
|
|
* @retval HAL status
|
|
*/
|
|
HAL_StatusTypeDef HAL_CORDIC_Calculate_DMA(CORDIC_HandleTypeDef *hcordic, int32_t *pInBuff, int32_t *pOutBuff,
|
|
uint32_t NbCalc, uint32_t DMADirection)
|
|
{
|
|
uint32_t sizeinbuff;
|
|
uint32_t sizeoutbuff;
|
|
uint32_t inputaddr;
|
|
uint32_t outputaddr;
|
|
|
|
/* Check the parameters */
|
|
assert_param(IS_CORDIC_DMA_DIRECTION(DMADirection));
|
|
|
|
/* Check parameters setting */
|
|
if (NbCalc == 0U)
|
|
{
|
|
/* Update the error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_PARAM;
|
|
|
|
/* Return error status */
|
|
return HAL_ERROR;
|
|
}
|
|
|
|
/* Check if CORDIC DMA direction "Out" is requested */
|
|
if ((DMADirection == CORDIC_DMA_DIR_OUT) || (DMADirection == CORDIC_DMA_DIR_IN_OUT))
|
|
{
|
|
/* Check parameters setting */
|
|
if (pOutBuff == NULL)
|
|
{
|
|
/* Update the error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_PARAM;
|
|
|
|
/* Return error status */
|
|
return HAL_ERROR;
|
|
}
|
|
}
|
|
|
|
/* Check if CORDIC DMA direction "In" is requested */
|
|
if ((DMADirection == CORDIC_DMA_DIR_IN) || (DMADirection == CORDIC_DMA_DIR_IN_OUT))
|
|
{
|
|
/* Check parameters setting */
|
|
if (pInBuff == NULL)
|
|
{
|
|
/* Update the error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_PARAM;
|
|
|
|
/* Return error status */
|
|
return HAL_ERROR;
|
|
}
|
|
}
|
|
|
|
if (hcordic->State == HAL_CORDIC_STATE_READY)
|
|
{
|
|
/* Reset CORDIC error code */
|
|
hcordic->ErrorCode = HAL_CORDIC_ERROR_NONE;
|
|
|
|
/* Change the CORDIC state */
|
|
hcordic->State = HAL_CORDIC_STATE_BUSY;
|
|
|
|
/* Get DMA direction */
|
|
hcordic->DMADirection = DMADirection;
|
|
|
|
/* Check if CORDIC DMA direction "Out" is requested */
|
|
if ((DMADirection == CORDIC_DMA_DIR_OUT) || (DMADirection == CORDIC_DMA_DIR_IN_OUT))
|
|
{
|
|
/* Set the CORDIC DMA transfer complete callback */
|
|
hcordic->hdmaOut->XferCpltCallback = CORDIC_DMAOutCplt;
|
|
/* Set the DMA error callback */
|
|
hcordic->hdmaOut->XferErrorCallback = CORDIC_DMAError;
|
|
|
|
/* Check number of output data at each calculation,
|
|
to retrieve the size of output data buffer */
|
|
if (HAL_IS_BIT_SET(hcordic->Instance->CSR, CORDIC_CSR_NRES))
|
|
{
|
|
sizeoutbuff = 2U * NbCalc;
|
|
}
|
|
else
|
|
{
|
|
sizeoutbuff = NbCalc;
|
|
}
|
|
|
|
outputaddr = (uint32_t)pOutBuff;
|
|
|
|
/* Enable the DMA stream managing CORDIC output data read */
|
|
if (HAL_DMA_Start_IT(hcordic->hdmaOut, (uint32_t)&hcordic->Instance->RDATA, outputaddr, sizeoutbuff) != HAL_OK)
|
|
{
|
|
/* Update the error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_DMA;
|
|
|
|
/* Return error status */
|
|
return HAL_ERROR;
|
|
}
|
|
|
|
/* Enable output data Read DMA requests */
|
|
SET_BIT(hcordic->Instance->CSR, CORDIC_DMA_REN);
|
|
}
|
|
|
|
/* Check if CORDIC DMA direction "In" is requested */
|
|
if ((DMADirection == CORDIC_DMA_DIR_IN) || (DMADirection == CORDIC_DMA_DIR_IN_OUT))
|
|
{
|
|
/* Set the CORDIC DMA transfer complete callback */
|
|
hcordic->hdmaIn->XferCpltCallback = CORDIC_DMAInCplt;
|
|
/* Set the DMA error callback */
|
|
hcordic->hdmaIn->XferErrorCallback = CORDIC_DMAError;
|
|
|
|
/* Check number of input data expected for each calculation,
|
|
to retrieve the size of input data buffer */
|
|
if (HAL_IS_BIT_SET(hcordic->Instance->CSR, CORDIC_CSR_NARGS))
|
|
{
|
|
sizeinbuff = 2U * NbCalc;
|
|
}
|
|
else
|
|
{
|
|
sizeinbuff = NbCalc;
|
|
}
|
|
|
|
inputaddr = (uint32_t)pInBuff;
|
|
|
|
/* Enable the DMA stream managing CORDIC input data write */
|
|
if (HAL_DMA_Start_IT(hcordic->hdmaIn, inputaddr, (uint32_t)&hcordic->Instance->WDATA, sizeinbuff) != HAL_OK)
|
|
{
|
|
/* Update the error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_DMA;
|
|
|
|
/* Return error status */
|
|
return HAL_ERROR;
|
|
}
|
|
|
|
/* Enable input data Write DMA request */
|
|
SET_BIT(hcordic->Instance->CSR, CORDIC_DMA_WEN);
|
|
}
|
|
|
|
/* Return function status */
|
|
return HAL_OK;
|
|
}
|
|
else
|
|
{
|
|
/* Set CORDIC error code */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_NOT_READY;
|
|
|
|
/* Return function status */
|
|
return HAL_ERROR;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/** @defgroup CORDIC_Exported_Functions_Group3 Callback functions
|
|
* @brief Callback functions.
|
|
*
|
|
@verbatim
|
|
==============================================================================
|
|
##### Callback functions #####
|
|
==============================================================================
|
|
[..] This section provides Interruption and DMA callback functions:
|
|
(+) DMA or Interrupt calculate complete
|
|
(+) DMA or Interrupt error
|
|
|
|
@endverbatim
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* @brief CORDIC error callback.
|
|
* @param hcordic pointer to a CORDIC_HandleTypeDef structure that contains
|
|
* the configuration information for CORDIC module
|
|
* @retval None
|
|
*/
|
|
__weak void HAL_CORDIC_ErrorCallback(CORDIC_HandleTypeDef *hcordic)
|
|
{
|
|
/* Prevent unused argument(s) compilation warning */
|
|
UNUSED(hcordic);
|
|
|
|
/* NOTE : This function should not be modified; when the callback is needed,
|
|
the HAL_CORDIC_ErrorCallback can be implemented in the user file
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* @brief CORDIC calculate complete callback.
|
|
* @param hcordic pointer to a CORDIC_HandleTypeDef structure that contains
|
|
* the configuration information for CORDIC module
|
|
* @retval None
|
|
*/
|
|
__weak void HAL_CORDIC_CalculateCpltCallback(CORDIC_HandleTypeDef *hcordic)
|
|
{
|
|
/* Prevent unused argument(s) compilation warning */
|
|
UNUSED(hcordic);
|
|
|
|
/* NOTE : This function should not be modified; when the callback is needed,
|
|
the HAL_CORDIC_CalculateCpltCallback can be implemented in the user file
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/** @defgroup CORDIC_Exported_Functions_Group4 IRQ handler management
|
|
* @brief IRQ handler.
|
|
*
|
|
@verbatim
|
|
==============================================================================
|
|
##### IRQ handler management #####
|
|
==============================================================================
|
|
[..] This section provides IRQ handler function.
|
|
|
|
@endverbatim
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* @brief Handle CORDIC interrupt request.
|
|
* @param hcordic pointer to a CORDIC_HandleTypeDef structure that contains
|
|
* the configuration information for CORDIC module
|
|
* @retval None
|
|
*/
|
|
void HAL_CORDIC_IRQHandler(CORDIC_HandleTypeDef *hcordic)
|
|
{
|
|
/* Check if calculation complete interrupt is enabled and if result ready
|
|
flag is raised */
|
|
if (__HAL_CORDIC_GET_IT_SOURCE(hcordic, CORDIC_IT_IEN) != 0U)
|
|
{
|
|
if (__HAL_CORDIC_GET_FLAG(hcordic, CORDIC_FLAG_RRDY) != 0U)
|
|
{
|
|
/* Decrement number of calculations to get */
|
|
hcordic->NbCalcToGet--;
|
|
|
|
/* Read output data from Read Data register, and increment output buffer pointer */
|
|
CORDIC_ReadOutDataIncrementPtr(hcordic, &(hcordic->pOutBuff));
|
|
|
|
/* Check if calculations are still to be ordered */
|
|
if (hcordic->NbCalcToOrder > 0U)
|
|
{
|
|
/* Decrement number of calculations to order */
|
|
hcordic->NbCalcToOrder--;
|
|
|
|
/* Continue the processing by providing another write of input data
|
|
in the Write Data register, and increment input buffer pointer */
|
|
CORDIC_WriteInDataIncrementPtr(hcordic, &(hcordic->pInBuff));
|
|
}
|
|
|
|
/* Check if all calculations results are got */
|
|
if (hcordic->NbCalcToGet == 0U)
|
|
{
|
|
/* Disable Result Ready Interrupt */
|
|
__HAL_CORDIC_DISABLE_IT(hcordic, CORDIC_IT_IEN);
|
|
|
|
/* Change the CORDIC state */
|
|
hcordic->State = HAL_CORDIC_STATE_READY;
|
|
|
|
/* Call calculation complete callback */
|
|
#if USE_HAL_CORDIC_REGISTER_CALLBACKS == 1
|
|
/*Call registered callback*/
|
|
hcordic->CalculateCpltCallback(hcordic);
|
|
#else
|
|
/*Call legacy weak (surcharged) callback*/
|
|
HAL_CORDIC_CalculateCpltCallback(hcordic);
|
|
#endif /* USE_HAL_CORDIC_REGISTER_CALLBACKS */
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/** @defgroup CORDIC_Exported_Functions_Group5 Peripheral State functions
|
|
* @brief Peripheral State functions.
|
|
*
|
|
@verbatim
|
|
==============================================================================
|
|
##### Peripheral State functions #####
|
|
==============================================================================
|
|
[..]
|
|
This subsection permits to get in run-time the status of the peripheral.
|
|
|
|
@endverbatim
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* @brief Return the CORDIC handle state.
|
|
* @param hcordic pointer to a CORDIC_HandleTypeDef structure that contains
|
|
* the configuration information for CORDIC module
|
|
* @retval HAL state
|
|
*/
|
|
HAL_CORDIC_StateTypeDef HAL_CORDIC_GetState(CORDIC_HandleTypeDef *hcordic)
|
|
{
|
|
/* Return CORDIC handle state */
|
|
return hcordic->State;
|
|
}
|
|
|
|
/**
|
|
* @brief Return the CORDIC peripheral error.
|
|
* @param hcordic pointer to a CORDIC_HandleTypeDef structure that contains
|
|
* the configuration information for CORDIC module
|
|
* @note The returned error is a bit-map combination of possible errors
|
|
* @retval Error bit-map
|
|
*/
|
|
uint32_t HAL_CORDIC_GetError(CORDIC_HandleTypeDef *hcordic)
|
|
{
|
|
/* Return CORDIC error code */
|
|
return hcordic->ErrorCode;
|
|
}
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/** @addtogroup CORDIC_Private_Functions
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* @brief Write input data for CORDIC processing, and increment input buffer pointer.
|
|
* @param hcordic pointer to a CORDIC_HandleTypeDef structure that contains
|
|
* the configuration information for CORDIC module.
|
|
* @param ppInBuff Pointer to pointer to input buffer.
|
|
* @retval none
|
|
*/
|
|
static void CORDIC_WriteInDataIncrementPtr(CORDIC_HandleTypeDef *hcordic, int32_t **ppInBuff)
|
|
{
|
|
/* First write of input data in the Write Data register */
|
|
WRITE_REG(hcordic->Instance->WDATA, (uint32_t) **ppInBuff);
|
|
|
|
/* Increment input data pointer */
|
|
(*ppInBuff)++;
|
|
|
|
/* Check if second write of input data is expected */
|
|
if (HAL_IS_BIT_SET(hcordic->Instance->CSR, CORDIC_CSR_NARGS))
|
|
{
|
|
/* Second write of input data in the Write Data register */
|
|
WRITE_REG(hcordic->Instance->WDATA, (uint32_t) **ppInBuff);
|
|
|
|
/* Increment input data pointer */
|
|
(*ppInBuff)++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Read output data of CORDIC processing, and increment output buffer pointer.
|
|
* @param hcordic pointer to a CORDIC_HandleTypeDef structure that contains
|
|
* the configuration information for CORDIC module.
|
|
* @param ppOutBuff Pointer to pointer to output buffer.
|
|
* @retval none
|
|
*/
|
|
static void CORDIC_ReadOutDataIncrementPtr(CORDIC_HandleTypeDef *hcordic, int32_t **ppOutBuff)
|
|
{
|
|
/* First read of output data from the Read Data register */
|
|
**ppOutBuff = (int32_t)READ_REG(hcordic->Instance->RDATA);
|
|
|
|
/* Increment output data pointer */
|
|
(*ppOutBuff)++;
|
|
|
|
/* Check if second read of output data is expected */
|
|
if (HAL_IS_BIT_SET(hcordic->Instance->CSR, CORDIC_CSR_NRES))
|
|
{
|
|
/* Second read of output data from the Read Data register */
|
|
**ppOutBuff = (int32_t)READ_REG(hcordic->Instance->RDATA);
|
|
|
|
/* Increment output data pointer */
|
|
(*ppOutBuff)++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief DMA CORDIC Input Data process complete callback.
|
|
* @param hdma DMA handle.
|
|
* @retval None
|
|
*/
|
|
static void CORDIC_DMAInCplt(DMA_HandleTypeDef *hdma)
|
|
{
|
|
CORDIC_HandleTypeDef *hcordic = (CORDIC_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
|
|
|
|
/* Disable the DMA transfer for input request */
|
|
CLEAR_BIT(hcordic->Instance->CSR, CORDIC_DMA_WEN);
|
|
|
|
/* Check if DMA direction is CORDIC Input only (no DMA for CORDIC Output) */
|
|
if (hcordic->DMADirection == CORDIC_DMA_DIR_IN)
|
|
{
|
|
/* Change the CORDIC DMA direction to none */
|
|
hcordic->DMADirection = CORDIC_DMA_DIR_NONE;
|
|
|
|
/* Change the CORDIC state to ready */
|
|
hcordic->State = HAL_CORDIC_STATE_READY;
|
|
|
|
/* Call calculation complete callback */
|
|
#if USE_HAL_CORDIC_REGISTER_CALLBACKS == 1
|
|
/*Call registered callback*/
|
|
hcordic->CalculateCpltCallback(hcordic);
|
|
#else
|
|
/*Call legacy weak (surcharged) callback*/
|
|
HAL_CORDIC_CalculateCpltCallback(hcordic);
|
|
#endif /* USE_HAL_CORDIC_REGISTER_CALLBACKS */
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief DMA CORDIC Output Data process complete callback.
|
|
* @param hdma DMA handle.
|
|
* @retval None
|
|
*/
|
|
static void CORDIC_DMAOutCplt(DMA_HandleTypeDef *hdma)
|
|
{
|
|
CORDIC_HandleTypeDef *hcordic = (CORDIC_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
|
|
|
|
/* Disable the DMA transfer for output request */
|
|
CLEAR_BIT(hcordic->Instance->CSR, CORDIC_DMA_REN);
|
|
|
|
/* Change the CORDIC DMA direction to none */
|
|
hcordic->DMADirection = CORDIC_DMA_DIR_NONE;
|
|
|
|
/* Change the CORDIC state to ready */
|
|
hcordic->State = HAL_CORDIC_STATE_READY;
|
|
|
|
/* Call calculation complete callback */
|
|
#if USE_HAL_CORDIC_REGISTER_CALLBACKS == 1
|
|
/*Call registered callback*/
|
|
hcordic->CalculateCpltCallback(hcordic);
|
|
#else
|
|
/*Call legacy weak (surcharged) callback*/
|
|
HAL_CORDIC_CalculateCpltCallback(hcordic);
|
|
#endif /* USE_HAL_CORDIC_REGISTER_CALLBACKS */
|
|
}
|
|
|
|
/**
|
|
* @brief DMA CORDIC communication error callback.
|
|
* @param hdma DMA handle.
|
|
* @retval None
|
|
*/
|
|
static void CORDIC_DMAError(DMA_HandleTypeDef *hdma)
|
|
{
|
|
CORDIC_HandleTypeDef *hcordic = (CORDIC_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
|
|
|
|
/* Set CORDIC handle state to error */
|
|
hcordic->State = HAL_CORDIC_STATE_READY;
|
|
|
|
/* Set CORDIC handle error code to DMA error */
|
|
hcordic->ErrorCode |= HAL_CORDIC_ERROR_DMA;
|
|
|
|
/* Call user callback */
|
|
#if USE_HAL_CORDIC_REGISTER_CALLBACKS == 1
|
|
/*Call registered callback*/
|
|
hcordic->ErrorCallback(hcordic);
|
|
#else
|
|
/*Call legacy weak (surcharged) callback*/
|
|
HAL_CORDIC_ErrorCallback(hcordic);
|
|
#endif /* USE_HAL_CORDIC_REGISTER_CALLBACKS */
|
|
}
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
#endif /* HAL_CORDIC_MODULE_ENABLED */
|
|
#endif /* CORDIC */
|