hw_gpadc.h

Go to the documentation of this file.

 
#ifndef HW_GPADC_H
#define HW_GPADC_H
 
 
#if dg_configUSE_HW_GPADC
 
#include <stdbool.h>
#include <stdint.h>
#include "sdk_defs.h"
 
/***************************************************************************
 *********    Macro, type and data-structure definitions     ***************
 ***************************************************************************/
 
typedef void * HW_GPADC_ID;
 
typedef void (*hw_gpadc_interrupt_cb)(void);
 
typedef void (*hw_gpadc_read_cb)(void *user_data, uint32_t conv_to_go);
 
#define HW_GPADC_RESULT_NOB                     (16U)
 
#define HW_GPADC_DEFAULT_ENOB                   (10U)
 
#define HW_GPADC_UNUSED_BITS                    (HW_GPADC_RESULT_NOB - HW_GPADC_DEFAULT_ENOB)
 
#define HW_GPADC_MID_SCALE_ADC                  (1 << (HW_GPADC_RESULT_NOB - 1))
 
#define HW_GPADC_OFFSET_RESET                   0x200
 
#define HW_GPADC_DMA_SUPPORT                    dg_configGPADC_DMA_SUPPORT
 
typedef enum {
        HW_GPADC_INPUT_MODE_DIFFERENTIAL = 0,   
        HW_GPADC_INPUT_MODE_SINGLE_ENDED = 1    
} HW_GPADC_INPUT_MODE;
 
typedef enum {
        HW_GPADC_OVERSAMPLING_1_SAMPLE          = 0,    
        HW_GPADC_OVERSAMPLING_2_SAMPLES         = 1,    
        HW_GPADC_OVERSAMPLING_4_SAMPLES         = 2,    
        HW_GPADC_OVERSAMPLING_8_SAMPLES         = 3,    
        HW_GPADC_OVERSAMPLING_16_SAMPLES        = 4,    
        HW_GPADC_OVERSAMPLING_32_SAMPLES        = 5,    
        HW_GPADC_OVERSAMPLING_64_SAMPLES        = 6,    
        HW_GPADC_OVERSAMPLING_128_SAMPLES       = 7     
} HW_GPADC_OVERSAMPLING;
 
#if HW_GPADC_DMA_SUPPORT
#include "hw_dma.h"
 
typedef struct {
        HW_DMA_CHANNEL       channel;                   
        HW_DMA_PRIO          prio;                      
        bool                 circular;                  
        uint16               irq_nr_of_trans;           
} gpadc_dma_cfg;
#endif /* HW_GPADC_DMA_SUPPORT */
 
#include "hw_gpadc_v2.h"
 
/***************************************************************************
 ****************      GP_ADC configuration functions    *******************
 ***************************************************************************/
 
__STATIC_INLINE void hw_gpadc_set_continuous(bool enabled)
{
        REG_SETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_CONT, !!enabled);
}
 
__STATIC_INLINE bool hw_gpadc_get_continuous(void)
{
        return REG_GETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_CONT);
}
 
__STATIC_INLINE void hw_gpadc_set_input_mode(HW_GPADC_INPUT_MODE mode)
{
        REG_SETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_SE, mode);
}
 
__STATIC_INLINE HW_GPADC_INPUT_MODE hw_gpadc_get_input_mode(void)
{
        return (HW_GPADC_INPUT_MODE) REG_GETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_SE);
}
 
__STATIC_INLINE void hw_gpadc_set_oversampling(HW_GPADC_OVERSAMPLING n_samples)
{
        REG_SETF(GPADC, GP_ADC_CTRL2_REG, GP_ADC_CONV_NRS, n_samples);
}
 
__STATIC_INLINE HW_GPADC_OVERSAMPLING hw_gpadc_get_oversampling(void)
{
        return REG_GETF(GPADC, GP_ADC_CTRL2_REG, GP_ADC_CONV_NRS);
}
 
__STATIC_INLINE void hw_gpadc_set_mute(bool enabled)
{
        REG_SETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_MUTE, !!enabled);
}
 
__STATIC_INLINE bool hw_gpadc_get_mute(void)
{
        return REG_GETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_MUTE);
}
 
__STATIC_INLINE void hw_gpadc_set_sign_change(bool enabled)
{
        REG_SETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_SIGN, !!enabled);
}
 
__STATIC_INLINE bool hw_gpadc_get_sign_change(void)
{
        return REG_GETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_SIGN);
}
__STATIC_INLINE void hw_gpadc_set_chopping(bool enabled)
{
        REG_SETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_CHOP, !!enabled);
}
 
__STATIC_INLINE bool hw_gpadc_get_chopping(void)
{
        return REG_GETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_CHOP);
}
 
 
__STATIC_INLINE void hw_gpadc_set_mint(bool enabled)
{
        REG_SETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_MINT, !!enabled);
}
 
__STATIC_INLINE bool hw_gpadc_get_mint(void)
{
        return REG_GETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_MINT);
}
 
__STATIC_INLINE void hw_gpadc_set_ldo_constant_current(bool enabled)
{
        REG_SETF(GPADC, GP_ADC_CTRL2_REG, GP_ADC_I20U, !!enabled);
}
 
__STATIC_INLINE bool hw_gpadc_get_ldo_constant_current(void)
{
        return REG_GETF(GPADC, GP_ADC_CTRL2_REG, GP_ADC_I20U);
}
 
__STATIC_INLINE void hw_gpadc_set_interval(uint8_t mult)
{
        REG_SETF(GPADC, GP_ADC_CTRL3_REG, GP_ADC_INTERVAL, mult);
}
 
__STATIC_INLINE uint8_t hw_gpadc_get_interval(void)
{
        return REG_GETF(GPADC, GP_ADC_CTRL3_REG, GP_ADC_INTERVAL);
}
 
__STATIC_INLINE void hw_gpadc_set_dma_functionality(bool enabled)
{
        REG_SETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_DMA_EN, !!enabled);
}
 
__STATIC_INLINE bool hw_gpadc_get_dma_functionality(void)
{
        return REG_GETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_DMA_EN);
}
 
/***************************************************************************
 ****************      GP_ADC calibration functions      *******************
 ***************************************************************************/
 
__STATIC_INLINE void hw_gpadc_set_offset_positive(uint16_t offset)
{
        GPADC->GP_ADC_OFFP_REG = offset & REG_MSK(GPADC, GP_ADC_OFFP_REG, GP_ADC_OFFP);
}
 
__STATIC_INLINE uint16_t hw_gpadc_get_offset_positive(void)
{
        return GPADC->GP_ADC_OFFP_REG & REG_MSK(GPADC, GP_ADC_OFFP_REG, GP_ADC_OFFP);
}
 
__STATIC_INLINE void hw_gpadc_set_offset_negative(uint16_t offset)
{
        GPADC->GP_ADC_OFFN_REG = offset & REG_MSK(GPADC, GP_ADC_OFFN_REG, GP_ADC_OFFN);
}
 
 
__STATIC_INLINE uint16_t hw_gpadc_get_offset_negative(void)
{
        return GPADC->GP_ADC_OFFN_REG & REG_MSK(GPADC, GP_ADC_OFFN_REG, GP_ADC_OFFN);
}
 
void hw_gpadc_store_se_gain_error(int16_t single);
 
void hw_gpadc_store_diff_gain_error(int16_t diff);
 
void hw_gpadc_store_se_offset_error(int16_t single);
 
void hw_gpadc_store_diff_offset_error(int16_t diff);
 
__STATIC_INLINE int16_t hw_gpadc_calculate_single_ended_gain_error(int16_t low, int16_t high)
{
        return ((high - low + ((uint16_t)(high - low) >> 2 )) - UINT16_MAX);
}
 
__STATIC_INLINE int16_t hw_gpadc_calculate_single_ended_offset_error(int16_t low, int16_t high)
{
        return ((int16_t)((9 * low) - high) >> 3);
}
 
__STATIC_INLINE int16_t hw_gpadc_calculate_differential_gain_error(int16_t low, int16_t high)
{
        return (((high - low) + ((uint16_t)(high - low) >> 2)) - UINT16_MAX);
}
 
__STATIC_INLINE int16_t hw_gpadc_calculate_differential_offset_error(int16_t low, int16_t high)
{
        return (low + high) >> 1;
}
 
bool hw_gpadc_pre_check_for_gain_error(void);
 
int16_t hw_gpadc_get_single_ended_gain_error(void);
 
void hw_gpadc_offset_calibrate(void);
 
/***************************************************************************
 ****************    Basic functionality of the GPADC    *******************
 ***************************************************************************/
 
void hw_gpadc_init(const hw_gpadc_config_t *cfg, bool enable);
 
void hw_gpadc_configure(const hw_gpadc_config_t *cfg);
 
void hw_gpadc_register_interrupt(hw_gpadc_interrupt_cb cb);
 
void hw_gpadc_unregister_interrupt(void);
 
void hw_gpadc_unregister_interrupt_no_clear(void);
 
__STATIC_INLINE void hw_gpadc_clear_interrupt(void)
{
        GPADC->GP_ADC_CLEAR_INT_REG = 1;
}
 
__STATIC_INLINE void hw_gpadc_enable(void)
{
        REG_SET_BIT(GPADC, GP_ADC_CTRL_REG, GP_ADC_EN);
}
 
__STATIC_INLINE void hw_gpadc_disable(void)
{
        REG_CLR_BIT(GPADC, GP_ADC_CTRL_REG, GP_ADC_EN);
}
 
__STATIC_INLINE bool hw_gpadc_is_enabled(void)
{
        return REG_GETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_EN);
}
 
__STATIC_INLINE void hw_gpadc_start(void)
{
        REG_SETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_START, 1);
}
 
__STATIC_INLINE bool hw_gpadc_in_progress(void)
{
        return REG_GETF(GPADC, GP_ADC_CTRL_REG, GP_ADC_START);
}
 
__STATIC_INLINE uint16_t hw_gpadc_get_raw_value(void)
{
        return GPADC->GP_ADC_RESULT_REG;
}
 
uint16_t hw_gpadc_get_value(void);
 
__STATIC_INLINE void hw_gpadc_adc_measure(void)
{
        ASSERT_ERROR(hw_gpadc_get_continuous() == false);
        hw_gpadc_start();
        while (hw_gpadc_in_progress());
}
 
bool hw_gpadc_read(uint32_t nof_conv, uint16_t *out_buf, hw_gpadc_read_cb cb, void *user_data);
 
void hw_gpadc_abort_read(void);
 
uint16_t hw_gpadc_apply_correction(const hw_gpadc_config_t *cfg, uint16_t raw);
 
int16_t hw_gpadc_convert_to_millivolt(const hw_gpadc_config_t *cfg, uint16_t raw);
 
/***************************************************************************
 ******************    TEMPERATURE SENSOR declarations   *******************
 ***************************************************************************/
 
typedef struct {
        int16_t temp;   
        uint16_t adc;   
} hw_gpadc_calibration_point_t;
 
#endif /* dg_configUSE_HW_GPADC */
 
 
#endif /* HW_GPADC_H */