xc_drv_adc.c

浏览该文件的文档.

 
/*-----------------------------------------------------------------------------------
                                       INCLUDE HEADE FILES
 ------------------------------------------------------------------------------------*/
#include "xc6xxx.h"
 
/*------------------------------------------------------------------------------------
                                          Local Variables
 -------------------------------------------------------------------------------------*/
static uint16_t adc_value[2 * ADC_FIFO_DOUT_LEN] = {0};
static uint16_t adc_it_val;
 
/*------------------------------------------------------------------------------------
                                         Global Variables
 -------------------------------------------------------------------------------------*/
 
/*------------------------------------------------------------------------------------
                                         Func Prototype
 -------------------------------------------------------------------------------------*/
 
/*------------------------------------------------------------------------------------
                                            Functions
 -------------------------------------------------------------------------------------*/
 
void xc_adc_init(ADC_InitCfg_t *adc_cfg)
{
    cpr_rstctl_ctlapb_sw__gpadc_rstn__setf(RSTCTL_ENABLE);
    cpr_rstctl_ctlapb_sw__gpadc_rstn__setf(RSTCTL_DISABLE);
    cpr_ctlapbclken_grctl__gpadc_pclk_en__setf(ENABLE);
 
    cpr_opa_ctrl_reg__bg_5v_ctrl__setf(ENABLE);
 
    adc_main_ctl__adc_en__setf(ADC_MAIN_CTL_ADC_EN_DISABLE);
 
    xc_adc_fifo_flush();
 
    adc_timer0_set(ADC_TIMER);
 
    adc_main_ctl__edge_sel__setf(adc_cfg->SampEdge);
 
    xc_adc_freq_set(adc_cfg->Freq);
 
    xc_adc_refvol_set(adc_cfg->RefVol);
 
    adc_main_ctl__ext_edge_sel__setf(adc_cfg->ExtEdgeSel);
 
    adc_main_ctl__ext_sample_num__setf(adc_cfg->ExtSampleNum);
 
    adc_main_ctl__ext_trigger_sel__setf(adc_cfg->ExtTriggerSel);
 
    adc_main_ctl__ext_data_mode__setf(adc_cfg->ExtDataMode);
}
 
 
uint16_t xc_adc_data_average(uint16_t *data, uint16_t len)
{
    uint16_t add_cnt   = 0;
    uint32_t sum_data  = 0;
    uint8_t filter_cnt = 0;
 
    filter_cnt         = len / 4;
 
    for (int i = 0; i < len - 1; i++) {
        for (int j = 0; j < len - i - 1; j++) {
            if (data[j] > data[j + 1]) {
                uint16_t temp = data[j];
                data[j]       = data[j + 1];
                data[j + 1]   = temp;
            }
        }
    }
 
    for (int i = filter_cnt; i < len - filter_cnt; i++) {
        sum_data += data[i];
        add_cnt++;
    }
 
    if (0 == add_cnt)
        return 0xffff;
    else
        return sum_data / add_cnt;
}
 
 
 
 
void xc_adc_channel_gpio_config(ADC_ChannelTypeDef_t Channel)
{
    GPIO_InitCfg_t GPIO_InitCfg;
 
    GPIO_InitCfg.Mux    = GPIO_Mux0;
    GPIO_InitCfg.FunSel = GPIO_Dx;
    GPIO_InitCfg.Dir    = GPIO_DIR_INPUT;
    GPIO_InitCfg.Pull   = GPIO_NOPULL;
    GPIO_InitCfg.Int    = NOT_INT;
 
    switch (Channel) {
    case 0:
    case 1:
    case 2:
    case 3: {
        GPIO_InitCfg.Pin = GPIO_21 - Channel;
    } break;
 
    case 4: {
        GPIO_InitCfg.Pin = GPIO_0;
    } break;
 
    case 5: {
        GPIO_InitCfg.Pin = GPIO_1;
 
    } break;
 
    case 6: {
        GPIO_InitCfg.Pin = GPIO_4;
    } break;
 
    case 7: {
        GPIO_InitCfg.Pin = GPIO_5;
    } break;
 
    case 10: {
        GPIO_InitCfg.Pin = GPIO_2;
    } break;
 
    case 11: {
        GPIO_InitCfg.Pin = GPIO_3;
    } break;
 
    default:
        break;
    }
    xc_gpio_init(&GPIO_InitCfg);
}
 
 
 
void xc_adc_start_get_value(ADC_ChannelTypeDef_t Channel, uint16_t *adc_val)
{
    uint32_t val;
    ADC_FIFO_TypeDef_t *fifo_val = NULL;
    uint32_t time_out            = 100000;
    uint8_t adc_count            = 0;
 
    adc_main_ctl__adc_en__setf(ADC_MAIN_CTL_ADC_EN_DISABLE);
 
    adc_chan_ctl__select_chan__setf(Channel);
 
    adc_fifo_ctl__read_req_thresh__setf(ADC_FIFO_CTL_READ_REQ_THRESH_LEN_8);
 
    xc_adc_fifo_flush();
 
    adc_int_set(adc_int_get());
 
    adc_main_ctl__adc_en__setf(ADC_MAIN_CTL_ADC_EN_ENABLE);
 
    val = adc_int_raw_get();
 
    while (((val & ADC_INT_READ_REQ_INT_SET) != ADC_INT_READ_REQ_INT_SET) &&
           time_out) {
        __nop();
 
        val = adc_int_raw_get();
        time_out--;
    }
 
    if (time_out == 0) {
        DEBUG("adc time_out\n");
        return;
    }
 
    adc_main_ctl__adc_en__setf(ADC_MAIN_CTL_ADC_EN_DISABLE);
 
    fifo_val = (ADC_FIFO_TypeDef_t *)&val;
 
         for (int t = 0; t < ADC_FIFO_CTL_READ_REQ_THRESH_LEN_8; t++) {
        val = adc_fifo_get();
 
        if (fifo_val->chanel_1 != fifo_val->chanel_2) {
            DEBUG("channel error :%d\n", t);
            return;
        }
 
        if (fifo_val->chanel_1 != Channel) {
            DEBUG("channel error :%d\n", t);
            return;
        }
 
        adc_value[adc_count++] = fifo_val->value_1;
        adc_value[adc_count++] = fifo_val->value_2;
//        DEBUG("adc_value  :%d\n", fifo_val->value_1);
//        DEBUG("adc_value  :%d\n", fifo_val->value_2);
    }
 
    *adc_val = xc_adc_data_average(adc_value, adc_count);
}
 
 
 
void xc_adc_enable(void)
{         
    adc_main_ctl__adc_en__setf(ADC_MAIN_CTL_ADC_EN_ENABLE) ;
}
 
 
 
void xc_adc_disable(void)
{         
    adc_main_ctl__adc_en__setf(ADC_MAIN_CTL_ADC_EN_DISABLE) ;
}
 
 
 
 
void xc_adc_enable_it(uint8_t it)
{         
    adc_int_en_set(it) ;
}
 
void xc_adc_disable_it(uint8_t it)
{         
    adc_int_en_set(it) ;
}
 
 
 
 
void xc_adc_fifo_req_len_set(uint8_t len)
{
    adc_fifo_ctl__read_req_thresh__setf(len);
}
 
 
 
void xc_adc_wait_time_set(uint8_t timer0, uint16_t timer1)
{
    adc_timer1_set(timer1);
    adc_timer0_set(timer0);
}
 
 
 
void xc_adc_ch_auto_enable(void)
{
    adc_main_ctl__auto_sw__setf(ADC_MAIN_CTL_AUTO_SW_ENABLE);
}
 
 
 
void xc_adc_ch_auto_disable(void)
{
    adc_main_ctl__auto_sw__setf(ADC_MAIN_CTL_AUTO_SW_DISABLE);
}
 
 
 
void xc_adc_ch_auto_set(uint8_t ch)
{
    adc_chan_ctl__chan_auto__setf(ch);
}
 
 
 
void xc_adc_ch_not_auto_set(uint8_t ch)
{
    adc_chan_ctl__select_chan__setf(ch);
}
 
 
 
void xc_adc_it_set(uint8_t it)
{
    adc_int_set(it);
}
 
 
 
 
uint8_t xc_adc_it_get(void)
{
    return adc_int_get();
}
 
 
 
 
uint32_t xc_adc_data_get(void)
{
    return adc_fifo__fifo_dout__getf();
}
 
 
 
 
void xc_adc_it_collectval_set(uint16_t val) { adc_it_val = val; }
 
 
uint16_t xc_adc_it_collectval_get(void) { return adc_it_val; }
 
void GADC_Handler(void)
{
    adc_intr_callback();
    adc_int_set(adc_int_get());
}
 
__WEAK void adc_intr_callback(void)
{
    uint32_t adc_int;
    uint32_t val;
 
    uint8_t adc_count            = 0;
    ADC_FIFO_TypeDef_t *fifo_val = NULL;
    uint8_t channel              = adc_chan_ctl__select_chan__getf();
 
    adc_int                      = adc_int_get();
 
    if (!(adc_int & (ADC_INT_READ_REQ_INT_SET | ADC_INT_FIFO_ERROR_INT_SET))) {
//        DEBUG("adc error\n");
        return;
    }
 
    fifo_val = (ADC_FIFO_TypeDef_t *)&val;
 
    for (int t = 0; t < adc_fifo_ctl__read_req_thresh__getf(); t++) {
        val = adc_fifo_get();
 
        if (fifo_val->chanel_1 != fifo_val->chanel_2) {
            DEBUG("channel error :%d\n", t);
            break;
        }
 
        if (fifo_val->chanel_1 != channel) {
            DEBUG("channel error :%d\n", t);
            break;
        }
 
        adc_value[adc_count++] = fifo_val->value_1;
        adc_value[adc_count++] = fifo_val->value_2;
    }
 
    val = xc_adc_data_average(adc_value, adc_count);
    xc_adc_it_collectval_set(val);
 
    adc_chan_ctl__select_chan__setf(channel);
}