找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 1449|回复: 1
收起左侧

STM32控制FDC2214程序

[复制链接]
ID:442993 发表于 2020-3-28 09:31 | 显示全部楼层 |阅读模式
#include "2214.h"

/**********************************************
* 硬件连接:------------------
*          | PB3  - SDIN      |
*          | PB4  - SCLK      |
*           ------------------
*
*********************************************************************************/


/**********************************用法********************************/
//#include "stm32f10x.h"
//#include "LED.h"
//#include "delay.h"
//#include "KEY.h"
//#include "OLED_IIC.h"
//#include "usart.h"
//#include "ADC.h"
//#include "DAC.h"
//#include "TIM.h"
//#include "2214.h"

//void FDC2214_GetData(void);
//u32 ch0,ch1,ch2,ch3;

//int main(void)
//{
//        u32 t = 0;
//        delay_init(); //延时函数初始化
//        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置 NVIC 中断分组 2
//        uart_init(115200); //串口初始化波特率为 115200
//        OLED_Init();
//        OLED_Clear();
//        LED_Pin_Init(); //LED 端口初始化
//        OLED_ShowCHinese(90,0,7);//赞
//       
//        FDC2214_init();
//       
//        while(1)
//        {
//                        FDC2214_GetData();
//                        //printf("\r\nCH0~3(%d , %d , %d , %d)",ch0,ch1,ch2,ch3);
//                        OLED_ShowNum(0,0,ch0,16,16);
//                        OLED_ShowNum(0,2,ch1,16,16);
//                        OLED_ShowNum(0,4,ch2,16,16);
//                        OLED_ShowNum(0,6,ch3,16,16);
//                        delay_ms(500);         //延时300ms
//        }
//}

//void FDC2214_GetData(void)
//{
//    FDC2214_GetChannelData(FDC2214_Channel_0, &ch0);  
//    FDC2214_GetChannelData(FDC2214_Channel_1, &ch1);
//    FDC2214_GetChannelData(FDC2214_Channel_2, &ch2);
//    FDC2214_GetChannelData(FDC2214_Channel_3, &ch3);
//}




#define PI 3.14159265358979323846
#define ClockFrequency   36000000 //时钟频率

uint8_t CHx_FIN_SEL[4];
double fREFx[4];


void FDC_IIC_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOB, ENABLE );        //使能GPIOB时钟
   
   
    RCC_APB2PeriphClockCmd(        RCC_APB2Periph_AFIO, ENABLE );
    GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);//关闭JTAG,释放PB3,PB4,PA15
   
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_4;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;//推挽输出
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);
    GPIO_SetBits(GPIOB,GPIO_Pin_3|GPIO_Pin_4);         //输出高
}

void delay_2us(void)
{
    //一个NOP是1/72us  所以72个NOP是1us
    u32 i=0;  
    for(i=0;i<2;i++)
    {  
        __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
        __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
        __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
        __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
        __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();  
        __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
        __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
   
    }  
}
void FDC_IIC_Start(void)
{
        SDA_OUT();
        FDC_IIC_SDA_OUT=1;                    
        FDC_IIC_SCL=1;
        delay_2us();
        FDC_IIC_SDA_OUT=0;
        delay_2us();
        FDC_IIC_SCL=0;
        delay_2us();
}          


void FDC_IIC_Stop(void)
{
        SDA_OUT();
        FDC_IIC_SCL=0;
    delay_2us();
        FDC_IIC_SDA_OUT=0;
        delay_2us();
        FDC_IIC_SCL=1;
    delay_2us();
        FDC_IIC_SDA_OUT=1;
        delay_2us();                                                          
}

u8 FDC_IIC_Wait_Ack(void)
{
        u8 waitTime=0;
        SDA_IN();  
        FDC_IIC_SDA_OUT=1;
    delay_2us();          
        FDC_IIC_SCL=1;
    delay_2us();
        while(FDC_IIC_SDA_IN)
        {
                waitTime++;
                if(waitTime>250)
                {
                        FDC_IIC_Stop();
                        return 1;
                }
        }
        FDC_IIC_SCL=0;   
        return 0;  
}

void FDC_IIC_Ack(void)
{
        FDC_IIC_SCL=0;
    delay_2us();
        SDA_OUT();
        FDC_IIC_SDA_OUT=0;//发送0是ACK
        delay_2us();
        FDC_IIC_SCL=1;
        delay_2us();
        FDC_IIC_SCL=0;
    delay_2us();
}

void FDC_IIC_NAck(void)
{
        FDC_IIC_SCL=0;
    delay_2us();
        SDA_OUT();
        FDC_IIC_SDA_OUT=1;//发送1是nACK
        delay_2us();
        FDC_IIC_SCL=1;
        delay_2us();
        FDC_IIC_SCL=0;
    delay_2us();
}

void FDC_IIC_Send_Byte(u8 dat)
{                        
    u8 t;   
        SDA_OUT();
    FDC_IIC_SCL=0;       
    for(t=0;t<8;t++)
    {      
        
                delay_2us();
        FDC_IIC_SDA_OUT=(dat&0x80)>>7;
        dat<<=1;
        FDC_IIC_SCL=1;        
                delay_2us();
                FDC_IIC_SCL=0;
                delay_2us();       
    }
    //FDC_IIC_SCL=0;
}

u8 FDC_IIC_Read_Byte(u8 ack)
{
        u8 i,receive=0;
        FDC_IIC_SDA_OUT=1;
    SDA_IN();
    for(i=0;i<8;i++ )
        {
        receive<<=1;
        
        FDC_IIC_SCL=0;
        delay_2us();
                FDC_IIC_SCL=1;
        delay_2us();
        if(FDC_IIC_SDA_IN)receive++;//最低位置1   
    }
    FDC_IIC_SCL=0;
    if (!ack)
        FDC_IIC_NAck();
    else
        FDC_IIC_Ack();  
    return receive;
}




/*!
*  @brief      FDC_IIC写FDC2214
*  @param      Slve_Addr     器件地址
*  @param      reg           寄存器
*  @param      data          数据
*  @since      v1.0
*  Sample usage:       FDC2214_Write16(FDC2214_Addr, FDC2214_CONFIG, 0xFFFF);
*/
void FDC2214_Write16(uint8_t Slve_Addr, uint8_t reg, uint16_t data)
{
    u8 dat;
    FDC_IIC_Start();
   
    FDC_IIC_Send_Byte(Slve_Addr << 1);
    FDC_IIC_Wait_Ack();
   
    FDC_IIC_Send_Byte(reg);
    FDC_IIC_Wait_Ack();
   
    dat=(data >> 8);
    FDC_IIC_Send_Byte(dat);
    FDC_IIC_Wait_Ack();
   
    dat=data & 0xFF;
    FDC_IIC_Send_Byte(dat);
    FDC_IIC_Wait_Ack();
   
    FDC_IIC_Stop();
}

/*!
*  @brief      FDC_IIC读FDC2214
*  @param      Slve_Addr     器件地址
*  @param      reg           寄存器
*  @return     寄存器值
*  @since      v1.0
*  Sample usage:       FDC2214_Read16(FDC2214_Addr, FDC2214_CONFIG);
*/
uint16_t FDC2214_Read16(uint8_t Slve_Addr, uint8_t reg)
{
    uint16_t temp;

    FDC_IIC_Start();
    FDC_IIC_Send_Byte(Slve_Addr << 1);
    FDC_IIC_Wait_Ack();
    FDC_IIC_Send_Byte(reg);
    FDC_IIC_Wait_Ack();
    FDC_IIC_Start();
    FDC_IIC_Send_Byte((Slve_Addr << 1) | 0x01);
    FDC_IIC_Wait_Ack();
    temp = (uint16_t)(FDC_IIC_Read_Byte(1) << 8);
    temp |= FDC_IIC_Read_Byte(0);
    FDC_IIC_Stop();
   
    return temp;
}

/*!
*  @brief      读取FDC2214一个通道的转换值
*  @param      channel     通道
*  @param      *data       读取的数据
*  @return     0:失败;1:成功
*  @since      v1.0
*  Sample usage:       FDC2214_GetChannelData(FDC2214_Channel_0, &CH0_DATA);
*/
uint8_t FDC2214_GetChannelData(FDC2214_channel_t channel, uint32_t *data)
{
    int16_t timeout = 100;
    uint8_t dateReg_H;
    uint8_t dateReg_L;
    uint8_t bitUnreadConv;
    uint16_t status;
    uint32_t dataRead;

    switch(channel)
    {
        case FDC2214_Channel_0:
            dateReg_H = FDC2214_DATA_CH0;
            dateReg_L = FDC2214_DATA_LSB_CH0;
            bitUnreadConv = 0x0008;
        break;

        case FDC2214_Channel_1:
            dateReg_H = FDC2214_DATA_CH1;
            dateReg_L = FDC2214_DATA_LSB_CH1;
            bitUnreadConv = 0x0004;
        break;

        case FDC2214_Channel_2:
            dateReg_H = FDC2214_DATA_CH2;
            dateReg_L = FDC2214_DATA_LSB_CH2;
            bitUnreadConv = 0x0002;
        break;

        case FDC2214_Channel_3:
            dateReg_H = FDC2214_DATA_CH3;
            dateReg_L = FDC2214_DATA_LSB_CH3;
            bitUnreadConv = 0x0001;
        break;
    }

    status = FDC2214_Read16(FDC2214_Addr, FDC2214_STATUS);//读取状态寄存器的值
    while(timeout && !(status & bitUnreadConv))//检查是否有未读数据
    {
        status = FDC2214_Read16(FDC2214_Addr, FDC2214_STATUS);
        timeout--;
    }
    if(timeout)
    {
        dataRead = (uint32_t)(FDC2214_Read16(FDC2214_Addr, dateReg_H) << 16);
        dataRead |= FDC2214_Read16(FDC2214_Addr, dateReg_L);
        *data = dataRead;
        return 1;
    }
    else
    {
        //超时
      
        return 0;
    }
}

/*!
*  @brief      设置FDC2214一个通道的转换时间,转换时间(tCx)=(CHx_RCOUNT?16) / fREFx。
*  @param      channel     通道
*  @param      rcount      CHx_RCOUNT
*  @since      v1.0
*  Sample usage:       FDC2214_SetRcount(FDC2214_Channel_0, 0x0FFF);
*/
void FDC2214_SetRcount(FDC2214_channel_t channel, uint16_t rcount)
{
    if(rcount <= 0x00FF) return;

    switch(channel)
    {
        case FDC2214_Channel_0:
            FDC2214_Write16(FDC2214_Addr, FDC2214_RCOUNT_CH0, rcount);
        break;

        case FDC2214_Channel_1:
            FDC2214_Write16(FDC2214_Addr, FDC2214_RCOUNT_CH1, rcount);
        break;

        case FDC2214_Channel_2:
            FDC2214_Write16(FDC2214_Addr, FDC2214_RCOUNT_CH2, rcount);
        break;

        case FDC2214_Channel_3:
            FDC2214_Write16(FDC2214_Addr, FDC2214_RCOUNT_CH3, rcount);
        break;
    }
}

/*!
*  @brief      设置FDC2214一个通道的建立时间,使LC传感器可以在通道x开始转换之前稳定下来,建立时间(tSx) = (CHx_SETTLECOUNT?16) ÷ fREFx。
                CHx_SETTLECOUNT = 0x00, 0x01时(tSx) = 32 ÷ fREFx。
*  @param      channel     通道
*  @param      count       CHx_SETTLECOUNT
*  @since      v1.0
*  @note       CHx_SETTLECOUNT > Vpk × fREFx × C × π^2 / (32 × IDRIVEX)
*  Sample usage:       FDC2214_SetSettleCount(FDC2214_Channel_0, 0x00FF);
*/
void FDC2214_SetSettleCount(FDC2214_channel_t channel, uint16_t count)
{
    switch(channel)
    {
        case FDC2214_Channel_0:
            FDC2214_Write16(FDC2214_Addr, FDC2214_SETTLECOUNT_CH0, count);
        break;

        case FDC2214_Channel_1:
            FDC2214_Write16(FDC2214_Addr, FDC2214_SETTLECOUNT_CH1, count);
        break;

        case FDC2214_Channel_2:
            FDC2214_Write16(FDC2214_Addr, FDC2214_SETTLECOUNT_CH2, count);
        break;

        case FDC2214_Channel_3:
            FDC2214_Write16(FDC2214_Addr, FDC2214_SETTLECOUNT_CH3, count);
        break;
    }
}

/*!
*  @brief      设置FDC2214一个通道的的时钟频率,
                差分传感器配置:
                0x01 -- 传感器频率0.01MHz和8.75MHz
                0x02 -- 传感器频率5MHz和10MHz
                单端传感器配置:
                0x01 -- 传感器频率0.01MHz和10MHz
*  @param      channel               通道
*  @param      frequency_select      时钟选择
*  @param      divider               分频器,fREFx = fCLK / CHx_FREF_DIVIDER,
*  @note       fREFx is > 4 × fSENSOR(外部LC振荡器频率)
*  @since      v1.0
*  Sample usage:       FDC2214_SetChannelClock(FDC2214_Channel_0, 0x01, 0xFF);
*/
void FDC2214_SetChannelClock(FDC2214_channel_t channel, uint8_t frequency_select, uint16_t divider)
{
    uint16_t temp = 0;

    temp = (uint16_t)(frequency_select << 12) | (divider & 0x03FF);

    CHx_FIN_SEL[channel] = frequency_select;//记录时钟选择
    fREFx[channel] = (double)ClockFrequency / divider;//记录时钟频率

    switch(channel)
    {
        case FDC2214_Channel_0:
            FDC2214_Write16(FDC2214_Addr, FDC2214_CLOCK_DIVIDERS_CH0, temp);
        break;

        case FDC2214_Channel_1:
            FDC2214_Write16(FDC2214_Addr, FDC2214_CLOCK_DIVIDERS_CH1, temp);
        break;

        case FDC2214_Channel_2:
            FDC2214_Write16(FDC2214_Addr, FDC2214_CLOCK_DIVIDERS_CH2, temp);
        break;

        case FDC2214_Channel_3:
            FDC2214_Write16(FDC2214_Addr, FDC2214_CLOCK_DIVIDERS_CH3, temp);
        break;
    }
}

/*!
*  @brief      配置INTB引脚中断功能
*  @param      mode      1:开中断;0:关中断
*  @since      v1.0
*  Sample usage:       FDC2214_SetDriveCurrent(FDC2214_Channel_0, FDC2214_Drive_Current_0_025);
*/
void FDC2214_SetINTB(uint8_t mode)
{
    uint16_t temp = 0;

    temp = FDC2214_Read16(FDC2214_Addr, FDC2214_CONFIG);
    temp &= 0xFF7F;
    if(mode)
        temp |= 0x0080;
    FDC2214_Write16(FDC2214_Addr, FDC2214_CONFIG, temp);

    temp = FDC2214_Read16(FDC2214_Addr, FDC2214_ERROR_CONFIG);
    temp &= 0xFFFE;
    if(mode)
        temp |= 0x0001;
    FDC2214_Write16(FDC2214_Addr, FDC2214_ERROR_CONFIG, temp);
}

/*!
*  @brief      激活FDC2214的一个通道,单通道模式
*  @param      channel     通道
*  @since      v1.0
*  Sample usage:       FDC2214_SetActiveChannel(FDC2214_Channel_0);
*/
void FDC2214_SetActiveChannel(FDC2214_channel_t channel)
{
    uint16_t temp = 0;
    temp = FDC2214_Read16(FDC2214_Addr, FDC2214_CONFIG);
    temp &= 0x3FFF;
    temp |= (uint16_t)(channel << 14);

    FDC2214_Write16(FDC2214_Addr, FDC2214_CONFIG, temp);
}

/*!
*  @brief      设置FDC2214的工作模式:正常、睡眠。
*  @param      mode     0:正常工作;1:睡激活模式选择。眠
*  @since      v1.0
*  Sample usage:       FDC2214_SetSleepMode(0);
*/
void FDC2214_SetSleepMode(uint8_t mode)
{
    uint16_t temp = 0;
    temp = FDC2214_Read16(FDC2214_Addr, FDC2214_CONFIG);
    temp &= 0xDFFF;
    if(mode)temp |= 0x2000;

    FDC2214_Write16(FDC2214_Addr, FDC2214_CONFIG, temp);
}

/*!
*  @brief      FDC2214激活模式选择。
*  @param      mode     0:全电流激活模式;1:低功率激活模式
*  @since      v1.0
*  Sample usage:       FDC2214_SetCurrentMode(1);
*/
void FDC2214_SetCurrentMode(uint8_t mode)
{
    uint16_t temp = 0;
    temp = FDC2214_Read16(FDC2214_Addr, FDC2214_CONFIG);
    temp &= 0xF7FF;
    if(mode)
        temp |= 0x800;

    FDC2214_Write16(FDC2214_Addr, FDC2214_CONFIG, temp);
}

/*!
*  @brief      设置FDC2214时钟源
*  @param      src     0:内部时钟源;1:外部时钟源
*  @since      v1.0
*  Sample usage:       FDC2214_SetClockSource(1);
*/
void FDC2214_SetClockSource(uint8_t src)
{
    uint16_t temp = 0;
    temp = FDC2214_Read16(FDC2214_Addr, FDC2214_CONFIG);
    temp &= 0xFDFF;
    if(src)
        temp |= 0x200;

    FDC2214_Write16(FDC2214_Addr, FDC2214_CONFIG, temp);
}

/*!
*  @brief      高电流传感器驱动,只适用于单通道模式。
*  @param      mode     0:正常(最大1.5mA);1:高电流传感器驱动(>1.5mA)
*  @since      v1.0
*  Sample usage:       FDC2214_SetHighCurrentMode(0);
*/
void FDC2214_SetHighCurrentMode(uint8_t mode)
{
    uint16_t temp = 0;
    temp = FDC2214_Read16(FDC2214_Addr, FDC2214_CONFIG);
    temp &= 0xFFBF;
    if(mode)
        temp |= 0x40;

    FDC2214_Write16(FDC2214_Addr, FDC2214_CONFIG, temp);
}

/*!
*  @brief      设置FDC2214的MUX CONFIG寄存器
*  @param      autoscan      自动扫描模式 0:关闭,1:打开
*  @param      channels      自动扫描通道
*  @param      bandwidth     数字滤波器带宽,大于外部LC振荡器频率
*  @since      v1.0
*  Sample usage:       FDC2214_SetMUX_CONFIG(1, FDC2214_Channel_Sequence_0_1_2, FDC2214_Bandwidth_10M);
*/
void FDC2214_SetMUX_CONFIG(uint8_t autoscan, FDC2214_channel_sequence_t channels, FDC2214_filter_bandwidth_t bandwidth)
{
    uint16_t temp = 0;

    if(autoscan)
    {
        temp = (uint16_t)(autoscan << 15) | (channels << 13) | 0x0208 | bandwidth;
    }
    else
    {
        temp = 0x0208 | bandwidth;
    }

    FDC2214_Write16(FDC2214_Addr, FDC2214_MUX_CONFIG, temp);
}

/*!
*  @brief      传感器复位
*  @since      v1.0
*  Sample usage:       FDC2214_Reset();
*/
void FDC2214_Reset(void)
{
    FDC2214_Write16(FDC2214_Addr, FDC2214_RESET_DEV, 0x8000);
}

/*!
*  @brief      设置FDC2214的一个通道传感器驱动电流,确保振荡幅度在1.2V和1.8V之间。
*  @param      channel      通道
*  @param      current      电流大小
*  @since      v1.0
*  Sample usage:       FDC2214_SetDriveCurrent(FDC2214_Channel_0, FDC2214_Drive_Current_0_025);
*/
void FDC2214_SetDriveCurrent(FDC2214_channel_t channel, FDC2214_drive_current_t current)
{
    uint16_t temp = 0;
    temp = (uint16_t)(current << 11);

    switch(channel)
    {
        case FDC2214_Channel_0:
            FDC2214_Write16(FDC2214_Addr, FDC2214_DRIVE_CURRENT_CH0, temp);
        break;

        case FDC2214_Channel_1:
            FDC2214_Write16(FDC2214_Addr, FDC2214_DRIVE_CURRENT_CH1, temp);
        break;

        case FDC2214_Channel_2:
            FDC2214_Write16(FDC2214_Addr, FDC2214_DRIVE_CURRENT_CH2, temp);
        break;

        case FDC2214_Channel_3:
            FDC2214_Write16(FDC2214_Addr, FDC2214_DRIVE_CURRENT_CH3, temp);
        break;
    }
}

/*!
*  @brief      计算频率
*  @param      channel      通道
*  @param      datax        读取的转换值
*  @return     频率,单位Hz
*  @since      v1.0
*  Sample usage:       FDC2214_CalculateFrequency(FDC2214_Channel_0, 0xFF);
*/
double FDC2214_CalculateFrequency(FDC2214_channel_t channel, uint32_t datax)
{
    double frequency = 0.0;

    frequency = (double)(CHx_FIN_SEL[channel] * fREFx[channel] * datax) / 268435456.0;//2^28

    return frequency;
}

/*!
*  @brief      计算外部电容大小
*  @param      frequency      频率大小,单位Hz
*  @param      inductance     板载电感大小,单位uH
*  @param      capacitance    板载电容大小,单位pF
*  @return     外部电容大小,单位pF
*  @since      v1.0
*  Sample usage:       FDC2214_CalculateCapacitance(FDC2214_Channel_0, 6000000, 18, 33);
*/
double FDC2214_CalculateCapacitance(double frequency, float inductance, float capacitance)
{
    double cap = 0.0;

    cap = (double)(1.0 / (inductance * (2 * PI * frequency) * (2 * PI * frequency)));

    return cap;
}

/*!
*  @brief      FDC2214初始化函数
*  @return     1:成功;0:失败
*  @since      v1.0
*  Sample usage:       FDC2214_Init();
*/
uint8_t FDC2214_Init(void)
{
    uint16_t deviceID = 0;
    deviceID = FDC2214_Read16(FDC2214_Addr, FDC2214_DEVICE_ID);//读器件ID
    if(deviceID == FDC2214_ID)
    {
        printf("\r\nFDC2214 ID:%d",deviceID);
        FDC2214_Reset();
        
   
        FDC2214_SetRcount(FDC2214_Channel_0, 5000);//2000us 转换周期
        FDC2214_SetRcount(FDC2214_Channel_1, 5000);//2000us 转换周期
        FDC2214_SetRcount(FDC2214_Channel_2, 5000);//2000us 转换周期
        FDC2214_SetRcount(FDC2214_Channel_3, 5000);//2000us 转换周期
        FDC2214_SetSettleCount(FDC2214_Channel_0, 200);//200 cycles 等待时间
        FDC2214_SetSettleCount(FDC2214_Channel_1, 200);//200 cycles 等待时间
        FDC2214_SetSettleCount(FDC2214_Channel_2, 200);//200 cycles 等待时间
        FDC2214_SetSettleCount(FDC2214_Channel_3, 200);//200 cycles 等待时间
        FDC2214_SetChannelClock(FDC2214_Channel_0, 2, 1);//设置时钟分频,1分频,40MHz
        FDC2214_SetChannelClock(FDC2214_Channel_1, 2, 1);//设置时钟分频,1分频,40MHz
        FDC2214_SetChannelClock(FDC2214_Channel_2, 2, 1);//设置时钟分频,1分频,40MHz
        FDC2214_SetChannelClock(FDC2214_Channel_3, 2, 1);//设置时钟分频,1分频,40MHz
        
        FDC2214_SetINTB(0);//关闭INTB中断
        //FDC2214_SetActiveChannel(FDC2214_Channel_0);//开启通道0
        FDC2214_SetCurrentMode(0);//全电流激活模式
        FDC2214_SetClockSource(1);//外部时钟源
        FDC2214_SetHighCurrentMode(0);//正常电流传感器驱动
        
        FDC2214_SetMUX_CONFIG(1, FDC2214_Channel_Sequence_0_1_2_3, FDC2214_Bandwidth_10M);//打开自动扫描,10MHz带宽
        
        FDC2214_SetDriveCurrent(FDC2214_Channel_0, FDC2214_Drive_Current_0_081);//通道0驱动电流0.081mA
        FDC2214_SetDriveCurrent(FDC2214_Channel_1, FDC2214_Drive_Current_0_081);//通道1驱动电流0.081mA
        FDC2214_SetDriveCurrent(FDC2214_Channel_2, FDC2214_Drive_Current_0_081);//通道2驱动电流0.081mA
        FDC2214_SetDriveCurrent(FDC2214_Channel_3, FDC2214_Drive_Current_0_081);//通道3驱动电流0.081mA
        
        
        FDC2214_SetSleepMode(0);//退出睡眠状态,开始工作
        delay_ms(100);
        
        return 1;
    }
    else
    {
                        printf("\r\nFDC2214 ID:%d",deviceID);
        printf("\r\nFDC2214 Init Failed!!\r\n");
    }

    return 0;
}



void FDC2214_init(void)
{
        FDC_IIC_Init();
  FDC2214_Init();
}



/**************************************************************************************/

#ifndef __2214_H
#define __2214_H
#include "sys.h"
#include "stdio.h"
#include "delay.h"

#define FDC_IIC_SCL         PBout(4)
#define FDC_IIC_SDA_OUT     PBout(3)
#define FDC_IIC_SDA_IN      PBin(3)

#define SDA_OUT()       {GPIOB->CRL&=0XFFFF0FFF;GPIOB->CRL|=(u32)3<<12;}//推挽输出
#define SDA_IN()        {GPIOB->CRL&=0XFFFF0FFF;GPIOB->CRL|=(u32)8<<12;}//上拉输入


#define SWAP16(data)    (uint32_t)((((uint16_t)(data) & (0xFF<<0 ))<<8)|(((uint32_t)(data) & (0xFF<<8))>>8))
#define FDC2214_Addr                 (0x2A)
#define FDC2214_DATA_CH0             (0x00)
#define FDC2214_DATA_LSB_CH0         (0x01)
#define FDC2214_DATA_CH1             (0x02)
#define FDC2214_DATA_LSB_CH1         (0x03)
#define FDC2214_DATA_CH2             (0x04)
#define FDC2214_DATA_LSB_CH2         (0x05)
#define FDC2214_DATA_CH3             (0x06)
#define FDC2214_DATA_LSB_CH3         (0x07)
#define FDC2214_RCOUNT_CH0           (0x08)
#define FDC2214_RCOUNT_CH1           (0x09)
#define FDC2214_RCOUNT_CH2           (0x0A)
#define FDC2214_RCOUNT_CH3           (0x0B)
#define FDC2214_SETTLECOUNT_CH0      (0x10)
#define FDC2214_SETTLECOUNT_CH1      (0x11)
#define FDC2214_SETTLECOUNT_CH2      (0x12)
#define FDC2214_SETTLECOUNT_CH3      (0x13)
#define FDC2214_CLOCK_DIVIDERS_CH0   (0x14)
#define FDC2214_CLOCK_DIVIDERS_CH1   (0x15)
#define FDC2214_CLOCK_DIVIDERS_CH2   (0x16)
#define FDC2214_CLOCK_DIVIDERS_CH3   (0x17)
#define FDC2214_STATUS               (0x18)
#define FDC2214_ERROR_CONFIG         (0x19)
#define FDC2214_CONFIG               (0x1A)
#define FDC2214_MUX_CONFIG           (0x1B)
#define FDC2214_RESET_DEV            (0x1C)
#define FDC2214_DRIVE_CURRENT_CH0    (0x1E)
#define FDC2214_DRIVE_CURRENT_CH1    (0x1F)
#define FDC2214_DRIVE_CURRENT_CH2    (0x20)
#define FDC2214_DRIVE_CURRENT_CH3    (0x21)
#define FDC2214_MANUFACTURER_ID      (0x7E)
#define FDC2214_DEVICE_ID            (0x7F)

#define FDC2214_ID                   (0x3055)


typedef enum
{
    FDC2214_Channel_0 = 0x00,
    FDC2214_Channel_1 = 0x01,
    FDC2214_Channel_2 = 0x02,
    FDC2214_Channel_3 = 0x03  
}FDC2214_channel_t;


typedef enum
{
    FDC2214_Channel_Sequence_0_1      = 0x00,
    FDC2214_Channel_Sequence_0_1_2    = 0x01,
    FDC2214_Channel_Sequence_0_1_2_3  = 0x02,
}FDC2214_channel_sequence_t;


typedef enum
{
    FDC2214_Bandwidth_1M   = 0x01, //1MHz
    FDC2214_Bandwidth_3_3M = 0x04, //3.3MHz
    FDC2214_Bandwidth_10M  = 0x05, //10MHz
    FDC2214_Bandwidth_33M  = 0x07  //33MHz
}FDC2214_filter_bandwidth_t;


typedef enum
{
    FDC2214_Drive_Current_0_016 = 0x00, //0.016mA
    FDC2214_Drive_Current_0_018 = 0x01, //0.018mA
    FDC2214_Drive_Current_0_021 = 0x02, //0.021mA
    FDC2214_Drive_Current_0_025 = 0x03, //0.025mA
    FDC2214_Drive_Current_0_028 = 0x04, //0.028mA
    FDC2214_Drive_Current_0_033 = 0x05, //0.033mA
    FDC2214_Drive_Current_0_038 = 0x06, //0.038mA
    FDC2214_Drive_Current_0_044 = 0x07, //0.044mA
    FDC2214_Drive_Current_0_052 = 0x08, //0.052mA
    FDC2214_Drive_Current_0_060 = 0x09, //0.060mA
    FDC2214_Drive_Current_0_069 = 0x0A, //0.069mA
    FDC2214_Drive_Current_0_081 = 0x0B, //0.081mA
    FDC2214_Drive_Current_0_093 = 0x0C, //0.093mA
    FDC2214_Drive_Current_0_108 = 0x0D, //0.108mA
    FDC2214_Drive_Current_0_126 = 0x0E, //0.126mA
    FDC2214_Drive_Current_0_146 = 0x0F, //0.146mA
    FDC2214_Drive_Current_0_169 = 0x10, //0.169mA
    FDC2214_Drive_Current_0_196 = 0x11, //0.196mA
    FDC2214_Drive_Current_0_228 = 0x12, //0.228mA
    FDC2214_Drive_Current_0_264 = 0x13, //0.264mA
    FDC2214_Drive_Current_0_307 = 0x14, //0.307mA
    FDC2214_Drive_Current_0_356 = 0x15, //0.356mA
    FDC2214_Drive_Current_0_413 = 0x16, //0.413mA
    FDC2214_Drive_Current_0_479 = 0x17, //0.479mA
    FDC2214_Drive_Current_0_555 = 0x18, //0.555mA
    FDC2214_Drive_Current_0_644 = 0x19, //0.644mA
    FDC2214_Drive_Current_0_747 = 0x1A, //0.747mA
    FDC2214_Drive_Current_0_867 = 0x1B, //0.867mA
    FDC2214_Drive_Current_1_006 = 0x1C, //1.006mA
    FDC2214_Drive_Current_1_167 = 0x1D, //1.167mA
    FDC2214_Drive_Current_1_354 = 0x1E, //1.354mA
    FDC2214_Drive_Current_1_571 = 0x1F  //1.571mA
}FDC2214_drive_current_t;

void FDC2214_Write16(uint8_t Slve_Addr, uint8_t reg, uint16_t data);
uint16_t FDC2214_Read16(uint8_t Slve_Addr, uint8_t reg);
uint8_t FDC2214_GetChannelData(FDC2214_channel_t channel, uint32_t *data);
void FDC2214_SetRcount(FDC2214_channel_t channel, uint16_t rcount);
void FDC2214_SetSettleCount(FDC2214_channel_t channel, uint16_t count);
void FDC2214_SetChannelClock(FDC2214_channel_t channel, uint8_t frequency_select, uint16_t divider);
void FDC2214_SetINTB(uint8_t mode);
void FDC2214_SetActiveChannel(FDC2214_channel_t channel);
void FDC2214_SetSleepMode(uint8_t mode);
void FDC2214_SetCurrentMode(uint8_t mode);
void FDC2214_SetClockSource(uint8_t src);
void FDC2214_SetHighCurrentMode(uint8_t mode);
void FDC2214_SetMUX_CONFIG(uint8_t autoscan, FDC2214_channel_sequence_t channels, FDC2214_filter_bandwidth_t bandwidth);
void FDC2214_Reset(void);
void FDC2214_SetDriveCurrent(FDC2214_channel_t channel, FDC2214_drive_current_t current);
double FDC2214_CalculateFrequency(FDC2214_channel_t channel, uint32_t datax);
double FDC2214_CalculateCapacitance(double frequency, float inductance, float capacitance);
uint8_t FDC2214_Init(void);



void FDC2214_init(void);
       
void FDC_IIC_Init(void);
void FDC_IIC_Start(void);
void FDC_IIC_Stop(void);
u8 FDC_IIC_Wait_Ack(void);
void FDC_IIC_Ack(void);
void FDC_IIC_NAck(void);
void FDC_IIC_Send_Byte(u8 dat);
u8 FDC_IIC_Read_Byte(u8 ack);

void delay_2us(void);
#endif


2214.zip

5.99 KB, 下载次数: 9, 下载积分: 黑币 -5

回复

使用道具 举报

ID:1 发表于 2020-3-30 01:00 | 显示全部楼层
本帖需要重新编辑补全电路原理图,源码,详细说明与图片即可获得100+黑币(帖子下方有编辑按钮)
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表