g32r4xx_ddl_comp.c

Go to the documentation of this file.

#if defined(USE_FULL_DDL_DRIVER)
 
/* Includes ------------------------------------------------------------------*/
#include "g32r4xx_ddl_comp.h"
#include "g32r4xx_ddl_rcm.h"
 
#ifdef  USE_FULL_ASSERT
#include "g32_assert.h"
#else
#define ASSERT_PARAM(_PARAM_) ((void)0U)
#endif /* USE_FULL_ASSERT */

 
#if defined (COMP1) || defined (COMP2) || defined (COMP3) || defined (COMP4)

 
/* Private types -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private constants ---------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/

 
 /* Check of parameters for configuration of COMP hierarchical scope:          */
    /* COMP instance.                                                             */
#define IS_DDL_COMP_INPUT_PLUS(__COMP_INSTANCE__, __INPUT_PLUS__)     \
    (   ((__COMP_INSTANCE__) < COMP4) ?                                   \
    (   ((__INPUT_PLUS__) == DDL_COMP_INPUT_PLUS_INP0) ||                               \
        ((__INPUT_PLUS__) == DDL_COMP_INPUT_PLUS_DAC1))                                   \
    :                                                                                   \
    (   ((__INPUT_PLUS__) == DDL_COMP_INPUT_PLUS_INP0) ||                               \
        ((__INPUT_PLUS__) == DDL_COMP_INPUT_PLUS_INP1) ||                               \
        ((__INPUT_PLUS__) == DDL_COMP_INPUT_PLUS_DAC1))                                   \
)
 
#define IS_DDL_COMP_INPUT_MINUS(__COMP_INSTANCE__, __INPUT_MINUS__)   \
(   ((__COMP_INSTANCE__) < COMP4) ?                                   \
    (   ((__INPUT_MINUS__) == DDL_COMP_INPUT_MINUS_INN0) ||                              \
        ((__INPUT_MINUS__) == DDL_COMP_INPUT_MINUS_DAC1) )                                \
    :                                                                               \
    (   ((__INPUT_MINUS__) == DDL_COMP_INPUT_MINUS_INN0) ||                              \
        ((__INPUT_MINUS__) == DDL_COMP_INPUT_MINUS_INN1) ||                              \
        ((__INPUT_MINUS__) == DDL_COMP_INPUT_MINUS_DAC1) )                                \
)
 
#define IS_DDL_COMP_OUTPUT_POLARITY(__POLARITY__)               \
    (   ((__POLARITY__) == DDL_COMP_OUTPUTPOL_NONINVERTED) ||   \
        ((__POLARITY__) == DDL_COMP_OUTPUTPOL_INVERTED)         \
    )
 
#define IS_DDL_COMP_OUTPUT_BLANK(__BLANK__)     \
    (   ((__BLANK__) == DDL_COMP_BLANK_0) ||    \
        ((__BLANK__) == DDL_COMP_BLANK_1) ||    \
        ((__BLANK__) == DDL_COMP_BLANK_2) ||    \
        ((__BLANK__) == DDL_COMP_BLANK_3) ||    \
        ((__BLANK__) == DDL_COMP_BLANK_4) ||    \
        ((__BLANK__) == DDL_COMP_BLANK_6) ||    \
        ((__BLANK__) == DDL_COMP_BLANK_7)       \
    )

 
/* Private function prototypes -----------------------------------------------*/
 
/* Exported functions --------------------------------------------------------*/


ErrorStatus DDL_COMP_Init(COMP_TypeDef *COMPx, DDL_COMP_InitTypeDef *COMP_InitStruct)
{
    ErrorStatus status = SUCCESS;
 
    /* Check parameters */
    ASSERT_PARAM(IS_COMP_ALL_INSTANCE(COMPx));
    ASSERT_PARAM(IS_DDL_COMP_INPUT_PLUS(COMPx, COMP_InitStruct->InputPlus));
    ASSERT_PARAM(IS_DDL_COMP_INPUT_MINUS(COMPx, COMP_InitStruct->InputMinus));
    ASSERT_PARAM(IS_DDL_COMP_OUTPUT_POLARITY(COMP_InitStruct->OutputPol));
    ASSERT_PARAM(IS_DDL_COMP_OUTPUT_BLANK(COMP_InitStruct->OutputBlank));
 
    /* COMP instance must not be locked */
    if (DDL_COMP_IsLocked(COMPx) == 0UL)
    {
        /* Configuration of comparator instance */
        MODIFY_REG(COMPx->CxCSR,
                    COMP_CSTS_VP_SEL |
                    COMP_CSTS_VN_SEL |
                    COMP_CSTS_BLANKSEL |
                    COMP_CSTS_POL,
                    COMP_InitStruct->InputPlus |
                    COMP_InitStruct->InputMinus |
                    COMP_InitStruct->OutputBlank |
                    COMP_InitStruct->OutputPol
        );
    }
    else
    {
        status = ERROR;
    }
 
    return status;
}

ErrorStatus DDL_COMP_DeInit(COMP_TypeDef *COMPx)
{
    ErrorStatus status = SUCCESS;
 
    /* Check parameters */
    ASSERT_PARAM(IS_COMP_ALL_INSTANCE(COMPx));
 
    /* COMP instance must not be locked */
    if (DDL_COMP_IsLocked(COMPx) == 0UL)
    {
        /* De-initialize the COMP registers to the reset values */
        DDL_COMP_WriteReg((COMPx), CxCSR, 0x00000000UL);
    }
    else
    {
        /* COMP instance is locked */
        /* The only way to unlock the COMP instance is to perform a system reset */
        status = ERROR;
    }
 
    return status;
}

void DDL_COMP_StructInit(DDL_COMP_InitTypeDef *COMP_InitStruct)
{
    /* Set COMP_InitStruct fields to default values */
    COMP_InitStruct->InputPlus      = DDL_COMP_INPUT_PLUS_INP0;
    COMP_InitStruct->InputMinus     = DDL_COMP_INPUT_MINUS_INN0;
    COMP_InitStruct->OutputPol      = DDL_COMP_OUTPUTPOL_NONINVERTED;
    COMP_InitStruct->OutputBlank    = DDL_COMP_BLANK_0;
}



 
#endif /* COMP1 || COMP2 */

 
#endif /* USE_FULL_DDL_DRIVER */