/**
 * @file xmc_dsd.h
 * @date 2015-09-18
 *
 * @cond
 *********************************************************************************************************************
 * XMClib v2.1.16 - XMC Peripheral Driver Library 
 *
 * Copyright (c) 2015-2017, Infineon Technologies AG
 * All rights reserved.                        
 *                                             
 * Redistribution and use in source and binary forms, with or without modification,are permitted provided that the 
 * following conditions are met:   
 *                                                                              
 * Redistributions of source code must retain the above copyright notice, this list of conditions and the following 
 * disclaimer.                        
 * 
 * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following 
 * disclaimer in the documentation and/or other materials provided with the distribution.                       
 * 
 * Neither the name of the copyright holders nor the names of its contributors may be used to endorse or promote 
 * products derived from this software without specific prior written permission.                                           
 *                                                                              
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE  
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE  FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR  
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
 * WHETHER IN CONTRACT, STRICT LIABILITY,OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                                                  
 *                                                                              
 * To improve the quality of the software, users are encouraged to share modifications, enhancements or bug fixes with 
 * Infineon Technologies AG dave@infineon.com).                                                          
 *********************************************************************************************************************
 *
 * Change History
 * --------------
 *
 * 2015-03-30:
 *     - Initial version
 *      
 * 2015-06-19:
 *     - Removed version macros and declaration of GetDriverVersion API <BR>
 *     - Added API XMC_DSD_CH_GetRectifyDelay <BR>
 *
 * 2015-07-16:
 *     - Renamed API “XMC_DSD_CH_AuxFilter_SetBoudary()” to “XMC_DSD_CH_AuxFilter_SetBoundary()” <BR>
 *
 * 2015-09-18:
 *     - Added APIs "XMC_DSD_SetResultEventFlag()","XMC_DSD_ClearResultEventFlag()"
 *       "XMC_DSD_SetAlarmEventFlag()" and "XMC_DSD_ClearAlarmEventFlag()" <BR>
 *     - Support added for XMC4800 microcontroller family <BR>
 * @endcond
 *
 */


#ifndef XMC_DSD_H
#define XMC_DSD_H


/**********************************************************************************************************************
 * HEADER FILES
 *********************************************************************************************************************/
#include <xmc_common.h>

#if defined(DSD)
#include <xmc_scu.h>

/**
 * @addtogroup XMClib XMC Peripheral Library
 * @{
 */

/**
 * @addtogroup DSD
* @{
* @brief Delta Sigma Demodulator (DSD) driver for the XMC4500, XMC4400 and XMC4800 microcontroller family <br>
 *
 * The DSD unit provides a series of digital input channels accepting data streams from external modulators
 * using the Delta/Sigma (DS) conversion principle. The on-chip demodulator channels convert these inputs to 
 * discrete digital values.
 * DSD unit can be used for isolated current/voltage measurement and for sensor interfaces.<br>
 *
 * Driver is divided in six DSD functional blocks -
 * - Main Filter (APIs prefixed with XMC_DSD_CH_MainFilter),
 * - Aux Filter (APIs prefixed with XMC_DSD_CH_AuxFilter),
 * - Integrator (APIs prefixed with XMC_DSD_CH_Integrator),
 * - Timestamp  (APIs prefixed with XMC_DSD_CH_Timestamp),
 * - Rectification (APIs prefixed with XMC_DSD_CH_Rectify),
 * - Carrier Generator (APIs prefixed with XMC_DSD_Generator)
 *
 * DSD driver features:
 * -# DSD channel Configuration structure XMC_DSD_CH_CONFIG_t initialization function XMC_DSD_CH_Init() to configure all the functional blocks (except carrier generator)
 * -# Configuration structure XMC_DSD_GENERATOR_CONFIG_t and initialization function XMC_DSD_Generator_Init() to configure carrier generator
 * -# Configuration structure XMC_DSD_CH_FILTER_CONFIG_t and initialization function XMC_DSD_CH_MainFilter_Init() to configure main  filter
 * -# Configuration structure XMC_DSD_CH_AUX_FILTER_CONFIG_t and initialization function XMC_DSD_CH_AuxFilter_Init() to configure auxilary  filter
 * -# Configuration structure XMC_DSD_CH_INTEGRATOR_CONFIG_t and initialization function XMC_DSD_CH_Integrator_Init() to configure integrator
 * -# Configuration structure XMC_DSD_CH_TIMESTAMP_CONFIG_t and initialization function XMC_DSD_CH_Timestamp_Init() to configure timestamp
 * -# Configuration structure XMC_DSD_CH_RECTIFY_CONFIG_t and initialization function XMC_DSD_CH_Rectify_Init() to configure rectifier
 */
 
 /*********************************************************************************************************************
 * MACROS
 ********************************************************************************************************************/
 #define XMC_DSD_CHECK_MODULE_PTR(PTR)  ( ((PTR)== DSD))
 #define XMC_DSD_CHECK_CHANNEL_PTR(PTR) ( ((PTR) == DSD_CH0) || ((PTR) == DSD_CH1) || ((PTR) == DSD_CH2) || ((PTR) == DSD_CH3))
 
/**********************************************************************************************************************
 * ENUMS
 *********************************************************************************************************************/
/**
 * DSD Channel
 */
typedef DSD_CH_TypeDef XMC_DSD_CH_t;

/**
 * DSD Module
 */
typedef DSD_GLOBAL_TypeDef XMC_DSD_t;


/**
 * Return types of the API's.Use type @ref XMC_DSD_STATUS_t for this enum.
 */
typedef enum XMC_DSD_STATUS
{

  XMC_DSD_STATUS_OK,        /**< API fulfills request */
  XMC_DSD_STATUS_ERROR      /**< Error detected */

} XMC_DSD_STATUS_t;

/**
 * Enumerates the divider factor for the PWM pattern signal generator.
 * Use divider factor to derive input frequency of the carrier signal generator(fCG),
 * from the selected internal clock source(fCLK).
 * Use type @ref XMC_DSD_GENERATOR_CLKDIV_t for this enum.
 */
typedef enum XMC_DSD_GENERATOR_CLKDIV
{
  XMC_DSD_GENERATOR_CLKDIV_2048  = 0x00U,   /**< fCG = (fCLK/2)/1024 */
  XMC_DSD_GENERATOR_CLKDIV_4096  = 0x01U,   /**< fCG = (fCLK/4)/1024 */
  XMC_DSD_GENERATOR_CLKDIV_6144  = 0x02U,   /**< fCG = (fCLK/6)/1024 */
  XMC_DSD_GENERATOR_CLKDIV_8192  = 0x03U,   /**< fCG = (fCLK/8)/1024 */
  XMC_DSD_GENERATOR_CLKDIV_10240 = 0x04U,   /**< fCG = (fCLK/10)/1024 */
  XMC_DSD_GENERATOR_CLKDIV_12288 = 0x05U,   /**< fCG = (fCLK/12)/1024 */
  XMC_DSD_GENERATOR_CLKDIV_14336 = 0x06U,   /**< fCG = (fCLK/14)/1024 */
  XMC_DSD_GENERATOR_CLKDIV_16384 = 0x07U,   /**< fCG = (fCLK/16)/1024 */
  XMC_DSD_GENERATOR_CLKDIV_18432 = 0x08U,   /**< fCG = (fCLK/18)/1024 */
  XMC_DSD_GENERATOR_CLKDIV_20480 = 0x09U,   /**< fCG = (fCLK/20)/1024 */
  XMC_DSD_GENERATOR_CLKDIV_22528 = 0x0AU,   /**< fCG = (fCLK/22)/1024 */
  XMC_DSD_GENERATOR_CLKDIV_24576 = 0x0BU,   /**< fCG = (fCLK/24)/1024 */
  XMC_DSD_GENERATOR_CLKDIV_26624 = 0x0CU,   /**< fCG = (fCLK/26)/1024 */
  XMC_DSD_GENERATOR_CLKDIV_28672 = 0x0DU,   /**< fCG = (fCLK/28)/1024 */
  XMC_DSD_GENERATOR_CLKDIV_30720 = 0x0EU,   /**< fCG = (fCLK/30)/1024 */
  XMC_DSD_GENERATOR_CLKDIV_32768 = 0x0FU    /**< fCG = (fCLK/32)/1024 */

} XMC_DSD_GENERATOR_CLKDIV_t;


/**
 * Enumerates the carrier generator operating mode.
 * Use type @ref XMC_DSD_GENERATOR_MODE_t for this enum.
 */
typedef enum XMC_DSD_GENERATOR_MODE
{
  XMC_DSD_GENERATOR_MODE_STOPPED   = 0x00U, /**< Stopped */
  XMC_DSD_GENERATOR_MODE_RECTANGLE = 0x01U, /**< Square wave */
  XMC_DSD_GENERATOR_MODE_TRIANGLE  = 0x02U, /**< Triangle */
  XMC_DSD_GENERATOR_MODE_SINE      = 0x03U /**< Sine wave*/

} XMC_DSD_GENERATOR_MODE_t;


/**
 * Enumerates the CIC(cyclic integrating comb) filter type.
 * Use type @ref XMC_DSD_CH_FILTER_TYPE_t for this enum.
 */
typedef enum XMC_DSD_CH_FILTER_TYPE
{

  XMC_DSD_CH_FILTER_TYPE_CIC1,  /**< CIC1 filter*/
  XMC_DSD_CH_FILTER_TYPE_CIC2,  /**< CIC2 filter*/
  XMC_DSD_CH_FILTER_TYPE_CIC3,  /**< CIC3 filter*/
  XMC_DSD_CH_FILTER_TYPE_CICF   /**< CICF filter*/

} XMC_DSD_CH_FILTER_TYPE_t;

/**
 * Enumerates the input data source select.
 * Use type @ref XMC_DSD_CH_DATA_SOURCE_t for this enum.
 */
typedef enum XMC_DSD_CH_DATA_SOURCE
{

  XMC_DSD_CH_DATA_SOURCE_DISCONNECT  = 0U,  /**< Disconnected */
  XMC_DSD_CH_DATA_SOURCE_A_DIRECT    = 2U,  /**< External source, from input A, direct */
  XMC_DSD_CH_DATA_SOURCE_A_INVERTED  = 3U,  /**< External source, from input A, inverted */
  XMC_DSD_CH_DATA_SOURCE_B_DIRECT    = 4U,  /**< External source, from input B, direct */
  XMC_DSD_CH_DATA_SOURCE_B_INVERTED  = 5U   /**< External source, from input B, inverted */

} XMC_DSD_CH_DATA_SOURCE_t;

/**
 * Enumerates the sample clock source select.
 * Use type @ref XMC_DSD_CH_CLOCK_SOURCE_t for this enum.
 */
typedef enum XMC_DSD_CH_CLOCK_SOURCE
{

  XMC_DSD_CH_CLOCK_SOURCE_A = 1U,        /**< External source, from input A */
  XMC_DSD_CH_CLOCK_SOURCE_B = 2U,        /**< External source, from input B */
  XMC_DSD_CH_CLOCK_SOURCE_C = 3U,        /**< External source, from input C */
  XMC_DSD_CH_CLOCK_SOURCE_D = 4U,        /**< External source, from input D */
  XMC_DSD_CH_CLOCK_SOURCE_INTERN = 15U   /**< Internal clock source */

} XMC_DSD_CH_CLOCK_SOURCE_t;


/**
 * Enumerates the data strobe generation Mode.
 * Use type @ref XMC_DSD_CH_STROBE_t for this enum.
 */
typedef enum XMC_DSD_CH_STROBE
{

  XMC_DSD_CH_STROBE_DIRECT_CLOCK_RISE = 1U,  /* Direct clock, a sample trigger is generated at each rising clock edge */
  XMC_DSD_CH_STROBE_DIRECT_CLOCK_FALL = 2U,  /* Direct clock, a sample trigger is generated at each falling clock edge */
  XMC_DSD_CH_STROBE_DOUBLE_DATA       = 3U,  /* Double data, a sample trigger is generated at each rising and falling clock edge */
  XMC_DSD_CH_STROBE_DOUBLE_CLOCK_RISE = 5U,  /* Double clock, a sample trigger is generated at every 2nd rising clock edge */
  XMC_DSD_CH_STROBE_DOUBLE_CLOCK_FALL = 6U   /* Double clock, a sample trigger is generated at every 2nd falling clock edge */

} XMC_DSD_CH_STROBE_t;


/**
 * Enumerates the divider factor for modulator clock (fMOD).
 * Use divider factor to derive modulator clock frequency(fMOD),
 * from the selected internal clock source(fCLK).
 * Use type @ref XMC_DSD_CH_CLK_t for this enum.
 */
typedef enum XMC_DSD_CH_CLK_DIV
{

  XMC_DSD_CH_CLK_DIV_2,        /**< fMOD = fCLK/2 */
  XMC_DSD_CH_CLK_DIV_4,        /**< fMOD = fCLK/4 */
  XMC_DSD_CH_CLK_DIV_6,        /**< fMOD = fCLK/6 */
  XMC_DSD_CH_CLK_DIV_8,        /**< fMOD = fCLK/8 */
  XMC_DSD_CH_CLK_DIV_10,       /**< fMOD = fCLK/10 */
  XMC_DSD_CH_CLK_DIV_12,       /**< fMOD = fCLK/12 */
  XMC_DSD_CH_CLK_DIV_14,       /**< fMOD = fCLK/14 */
  XMC_DSD_CH_CLK_DIV_16,       /**< fMOD = fCLK/16 */
  XMC_DSD_CH_CLK_DIV_18,       /**< fMOD = fCLK/18 */
  XMC_DSD_CH_CLK_DIV_20,       /**< fMOD = fCLK/20 */
  XMC_DSD_CH_CLK_DIV_22,       /**< fMOD = fCLK/22 */
  XMC_DSD_CH_CLK_DIV_24,       /**< fMOD = fCLK/24 */
  XMC_DSD_CH_CLK_DIV_26,       /**< fMOD = fCLK/26 */
  XMC_DSD_CH_CLK_DIV_28,       /**< fMOD = fCLK/28 */
  XMC_DSD_CH_CLK_DIV_30,       /**< fMOD = fCLK/30 */
  XMC_DSD_CH_CLK_DIV_32        /**< fMOD = fCLK/32 */

} XMC_DSD_CH_CLK_t;

/**
 * Enumerates the integrator trigger mode.
 * Use type @ref XMC_DSD_CH_INTEGRATOR_START_t for this enum.
 */
typedef enum XMC_DSD_CH_INTEGRATOR_START
{
  XMC_DSD_CH_INTEGRATOR_START_OFF,             /**< No integration trigger */
  XMC_DSD_CH_INTEGRATOR_START_TRIGGER_FALL,    /**< Trigger event upon a falling edge */
  XMC_DSD_CH_INTEGRATOR_START_TRIGGER_RISE,    /**< Trigger event upon a rising edge */
  XMC_DSD_CH_INTEGRATOR_START_ALLWAYS_ON       /**< No trigger, integrator active all the time */

} XMC_DSD_CH_INTEGRATOR_START_t;

/**
 * Enumerates the integration enable.
 * Use type @ref XMC_DSD_CH_INTEGRATOR_STOP_t for this enum.
 */
typedef enum XMC_DSD_CH_INTEGRATOR_STOP
{
  XMC_DSD_CH_INTEGRATOR_STOP_END_OF_LOOPS,                /**< Integration stopped upon the inverse trigger event */
  XMC_DSD_CH_INTEGRATOR_STOP_ENDLESS_OR_INVERSE_TRIGGER   /**< Integration enabled upon the defined trigger event. */

} XMC_DSD_CH_INTEGRATOR_STOP_t;


/**
 * Enumerates the trigger signal.
 * Use type @ref XMC_DSD_CH_TRIGGER_SOURCE_t for this enum.
 */
typedef enum XMC_DSD_CH_TRIGGER_SOURCE
{

  XMC_DSD_CH_TRIGGER_SOURCE_A = 0U,       /**< Trigger signal,input A*/
  XMC_DSD_CH_TRIGGER_SOURCE_B = 1U,       /**< Trigger signal,input B*/
  XMC_DSD_CH_TRIGGER_SOURCE_C = 2U,       /**< Trigger signal,input C*/
  XMC_DSD_CH_TRIGGER_SOURCE_D = 3U,       /**< Trigger signal,input D*/
  XMC_DSD_CH_TRIGGER_SOURCE_E = 4U,       /**< Trigger signal,input E*/
  XMC_DSD_CH_TRIGGER_SOURCE_F = 5U,       /**< Trigger signal,input F*/
  XMC_DSD_CH_TRIGGER_SOURCE_G = 6U,       /**< Trigger signal,input G*/
  XMC_DSD_CH_TRIGGER_SOURCE_H = 7U        /**< Trigger signal,input H*/

} XMC_DSD_CH_TRIGGER_SOURCE_t;

/**
 * Enumerates the timestamp trigger mode.
 * Use type @ref XMC_DSD_CH_TIMESTAMP_TRIGGER_t for this enum.
 */
typedef enum XMC_DSD_CH_TIMESTAMP_TRIGGER
{
  XMC_DSD_CH_TIMESTAMP_TRIGGER_DISABLE,    /**< No trigger event*/
  XMC_DSD_CH_TIMESTAMP_TRIGGER_FALL,       /**< Trigger event upon a falling edge*/
  XMC_DSD_CH_TIMESTAMP_TRIGGER_RISE,       /**< Trigger event upon a rising edge*/
  XMC_DSD_CH_TIMESTAMP_TRIGGER_BOTH_EDGES  /**< Trigger event upon both the edge*/

} XMC_DSD_CH_TIMESTAMP_TRIGGER_t;

/**
 * Enumerates the carrier generation mode.
 * Use type @ref XMC_DSD_CH_SIGN_SOURCE_t for this enum.
 */
typedef enum XMC_DSD_CH_SIGN_SOURCE
{
  XMC_DSD_CH_SIGN_SOURCE_ON_CHIP_GENERATOR, /**< Carrier is generated internally by DSD */
  XMC_DSD_CH_SIGN_SOURCE_NEXT_CHANNEL,      /**< Carrier sign signal is generated internally by next channel*/
  XMC_DSD_CH_SIGN_SOURCE_EXTERNAL_A,        /**< Carrier is generated externally, External sign signal A*/
  XMC_DSD_CH_SIGN_SOURCE_EXTERNAL_B         /**< Carrier is generated externally, External sign signal B*/

} XMC_DSD_CH_SIGN_SOURCE_t;

/**
 * Enumerates the channel run control bit register value in global run control register.
 * Use type @ref XMC_DSD_CH_ID_t for this enum.
 */
typedef enum XMC_DSD_CH_ID
{
  XMC_DSD_CH_ID_0 = 1U,   /**< Register value for channel 0 */
  XMC_DSD_CH_ID_1 = 2U,   /**< Register value for channel 1 */
  XMC_DSD_CH_ID_2 = 4U,   /**< Register value for channel 2 */
  XMC_DSD_CH_ID_3 = 8U    /**< Register value for channel 3 */

} XMC_DSD_CH_ID_t;

/**
 * Enumerates the service request generation mode for auxiliary filter.
 * Use type @ref XMC_DSD_CH_AUX_EVENT_t for this enum.
 * Note: This is combined ENUM for SRGA + ESEL bit fields
 */
typedef enum XMC_DSD_CH_AUX_EVENT
{
  XMC_DSD_CH_AUX_EVENT_DISABLED            = 0U,   /**< Service request is disabled */
  XMC_DSD_CH_AUX_EVENT_EVERY_NEW_RESULT    = 1U,   /**< Service request generated for aux filter for every new result */
  XMC_DSD_CH_AUX_EVENT_CAPTURE_SIGN_DELAY  = 2U,   /**< Service request generated for alternate source */
  XMC_DSD_CH_AUX_EVENT_INSIDE_BOUNDARY     = 5U,   /**< Service request generated for aux filter if result is inside boundary */
  XMC_DSD_CH_AUX_EVENT_OUTSIDE_BOUNDARY    = 9U    /**< Service request generated for aux filter if result is outside boundary */

} XMC_DSD_CH_AUX_EVENT_t;

/**
 * Enumerates the service request generation for main chain filter.
 * Use type @ref XMC_DSD_CH_RESULT_EVENT_t for this enum.
 */
typedef enum XMC_DSD_CH_RESULT_EVENT
{
	XMC_DSD_CH_RESULT_EVENT_DISABLE  = 0U,       /**< Disable service request */
	XMC_DSD_CH_RESULT_EVENT_ENABLE   = 3U        /**< Enable service request for each new result value */

} XMC_DSD_CH_RESULT_EVENT_t;


/*********************************************************************************************************************
 * DATA STRUCTURES
 ********************************************************************************************************************/
/*Anonymous structure/union guard start*/
#if defined(__CC_ARM)
  #pragma push
  #pragma anon_unions
#elif defined(__TASKING__)
  #pragma warning 586
#endif

/**
 * DSD generator generates several pattern and frequencies.
 * Use type @ref XMC_DSD_GENERATOR_CONFIG_t for this data structure.
 * Note: Output pins have to be enabled by user.
 */
typedef struct XMC_DSD_GENERATOR_CONFIG
{
  union
  {
    struct
    {
      uint32_t mode: 2;              /**< carrier generator operating mode. This parameter can take a value of XMC_DSD_GENERATOR_MODE_t */
      uint32_t bit_reverse: 1;       /**< should PWM signal be bit-reversed? 0: Normal mode, 1:Bit-reverse mode */
      uint32_t inverted_polarity: 1; /**< should PWM signal start from negative max. 0: Normal, 1: Inverted */
      uint32_t frequency: 4;         /**< Frequency divider value of PWM signal. This parameter can take a value of XMC_DSD_GENERATOR_CLKDIV_t */
      uint32_t :24;
    };
    uint32_t generator_conf;         /**< Carrier generator configuration register(CGCFG)*/
  };
} XMC_DSD_GENERATOR_CONFIG_t;


/**
 *  DSD filter is the basic module of the DSD. It can be used separately or can be combined with the other modules like
 *  integrator, rectify, auxiliary filter etc.
 *  The filter demodulates the incoming bit stream from the delta sigma modulator to a 16 bit result.
 *  Note: Configure or reconfigure filter parameters while the channel is inactive.
 */
typedef struct XMC_DSD_CH_FILTER_CONFIG
{
  uint32_t clock_divider: 4;	/**< This parameter can take a value of XMC_DSD_CH_CLK_t */
  int16_t offset;				/**< Offset subtracted from result.This parameter can take a value of int16_t */
  union
  {
    struct
    {
      uint32_t data_source: 4;	/**< This parameter can take a value of XMC_DSD_CH_DATA_SOURCE_t */
      uint32_t : 12;
      uint32_t clock_source: 4;	/**< This parameter can take a value of XMC_DSD_CH_CLOCK_SOURCE_t */
      uint32_t strobe: 4;		/**< This parameter can take a value of XMC_DSD_CH_STROBE_t */
      uint32_t :8;
    };
    uint32_t demodulator_conf;  /*Demodulator Input Configuration Register*/
  };
  union
  {
    struct
    {
      uint32_t : 8;
      uint32_t filter_type: 2;			/**< This parameter can take a value of XMC_DSD_CH_FILTER_TYPE_t */
      uint32_t : 4;
      uint32_t result_event : 2;        /**< This parameter can take a value of XMC_DSD_CH_RESULT_EVENT_t */
      uint32_t : 8;
      uint32_t : 8;
    };
    uint32_t main_filter_conf;

  };
  uint32_t decimation_factor;     /**< This parameter can be in range of 4 - 256[dec] */
  uint32_t filter_start_value;	  /**< This parameter can be in range of 4 - decimation_factor[dec]*/

} XMC_DSD_CH_FILTER_CONFIG_t;

/**
 *  The integrator is mainly used for high accurate measurement.
 *	Note:DSD Filter is mandatory to use this block.
 */
typedef struct XMC_DSD_CH_INTEGRATOR_CONFIG
{
  union
  {
	struct
	{
	  uint32_t :8;
	  uint32_t start_condition: 2; /**<  Can take a value of XMC_DSD_CH_INTEGRATOR_START_t.Bitfields \a ITRMODE of \a DICFG.*/
	  uint32_t :2;
	  uint32_t trigger_source: 3;  /**<  Can take a value of XMC_DSD_CH_TRIGGER_SOURCE_t.Bitfields \a TRSEL of \a DICFG. */
	  uint32_t :17;
	};
	uint32_t integrator_trigger;   /**< Demodulator Input Configuration Register(\a DICFG).*/

  };
	uint32_t integration_loop;     /**< Integration loops to see stop condition. Bitfields \a REPVAL of \a IWCTR.*/
	uint32_t discarded_values;     /**< Number of mainfilter results,discarded before integration starts.Bitfields \a NVALDIS of \a IWCTR.*/
	uint32_t stop_condition;	   /**< Integrator stop condition. Can take a value of XMC_DSD_CH_INTEGRATOR_STOP_t.Bitfields \a IWS of \a IWCTR.*/
	uint32_t counted_values;	   /**< Number of mainfilter results, integrated to a integrator result.Bitfields \a NVALINT of \a IWCTR.*/

} XMC_DSD_CH_INTEGRATOR_CONFIG_t;

/**
 *  DSD timestamp saves result, filter counter register and integrator count register.
 *	Note: Trigger source for timestamp and integrator trigger are shared.
 *        DSD Filter is mandatory to use this block.
 */
typedef struct XMC_DSD_CH_TIMESTAMP_CONFIG
{
  union
  {
    struct
    {
      uint32_t :10;
      uint32_t trigger_mode:2; /**<  This parameter can take a value of XMC_DSD_CH_TIMESTAMP_TRIGGER_t */
      uint32_t trigger_source: 3; /**<  This parameter can take a value of XMC_DSD_CH_TRIGGER_SOURCE_t */
      uint32_t : 17;
    };
    uint32_t timestamp_conf;
  };
} XMC_DSD_CH_TIMESTAMP_CONFIG_t;

/**
 *  DSD auxiliary Filter is used as fast filter to detect overvoltage or current by defining the boundaries.
 */
typedef struct XMC_DSD_CH_AUX_FILTER_CONFIG
{
  union
  {
    struct
    {
      uint32_t : 8;                             /**< This parameter can be in range of 4 - 256[dec] */
      uint32_t filter_type                : 2;  /**< This parameter can take a value of XMC_DSD_CH_FILTER_TYPE_t */
      uint32_t result_event_type          : 4;  /**< Result event for aux filter and the event select configuration.
                                                     Use enum XMC_DSD_CH_AUX_EVENT_t */
      uint32_t enable_integrator_coupling : 1;  /**< Only enable AUX filter when Integrator is enabled*/
      uint32_t                            : 17;
    };
    uint32_t aux_filter_conf;
  };
  union
  {
    struct
    {
      uint32_t lower_boundary             : 16;	/**< This parameter can take a value of int16_t */
      uint32_t upper_boundary             : 16; /**< This parameter can take a value of int16_t */
    };
    uint32_t boundary_conf;
  };

  uint32_t decimation_factor;                   /**< This parameter can be in range of 4 - 256[dec]*/

} XMC_DSD_CH_AUX_FILTER_CONFIG_t;


/**
 *  DSD Rectify.
 *  Note: DSD Filter and integrator is mandatory to use this block.
 */
typedef struct XMC_DSD_CH_RECTIFY_CONFIG
{
  union
  {
    struct
    {
      uint32_t :4;
      uint32_t sign_source: 2; /**< Can take a value of XMC_DSD_CH_SIGN_SOURCE_t.Bitfields \a SSRC of \a RECTCFG.*/
      uint32_t :26;
    };
    uint32_t rectify_config;  /**< Rectification configuration register(\a RECTCFG)*/
  };

  uint8_t delay;
  uint8_t half_cycle;

} XMC_DSD_CH_RECTIFY_CONFIG_t;


/*Anonymous structure/union guard end*/
#if defined(__CC_ARM)
  #pragma pop
#elif defined(__TASKING__)
  #pragma warning restore
#endif

/**
 *  DSD Enable Channel
 */
typedef struct XMC_DSD_CONFIG
{
  XMC_DSD_CH_FILTER_CONFIG_t     *const filter;      /**< Pointer to the filter configuration */
  XMC_DSD_CH_INTEGRATOR_CONFIG_t *const integrator;  /**< Pointer to the integrator configuration*/
  XMC_DSD_CH_TIMESTAMP_CONFIG_t  *const timestamp;   /**< Pointer to the time stamp configuration*/
  XMC_DSD_CH_AUX_FILTER_CONFIG_t *const aux;         /**< Pointer to the aux_filter configuration*/
  XMC_DSD_CH_RECTIFY_CONFIG_t    *const rectify;     /**< Pointer to the rectify configuration*/
} XMC_DSD_CH_CONFIG_t;


/**********************************************************************************************************************
 * API PROTOTYPES
 *********************************************************************************************************************/
#ifdef __cplusplus
extern "C" {
#endif

/**
 * @param  dsd  Pointer to an instance of DSD module of type @ref XMC_DSD_t
 * @return None
 *
 * \par<b>Description</b><br>
 * De-asserts the DSD module from reset.\n
 * Configures \a PRCLR0 register's \a DSDRS bit field.
 * If running on XMC44/XMC48 device then it will ungate the peripheral clock.
 *
 * \par<b>Note</b><br>
 * It is internally called by XMC_DSD_Init().
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_Disable(),XMC_DSD_Init() \n\n\n
 */
void XMC_DSD_Enable(XMC_DSD_t *const dsd);

/**
 * @param  dsd  Pointer to an instance of DSD module of type @ref XMC_DSD_t
 * @return None
 *
 * \par<b>Description</b><br>
 * Asserts the DSD module into reset.\n
 * Configures \a PRSET0 register's \a DSDRS bit field.
 * If running on XMC44/XMC48 device then it will gate the peripheral clock.
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_Enable()\n\n\n
 */
void XMC_DSD_Disable(XMC_DSD_t *const dsd);
/**
 * @param  dsd  Pointer to an instance of DSD module of type @ref XMC_DSD_t
 * @return None
 *
 * \par<b>Description</b><br>
 * Enable the module clock and internal module clock for DSD.\n
 * Configures bit field \a MCSEL of register \a GLOBCFG and  bit field \a DISR of register \a CLC.
 *
 * \par<b>Note</b><br>
 * It is internally called by XMC_DSD_Init().
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_DisableClock(),XMC_DSD_Init() \n\n\n
 */
void XMC_DSD_EnableClock(XMC_DSD_t *const dsd);
/**
 * @param  dsd  Pointer to an instance of DSD module of type @ref XMC_DSD_t
 * @return None
 *
 * \par<b>Description</b><br>
 * Stop the module clock and disable internal module clock for DSD.\n
 * Configures bit field \a MCSEL of register \a GLOBCFG and  bit field \a DISR of register \a CLC.
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_DisableClock()\n\n\n
 */
void XMC_DSD_DisableClock(XMC_DSD_t *const dsd);
/**
 * @param  dsd  Pointer to an instance of DSD module of type @ref XMC_DSD_t
 * @return bool Return 1 if success else 0.
 *
 * \par<b>Description</b><br>
 * Find out if the DSD reset is asserted.\n
 * Read \a PRSTAT0 register's \a DSDRS bit field.\n\n\n
 */
bool XMC_DSD_IsEnabled(XMC_DSD_t *const dsd);

/**
 * @param  dsd  Pointer to an instance of DSD module of type @ref XMC_DSD_t
 * @return None
 *
 * \par<b>Description</b><br>
 * Enable the DSD module and clock.\n
 *
 * \par<b>Note</b><br>
 * This is the first API which application must invoke to configure DSD.
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_Enable(),XMC_DSD_EnableClock()\n\n\n
 */
void XMC_DSD_Init(XMC_DSD_t *const dsd);
/**
 * @param  channel  Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t
 * @param  init     Pointer to an instance of data structure of type @ref XMC_DSD_CH_TIMESTAMP_CONFIG_t
 * @return None
 *
 * \par<b>Description</b><br>
 * Initialize timestamp mode of DSD module with \a init.\n
 * Configures bits \a TRSEL and \a TSTRMODE of  register \a DICFG .
 *
 * \par<b>Note</b><br>
 * Trigger source for timestamp and integrator are shared.
 * It is internally called by XMC_DSD_CH_Init().
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_CH_Init()\n\n\n
*/
void XMC_DSD_CH_Timestamp_Init(XMC_DSD_CH_t *const channel, const XMC_DSD_CH_TIMESTAMP_CONFIG_t *const init);

/**
 * @param  channel  Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t
 * @param  init     Pointer to an instance of data structure of type @ref XMC_DSD_CH_CONFIG_t
 * @return XMC_DSD_STATUS_t if success Returns @ref XMC_DSD_STATUS_OK
 *                          else return @ref XMC_DSD_STATUS_ERROR.
 *
 * \par<b>Description</b><br>
 * Initialize main filter,auxiliary filter,integrator, rectifier and timestamp of DSD module with \a init.\n
 * Internally this API invoke main filter, auxiliary filter, integrator, rectifier and timestamp init API.
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_CH_MainFilter_Init(),XMC_DSD_CH_AuxFilter_Init(),XMC_DSD_CH_Integrator_Init(),
 * XMC_DSD_CH_Rectify_Init(),XMC_DSD_CH_Timestamp_Init()\n\n\n
*/
XMC_DSD_STATUS_t XMC_DSD_CH_Init(XMC_DSD_CH_t *const channel, const XMC_DSD_CH_CONFIG_t *const init);

/**
 * @param  dsd      Pointer to an instance of DSD module of type @ref XMC_DSD_t
 * @param  channel  Channel run control bit register value
 * @return None
 *
 * \par<b>Description</b><br>
 * Start demodulator channel by enabling run control bit.
 * Multiple channel can be start at a time.
 * For an example: To start all four channel, call this function as
 * XMC_DSD_Start(DSD,(uint32_t)(XMC_DSD_CH_ID_0|XMC_DSD_CH_ID_1|XMC_DSD_CH_ID_2|XMC_DSD_CH_ID_3));
 *
 * \par<b>Note</b><br>
 * All filter blocks are cleared when CHxRUN is set.
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_Stop(),XMC_DSD_IsChannelStarted()\n\n\n
 */
__STATIC_INLINE void XMC_DSD_Start(XMC_DSD_t *const dsd, const uint32_t channel)
{
  XMC_ASSERT("XMC_DSD_Start:Invalid module pointer", XMC_DSD_CHECK_MODULE_PTR(dsd));
  dsd->GLOBRC |= channel;
}

/**
 * @param  dsd      Pointer to an instance of DSD module of type @ref XMC_DSD_t\n
 * @param  channel  Channel run control bit register value\n
 * @return None\n
 *
 * \par<b>Description</b><br>
 * Stop demodulator channel by resetting run control bit.
 * Multiple channel can be stop at a time.
 * For an example: To stop all four channel, call this function as
 * XMC_DSD_Stop(DSD,(uint32_t)(XMC_DSD_CH_ID_0|XMC_DSD_CH_ID_1|XMC_DSD_CH_ID_2|XMC_DSD_CH_ID_3));
 *
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_Start(),XMC_DSD_IsChannelStarted()\n\n\n
 */
__STATIC_INLINE void XMC_DSD_Stop(XMC_DSD_t *const dsd, const uint32_t channel)
{
  XMC_ASSERT("XMC_DSD_Stop:Invalid module pointer", XMC_DSD_CHECK_MODULE_PTR(dsd));
  dsd->GLOBRC &= (uint32_t) ~channel;
}

/**
 * @param  dsd     Pointer to an instance of DSD module of type @ref XMC_DSD_t\n
 * @param  channel Channel run control bit register value of type @ref XMC_DSD_CH_ID_t\n
 * @return bool    Return 1 if started else 0.\n
 *
 * \par<b>Description</b><br>
 * Find out if particular demodulator channel is started or not.\n
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_Start(),XMC_DSD_Stop()\n\n\n
 */
__STATIC_INLINE bool XMC_DSD_IsChannelStarted(XMC_DSD_t *const dsd, const XMC_DSD_CH_ID_t channel)
{
  bool status;
  XMC_ASSERT("XMC_DSD_IsChannelStarted:Invalid module pointer", XMC_DSD_CHECK_MODULE_PTR(dsd));
  if (dsd->GLOBRC & (uint32_t)channel)
  {
    status = true;
  }
  else
  {
    status = false;
  }
  return (status);
}

/**
 * @param  channel Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t
 * @param  dsd_Result pointer point to the address of 16 bit variable
 * @return None
 *
 * \par<b>Description:</b><br>
 *  Returns the result of most recent conversion associated with this channel.\n
 *  A call to this API would access the register bit field \a RESMx.RESULT (x = 0 - 3).
 *
 * \par<b>Related APIs:</b><br>
 * XMC_DSD_CH_GetResult_TS()\n\n\n
 */
__STATIC_INLINE void XMC_DSD_CH_GetResult(XMC_DSD_CH_t *const channel, int16_t* dsd_Result) 
{
  uint16_t result;
  result = (uint16_t)((uint32_t)channel->RESM & DSD_CH_RESM_RESULT_Msk);
  *dsd_Result = (int16_t)result;
}

/**
 * @param  channel              Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t\n
 * @param  dsd_Result           pointer point to the address of 16 bit variable holds result value\n
 * @param  dsd_filter_loop      pointer point to the address of 8 bit variable holds decimation counter value\n
 * @param  dsd_integration_loop pointer point to the address of 8 bit integration counter variable holds value\n
 * @return None\n
 *
 * \par<b>Description:</b><br>
 *  API to get the result of the last conversion associated with this channel with
 *  CIC filter decimation counter and number of values counted.\n
 *  A call to this API would access the register bit field \a TSTMPx.RESULT \a TSTMPx.CFMDCNT and \a TSTMPx.NVALCNT where (x = 0 - 3).
 *
 * \par<b>Related APIs:</b><br>
 * XMC_DSD_CH_GetResult(),XMC_DSD_CH_GetResult_TS_Time()\n\n\n
 */
void XMC_DSD_CH_GetResult_TS(
                             XMC_DSD_CH_t *const channel,
                             int16_t* dsd_Result,
                             uint8_t* dsd_filter_loop,
                             uint8_t* dsd_integration_loop);

/**
 * @param  channel    Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t\n
 * @param  dsd_Result pointer point to the address of 16 bit variable holds result value\n
 * @param  time       pointer point to the address of 32 bit variable holds the time\n
 * @return None
 *
 * \par<b>Description:</b><br>
 *  API to get the result of the last conversion with the time, associated with this channel.\n
 *
 * \par<b>Related APIs:</b><br>
 * XMC_DSD_CH_GetResult(),XMC_DSD_CH_GetResult_TS()\n\n\n
 */
void XMC_DSD_CH_GetResult_TS_Time(XMC_DSD_CH_t *const channel, int16_t* dsd_Result, uint32_t* time);

/**
 * @param  channel Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t
 * @param  dsd_Result pointer point to the address of 16 bit variable
 * @return None
 *
 * \par<b>Description:</b><br>
 *  Returns the most recent conversion result values of the auxiliary filter associated with this channel.\n
 *  A call to this API would access the register bit field \a RESAx.RESULT (x = 0 - 3).
 *
 * \par<b>Related APIs:</b><br>
 * XMC_DSD_CH_GetResult_TS()\n\n\n
 */
__STATIC_INLINE void XMC_DSD_CH_GetResult_AUX(XMC_DSD_CH_t *const channel, int16_t* dsd_Result)
{
  uint16_t result;
  result = (uint16_t) (channel->RESA & DSD_CH_RESA_RESULT_Msk);
  *dsd_Result = (int16_t) (result);
}

/**
 * @param  dsd  Pointer to an instance of DSD module of type @ref XMC_DSD_t
 * @param  init Pointer to an instance of data structure of type @ref XMC_DSD_GENERATOR_CONFIG_t
 * @return None
 *
 * \par<b>Description</b><br>
 * This API initialize generator module with \a init, to generate a wave for a resolver.
 * Three types of waveforms can be generated: Rectangle, Triangle and Sine.
 *
*/
void XMC_DSD_Generator_Init(XMC_DSD_t *const dsd, const XMC_DSD_GENERATOR_CONFIG_t *const init);

/**
 * @param  dsd     Pointer to an instance of DSD module of type @ref XMC_DSD_t
 * @param  config  Pointer to an instance of data structure of type @ref XMC_DSD_GENERATOR_CONFIG_t
 * @return None
 *
 * \par<b>Description</b><br>
 * Start carrier generator by configuring operating mode.
 * Configures bit field \a CGMOD of register \a CGCFG.
 *
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_Generator_Stop()\n\n\n
 */
__STATIC_INLINE void XMC_DSD_Generator_Start(XMC_DSD_t *const dsd, const XMC_DSD_GENERATOR_CONFIG_t *const config)
{
  XMC_ASSERT("XMC_DSD_Generator_Start:Invalid module pointer", XMC_DSD_CHECK_MODULE_PTR(dsd));
  XMC_ASSERT("XMC_DSD_Generator_Start:NULL Pointer", (config != (XMC_DSD_GENERATOR_CONFIG_t *)NULL) );
  dsd->CGCFG |= config->mode;
}

/**
 * @param  dsd     Pointer to an instance of DSD module of type @ref XMC_DSD_t
 * @return None
 *
 * \par<b>Description</b><br>
 * Stop carrier generator by configuring operating mode.
 * Reset bit field \a CGMOD of register \a CGCFG.
 *
 * \par<b>Note</b><br>
 * Stopping the carrier generator terminates the PWM output after completion of the current period.
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_Generator_Start()\n\n\n
 */
__STATIC_INLINE void XMC_DSD_Generator_Stop(XMC_DSD_t *const dsd)
{
  XMC_ASSERT("XMC_DSD_Generator_Stop:Invalid module pointer", XMC_DSD_CHECK_MODULE_PTR(dsd));
  dsd->CGCFG &= ~((uint32_t)DSD_CGCFG_CGMOD_Msk);
}

/**
 * @param  channel  Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t
 * @param  init     Pointer to an instance of data structure of type @ref XMC_DSD_CH_FILTER_CONFIG_t
 * @return None
 *
 * \par<b>Description</b><br>
 * This API initialize main filter module with \a init.
 * The filter demodulates the incoming bit stream from the delta sigma modulator to a 16 bit result.
 *
 *
 * \par<b>Note</b><br>
 * It is internally called by XMC_DSD_CH_Init().
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_CH_Init()\n\n\n
*/
void XMC_DSD_CH_MainFilter_Init(XMC_DSD_CH_t *const channel, const XMC_DSD_CH_FILTER_CONFIG_t *const init);

/**
 * @param  channel  Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t
 * @param  offset   Signed Offset value to be set
 * @return None
 *
 * \par<b>Description</b><br>
 * API set the signed offset value for this channel.
 * This offset value is subtracted from each result before being written to the corresponding result register \a RESMx.
 *
 * \par<b>Note</b><br>
 * The offset value is measured for each channel separately.
 *
*/
__STATIC_INLINE void XMC_DSD_CH_MainFilter_SetOffset(XMC_DSD_CH_t *const channel, const int16_t offset)
{
  XMC_ASSERT("XMC_DSD_CH_MainFilter_SetOffset:Invalid module pointer", XMC_DSD_CHECK_CHANNEL_PTR(channel));
  channel->OFFM = (uint32_t)offset;
}

/**
 * @param  channel  Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t
 * @return None
 *
 * \par<b>Description</b><br>
 * This API enable the service request generation for result of this channel.
 * Result events are generated at the output rate of the configured main filter chain.
 * Configure bit field \a SRGM of register \a FCFGC
 *
*/
__STATIC_INLINE void XMC_DSD_CH_MainFilter_EnableEvent(XMC_DSD_CH_t *const channel)
{
  XMC_ASSERT("XMC_DSD_CH_MainFilter_EnableEvent:Invalid module pointer", XMC_DSD_CHECK_CHANNEL_PTR(channel));
  channel->FCFGC |= (uint32_t)DSD_CH_FCFGC_SRGM_Msk;
}

/**
 * @param  channel  Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t
 * @return None
 *
 * \par<b>Description</b><br>
 * This API disable the service request generation for result of this channel.
 * Configure bit field \a SRGM of register \a FCFGC
 *
*/
__STATIC_INLINE void XMC_DSD_CH_MainFilter_DisableEvent(XMC_DSD_CH_t *const channel)
{
  XMC_ASSERT("XMC_DSD_CH_MainFilter_DisableEvent:Invalid module pointer", XMC_DSD_CHECK_CHANNEL_PTR(channel));
  channel->FCFGC &= ~((uint32_t)DSD_CH_FCFGC_SRGM_Msk);
}

/**
 * @param  channel  Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t
 * @param  init     Pointer to an instance of data structure of type @ref XMC_DSD_CH_AUX_FILTER_CONFIG_t
 * @return None
 *
 * \par<b>Description</b><br>
 * This API initialize auxiliary filter module with \a init. The auxiliary Filter is mainly used as fast filter.\n
 * Adding the auxiliary filter to the system structure helps by defining the boundaries and filter configurations.\n
 *
 *
 * \par<b>Note</b><br>
 * It is internally called by XMC_DSD_CH_Init().\n
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_CH_Init()\n\n\n
*/
void XMC_DSD_CH_AuxFilter_Init(XMC_DSD_CH_t *const channel, const XMC_DSD_CH_AUX_FILTER_CONFIG_t *const init);

/**
 * @param  channel          Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t
 * @param  lower_boundary   lower boundary value for limit checking
 * @param  upper_boundary   upper boundary value for limit checking
 * @return None
 *
 * \par<b>Description</b><br>
 * Invoke this API, to set the lower and upper boundary for limit checking for this channel.
 * This (two’s complement) value is compared to the results of the parallel filter.
 * Configure bit fields \a BOUNDARYU and \a BOUNDARYL of register \a BOUNDSEL.
 *
 * \par<b>Note</b><br>
 * Lower and upper boundaries are internally configured by function XMC_DSD_CH_AuxFilter_Init().
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_CH_AuxFilter_Init()\n\n\n
*/
__STATIC_INLINE void XMC_DSD_CH_AuxFilter_SetBoundary(
                                                   XMC_DSD_CH_t *const channel,
                                                   const int16_t lower_boundary,
                                                   const int16_t upper_boundary)
{
  XMC_ASSERT("XMC_DSD_CH_AuxFilter_SetBoundary:Invalid module pointer", XMC_DSD_CHECK_CHANNEL_PTR(channel));
  channel->BOUNDSEL = (((uint32_t)upper_boundary << (uint32_t)DSD_CH_BOUNDSEL_BOUNDARYU_Pos)
                      | ((uint32_t)lower_boundary & (uint32_t)DSD_CH_BOUNDSEL_BOUNDARYL_Msk));
}

/**
 * @param  channel  Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t
 * @param  event to select the type of event which will be enabled of type @ref XMC_DSD_CH_AUX_EVENT_t
 * @return None
 *
 * \par<b>Description</b><br>
 * This API enable the service request generation for this channel.
 * Result events are generated at the output rate of the configured auxiliary filter chain.
 * Configure bit field \a SRGA and ESEL of register \a FCFGA
 *
*/
__STATIC_INLINE void XMC_DSD_CH_AuxFilter_EnableEvent(XMC_DSD_CH_t *const channel, XMC_DSD_CH_AUX_EVENT_t event)
{
  XMC_ASSERT("XMC_DSD_CH_AuxFilter_EnableEvent:Invalid module pointer", XMC_DSD_CHECK_CHANNEL_PTR(channel));
  channel->FCFGA &= ~((uint32_t)DSD_CH_FCFGA_ESEL_Msk|(uint32_t)DSD_CH_FCFGA_SRGA_Msk);
  channel->FCFGA |= ((uint32_t)event << DSD_CH_FCFGA_SRGA_Pos);
}

/**
 * @param  channel  Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t
 * @return None
 *
 * \par<b>Description</b><br>
 * This API disable the auxiliary filter service request generation for this channel.
 * Clear the bit fields \a SRGA and ESEL of register \a FCFGA.
 *
*/
__STATIC_INLINE void XMC_DSD_CH_AuxFilter_DisableEvent(XMC_DSD_CH_t *const channel)
{
  XMC_ASSERT("XMC_DSD_CH_AuxFilter_DisableEvent:Invalid module pointer", XMC_DSD_CHECK_CHANNEL_PTR(channel));
  channel->FCFGA &= ~((uint32_t)DSD_CH_FCFGA_ESEL_Msk|(uint32_t)DSD_CH_FCFGA_SRGA_Msk);
}

/**
 * @param  channel  Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t
 * @param  init     Pointer to an instance of data structure of type @ref XMC_DSD_CH_INTEGRATOR_CONFIG_t
 * @return None
 *
 * \par<b>Description</b><br>
 * Initialize integrator of DSD module.The integrator is mainly used for resolver feedback but can also be used for high accurate measurement.
 * This API configures number of integration loops, number of results are discarded before integration starts, integrator stop condition,
 * number of integrator loop to get integration result and trigger mode.
 *
 * \par<b>Note</b><br>
 * Trigger source for timestamp and integrator are shared.
 * It is internally called by XMC_DSD_CH_Init().
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_CH_Init()\n\n\n
*/
void XMC_DSD_CH_Integrator_Init(XMC_DSD_CH_t *const channel, const XMC_DSD_CH_INTEGRATOR_CONFIG_t *const init);
/**
 * @param  channel  Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t
 * @param  init     Pointer to an instance of data structure of type @ref XMC_DSD_CH_RECTIFY_CONFIG_t
 * @return None
 *
 * \par<b>Description</b><br>
 * Initialize rectification for this channel.
 * In a resolver feedback system, rectifier is used to rectify the result from the integrator.
 * Configure bit field \a RFEN and \a SSRC of register \a RECTCFG. Also configure sign delay
 * value for positive halfwave(\a SDPOS) and negative halfwave(\a SDNEG).
 * \par<b>Note</b><br>
 * For the operational capability of rectifier the filter and the integrator is mandatory.
 * It is internally called by XMC_DSD_CH_Init().
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_CH_Init()\n\n\n
*/
void XMC_DSD_CH_Rectify_Init(XMC_DSD_CH_t *const channel, const XMC_DSD_CH_RECTIFY_CONFIG_t *const init);

/**
 * @param  channel  Pointer to an instance of DSD channel of type @ref XMC_DSD_CH_t
 * @param  delay    Captured value
 * @return uint8_t
 *
 * \par<b>Description</b><br>
 * This API, capture sign delay value for DSD channel.
 * Captured value indicates the values counted between the begin of the positive
 * halfwave of the carrier signal and the first received positive value.
 * Read bit field \a SDCAP of register \a CGSYNC
 *
*/
__STATIC_INLINE void XMC_DSD_CH_GetRectifyDelay(XMC_DSD_CH_t *const channel, uint8_t* delay)
{
  XMC_ASSERT("XMC_DSD_CH_GetRectifyDelay:Invalid module pointer", XMC_DSD_CHECK_CHANNEL_PTR(channel));
  *delay = (uint8_t)((channel->CGSYNC & DSD_CH_CGSYNC_SDCAP_Msk ) >> DSD_CH_CGSYNC_SDCAP_Pos);
}
/**
 * @param  dsd  Pointer to an instance of DSD module of type @ref XMC_DSD_t
 * @param  channel_id   Channel number register value of type @ref XMC_DSD_CH_ID_t
 * @return None
 *
 * \par<b>Description</b><br>
 * Set the result event flag and trigger the corresponding event.\n
 * Set bit fields \a RESEVx of register \a EVFLAG.Clearing these bits has no effect.
 *
 * \par<b>Note</b><br>
 * API call for channel-0  : XMC_DSD_SetResultEventFlag(DSD,(uint32_t)XMC_DSD_CH_ID_0);
 * API call for channel-0 and 1: XMC_DSD_SetResultEventFlag(DSD,(uint32_t)(XMC_DSD_CH_ID_0|XMC_DSD_CH_ID_1));
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_ClearResultEventFlag()\n\n\n
 */
__STATIC_INLINE void XMC_DSD_SetResultEventFlag(XMC_DSD_t *const dsd, const uint32_t channel_id)
{
  XMC_ASSERT("XMC_DSD_SetResultEventFlag:Invalid module pointer", XMC_DSD_CHECK_MODULE_PTR(dsd));
  dsd->EVFLAG = channel_id;
}
/**
 * @param  dsd  Pointer to an instance of DSD module of type @ref XMC_DSD_t
 * @param  channel_id   Channel number register value of type @ref XMC_DSD_CH_ID_t
 * @return None
 *
 * \par<b>Description</b><br>
 * Clear the result event flag.\n
 * Set bit fields \a RESECx of register \a EVFLAGCLR.Clearing these bits has no effect.
 *
 * \par<b>Note</b><br>
 * API call for channel-0      : XMC_DSD_ClearResultEventFlag(DSD,(uint32_t)XMC_DSD_CH_ID_0);
 * API call for channel-0 and 1: XMC_DSD_ClearResultEventFlag(DSD,(uint32_t)(XMC_DSD_CH_ID_0|XMC_DSD_CH_ID_1));
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_SetResultEventFlag()\n\n\n
 */
__STATIC_INLINE void XMC_DSD_ClearResultEventFlag(XMC_DSD_t *const dsd, const uint32_t channel_id)
{
  XMC_ASSERT("XMC_DSD_ClearResultEventFlag:Invalid module pointer", XMC_DSD_CHECK_MODULE_PTR(dsd));
  dsd->EVFLAGCLR = channel_id;
}
/**
 * @param  dsd  Pointer to an instance of DSD module of type @ref XMC_DSD_t
 * @param  channel_id   Channel number register value of type @ref XMC_DSD_CH_ID_t
 * @return None
 *
 * \par<b>Description</b><br>
 * Set the alarm event flag.\n
 * Set bit fields \a ALEVx of register \a EVFLAG.Clearing these bits has no effect.
 *
 * \par<b>Note</b><br>
 * API call for channel-0  : XMC_DSD_SetAlarmEventFlag(DSD,(uint32_t)XMC_DSD_CH_ID_0);
 * API call for channel-0 and 1: XMC_DSD_SetAlarmEventFlag(DSD,(uint32_t)(XMC_DSD_CH_ID_0|XMC_DSD_CH_ID_1));
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_ClearAlarmEventFlag()\n\n\n
 */
__STATIC_INLINE void XMC_DSD_SetAlarmEventFlag(XMC_DSD_t *const dsd, const uint32_t channel_id)
{
  XMC_ASSERT("XMC_DSD_SetAlarmEventFlag:Invalid module pointer", XMC_DSD_CHECK_MODULE_PTR(dsd));
  dsd->EVFLAG = (channel_id<< DSD_EVFLAGCLR_ALEC0_Pos);
}
/**
 * @param  dsd  Pointer to an instance of DSD module of type @ref XMC_DSD_t
 * @param  channel_id   Channel number register value of type @ref XMC_DSD_CH_ID_t
 * @return None
 *
 * \par<b>Description</b><br>
 * Clear the result event flag.\n
 * Set bit fields \a ALECx of register \a EVFLAGCLR.Clearing these bits has no effect.
 *
 * \par<b>Note</b><br>
 * API call for channel-0      : XMC_DSD_ClearResultEventFlag(DSD,(uint32_t)XMC_DSD_CH_ID_0);
 * API call for channel-0 and 1: XMC_DSD_ClearResultEventFlag(DSD,(uint32_t)(XMC_DSD_CH_ID_0|XMC_DSD_CH_ID_1));
 *
 * \par<b>Related APIs:</b><BR>
 * XMC_DSD_SetAlarmEventFlag()\n\n\n
 */
__STATIC_INLINE void XMC_DSD_ClearAlarmEventFlag(XMC_DSD_t *const dsd, const uint32_t channel_id)
{
  XMC_ASSERT("XMC_DSD_ClearAlarmEventFlag:Invalid module pointer", XMC_DSD_CHECK_MODULE_PTR(dsd));
  dsd->EVFLAGCLR = (channel_id<<DSD_EVFLAGCLR_ALEC0_Pos);
}
#ifdef __cplusplus
}
#endif

/**
 * @}
 */

/**
 * @}
 */


#endif /* DSD_PRESENT */
#endif /*XMC_DSD_H */