标题: STM32+FDC2214测试代码 [打印本页]
作者: 1425879    时间: 2020-1-1 12:09
标题: STM32+FDC2214测试代码
电赛FDC2214模块的程序

单片机源程序如下:
  1. #include "delay.h"
  2. #include "sys.h"
  3. #include "stdio.h"
  4. #include "usart.h"
  5. #include "timer.h"
  6. #include "FDC2214.h"

  8. void FDC2214_GetData(void);

  10. u32 ch0,ch1,ch2,ch3;

  12. u32 shujuchuli(u32 ch0)
  13. {
  14.         u8 i;
  15.         u32 he=0;
  16.         for(i=0;i<=10;i++)
  17.         {
  18.                 he=he+ch0;
  19.          
  20.         }
  21.         return (he/10);
  22.        
  23.        
  24.        

  26. }
  27. int main(void)
  28. {       
  29.         delay_init();//延时函数初始化       
  30.     uart_init(9600);//串口初始化   
  31.     TIM1_36Mhz_Init();//stm32定时器1输出一个36mhz方波，作为fdc2214的时钟。如果板载了40mhz的晶振，这个就不需要了。
  32.    
  33.     IIC_Init();
  34.     FDC2214_Init();
  35.         while(1)
  36.         {
  37.       FDC2214_GetData();
  38.                   printf("\r\nCH0~0(%d , %d , %d , %d)",ch0,ch1,ch2,shujuchuli(shujuchuli(shujuchuli(ch0))));
  39.       delay_ms(100);         //延时300ms
  40.         }
  41. }


  44. void FDC2214_GetData(void)
  45. {
  46.        
  47.     FDC2214_GetChannelData(FDC2214_Channel_0, &ch0);  
  48.     FDC2214_GetChannelData(FDC2214_Channel_1, &ch1);
  49.     FDC2214_GetChannelData(FDC2214_Channel_2, &ch2);
  50.     FDC2214_GetChannelData(FDC2214_Channel_3, &ch3);
  51.        
  52. }
复制代码
  1. #include "FDC2214.h"

  3. #define PI 3.14159265358979323846
  4. #define ClockFrequency   36000000 //时钟频率

  6. uint8_t CHx_FIN_SEL[4];
  7. double fREFx[4];


  10. /*!
  11. *  @brief      IIC写FDC2214
  12. *  @param      Slve_Addr     器件地址
  13. *  @param      reg           寄存器
  14. *  @param      data          数据
  15. *  @since      v1.0
  16. *  Sample usage:       FDC2214_Write16(FDC2214_Addr, FDC2214_CONFIG, 0xFFFF);
  17. */
  18. void FDC2214_Write16(uint8_t Slve_Addr, uint8_t reg, uint16_t data)
  19. {
  20.     u8 dat;
  21.     IIC_Start();
  22.    
  23.     IIC_Send_Byte(Slve_Addr << 1);
  24.     IIC_Wait_Ack();
  25.    
  26.     IIC_Send_Byte(reg);
  27.     IIC_Wait_Ack();
  28.    
  29.     dat=(data >> 8);
  30.     IIC_Send_Byte(dat);
  31.     IIC_Wait_Ack();
  32.    
  33.     dat=data & 0xFF;
  34.     IIC_Send_Byte(dat);
  35.     IIC_Wait_Ack();
  36.    
  37.     IIC_Stop();
  38. }

  40. /*!
  41. *  @brief      IIC读FDC2214
  42. *  @param      Slve_Addr     器件地址
  43. *  @param      reg           寄存器
  44. *  @return     寄存器值
  45. *  @since      v1.0
  46. *  Sample usage:       FDC2214_Read16(FDC2214_Addr, FDC2214_CONFIG);
  47. */
  48. uint16_t FDC2214_Read16(uint8_t Slve_Addr, uint8_t reg)
  49. {
  50.     uint16_t temp;

  52.     IIC_Start();
  53.     IIC_Send_Byte(Slve_Addr << 1);
  54.     IIC_Wait_Ack();
  55.     IIC_Send_Byte(reg);
  56.     IIC_Wait_Ack();
  57.     IIC_Start();
  58.     IIC_Send_Byte((Slve_Addr << 1) | 0x01);
  59.     IIC_Wait_Ack();
  60.     temp = (uint16_t)(IIC_Read_Byte(1) << 8);
  61.     temp |= IIC_Read_Byte(0);
  62.     IIC_Stop();
  63.    
  64.     return temp;
  65. }

  67. /*!
  68. *  @brief      读取FDC2214一个通道的转换值
  69. *  @param      channel     通道
  70. *  @param      *data       读取的数据
  71. *  @return     0：失败；1：成功
  72. *  @since      v1.0
  73. *  Sample usage:       FDC2214_GetChannelData(FDC2214_Channel_0, &CH0_DATA);
  74. */
  75. uint8_t FDC2214_GetChannelData(FDC2214_channel_t channel, uint32_t *data)
  76. {
  77.     int16_t timeout = 100;
  78.     uint8_t dateReg_H;
  79.     uint8_t dateReg_L;
  80.     uint8_t bitUnreadConv;
  81.     uint16_t status;
  82.     uint32_t dataRead;

  84.     switch(channel)
  85.     {
  86.         case FDC2214_Channel_0:
  87.             dateReg_H = FDC2214_DATA_CH0;
  88.             dateReg_L = FDC2214_DATA_LSB_CH0;
  89.             bitUnreadConv = 0x0008;
  90.         break;

  92.         case FDC2214_Channel_1:
  93.             dateReg_H = FDC2214_DATA_CH1;
  94.             dateReg_L = FDC2214_DATA_LSB_CH1;
  95.             bitUnreadConv = 0x0004;
  96.         break;

  98.         case FDC2214_Channel_2:
  99.             dateReg_H = FDC2214_DATA_CH2;
  100.             dateReg_L = FDC2214_DATA_LSB_CH2;
  101.             bitUnreadConv = 0x0002;
  102.         break;

  104.         case FDC2214_Channel_3:
  105.             dateReg_H = FDC2214_DATA_CH3;
  106.             dateReg_L = FDC2214_DATA_LSB_CH3;
  107.             bitUnreadConv = 0x0001;
  108.         break;
  109.     }

  111.     status = FDC2214_Read16(FDC2214_Addr, FDC2214_STATUS);//读取状态寄存器的值
  112.     while(timeout && !(status & bitUnreadConv))//检查是否有未读数据
  113.     {
  114.         status = FDC2214_Read16(FDC2214_Addr, FDC2214_STATUS);
  115.         timeout--;
  116.     }
  117.     if(timeout)
  118.     {
  119.         dataRead = (uint32_t)(FDC2214_Read16(FDC2214_Addr, dateReg_H) << 16);
  120.         dataRead |= FDC2214_Read16(FDC2214_Addr, dateReg_L);
  121.         *data = dataRead;
  122.         return 1;
  123.     }
  124.     else
  125.     {
  126.         //超时
  127.       
  128.         return 0;
  129.     }
  130. }

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

  143.     switch(channel)
  144.     {
  145.         case FDC2214_Channel_0:
  146.             FDC2214_Write16(FDC2214_Addr, FDC2214_RCOUNT_CH0, rcount);
  147.         break;

  149.         case FDC2214_Channel_1:
  150.             FDC2214_Write16(FDC2214_Addr, FDC2214_RCOUNT_CH1, rcount);
  151.         break;

  153.         case FDC2214_Channel_2:
  154.             FDC2214_Write16(FDC2214_Addr, FDC2214_RCOUNT_CH2, rcount);
  155.         break;

  157.         case FDC2214_Channel_3:
  158.             FDC2214_Write16(FDC2214_Addr, FDC2214_RCOUNT_CH3, rcount);
  159.         break;
  160.     }
  161. }

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

  180.         case FDC2214_Channel_1:
  181.             FDC2214_Write16(FDC2214_Addr, FDC2214_SETTLECOUNT_CH1, count);
  182.         break;

  184.         case FDC2214_Channel_2:
  185.             FDC2214_Write16(FDC2214_Addr, FDC2214_SETTLECOUNT_CH2, count);
  186.         break;

  188.         case FDC2214_Channel_3:
  189.             FDC2214_Write16(FDC2214_Addr, FDC2214_SETTLECOUNT_CH3, count);
  190.         break;
  191.     }
  192. }

  194. /*!
  195. *  @brief      设置FDC2214一个通道的的时钟频率,
  196.                 差分传感器配置：
  197.                 0x01 -- 传感器频率0.01MHz和8.75MHz
  198.                 0x02 -- 传感器频率5MHz和10MHz
  199.                 单端传感器配置：
  200.                 0x01 -- 传感器频率0.01MHz和10MHz
  201. *  @param      channel               通道
  202. *  @param      frequency_select      时钟选择
  203. *  @param      divider               分频器，fREFx = fCLK / CHx_FREF_DIVIDER，
  204. *  @note       fREFx is > 4 × fSENSOR(外部LC振荡器频率)
  205. *  @since      v1.0
  206. *  Sample usage:       FDC2214_SetChannelClock(FDC2214_Channel_0, 0x01, 0xFF);
  207. */
  208. void FDC2214_SetChannelClock(FDC2214_channel_t channel, uint8_t frequency_select, uint16_t divider)
  209. {
  210.     uint16_t temp = 0;

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

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

  217.     switch(channel)
  218.     {
  219.         case FDC2214_Channel_0:
  220.             FDC2214_Write16(FDC2214_Addr, FDC2214_CLOCK_DIVIDERS_CH0, temp);
  221.         break;

  223.         case FDC2214_Channel_1:
  224.             FDC2214_Write16(FDC2214_Addr, FDC2214_CLOCK_DIVIDERS_CH1, temp);
  225.         break;

  227.         case FDC2214_Channel_2:
  228.             FDC2214_Write16(FDC2214_Addr, FDC2214_CLOCK_DIVIDERS_CH2, temp);
  229.         break;

  231.         case FDC2214_Channel_3:
  232.             FDC2214_Write16(FDC2214_Addr, FDC2214_CLOCK_DIVIDERS_CH3, temp);
  233.         break;
  234.     }
  235. }

  237. /*!
  238. *  @brief      配置INTB引脚中断功能
  239. *  @param      mode      1：开中断；0：关中断
  240. *  @since      v1.0
  241. *  Sample usage:       FDC2214_SetDriveCurrent(FDC2214_Channel_0, FDC2214_Drive_Current_0_025);
  242. */
  243. void FDC2214_SetINTB(uint8_t mode)
  244. {
  245.     uint16_t temp = 0;

  247.     temp = FDC2214_Read16(FDC2214_Addr, FDC2214_CONFIG);
  248.     temp &= 0xFF7F;
  249.     if(mode)
  250.         temp |= 0x0080;
  251.     FDC2214_Write16(FDC2214_Addr, FDC2214_CONFIG, temp);

  253.     temp = FDC2214_Read16(FDC2214_Addr, FDC2214_ERROR_CONFIG);
  254.     temp &= 0xFFFE;
  255.     if(mode)
  256.         temp |= 0x0001;
  257.     FDC2214_Write16(FDC2214_Addr, FDC2214_ERROR_CONFIG, temp);
  258. }

  260. /*!
  261. *  @brief      激活FDC2214的一个通道，单通道模式
  262. *  @param      channel     通道
  263. *  @since      v1.0
  264. *  Sample usage:       FDC2214_SetActiveChannel(FDC2214_Channel_0);
  265. */
  266. void FDC2214_SetActiveChannel(FDC2214_channel_t channel)
  267. {
  268.     uint16_t temp = 0;
  269.     temp = FDC2214_Read16(FDC2214_Addr, FDC2214_CONFIG);
  270.     temp &= 0x3FFF;
  271.     temp |= (uint16_t)(channel << 14);

  273.     FDC2214_Write16(FDC2214_Addr, FDC2214_CONFIG, temp);
  274. }

  276. /*!
  277. *  @brief      设置FDC2214的工作模式：正常、睡眠。
  278. *  @param      mode     0：正常工作；1：睡激活模式选择。眠
  279. *  @since      v1.0
  280. *  Sample usage:       FDC2214_SetSleepMode(0);
  281. */
  282. void FDC2214_SetSleepMode(uint8_t mode)
  283. {
  284.     uint16_t temp = 0;
  285.     temp = FDC2214_Read16(FDC2214_Addr, FDC2214_CONFIG);
  286.     temp &= 0xDFFF;
  287.     if(mode)temp |= 0x2000;

  289.     FDC2214_Write16(FDC2214_Addr, FDC2214_CONFIG, temp);
  290. }

  292. /*!
  293. *  @brief      FDC2214激活模式选择。
  294. *  @param      mode     0：全电流激活模式；1：低功率激活模式
  295. *  @since      v1.0
  296. *  Sample usage:       FDC2214_SetCurrentMode(1);
  297. */
  298. void FDC2214_SetCurrentMode(uint8_t mode)
  299. {
  300.     uint16_t temp = 0;
  301.     temp = FDC2214_Read16(FDC2214_Addr, FDC2214_CONFIG);
  302.     temp &= 0xF7FF;
  303.     if(mode)
  304.         temp |= 0x800;

  306.     FDC2214_Write16(FDC2214_Addr, FDC2214_CONFIG, temp);
  307. }

  309. /*!
  310. *  @brief      设置FDC2214时钟源
  311. *  @param      src     0：内部时钟源；1：外部时钟源
  312. *  @since      v1.0
  313. *  Sample usage:       FDC2214_SetClockSource(1);
  314. */
  315. void FDC2214_SetClockSource(uint8_t src)
  316. {
  317.     uint16_t temp = 0;
  318.     temp = FDC2214_Read16(FDC2214_Addr, FDC2214_CONFIG);
  319.     temp &= 0xFDFF;
  320.     if(src)
  321.         temp |= 0x200;

  323.     FDC2214_Write16(FDC2214_Addr, FDC2214_CONFIG, temp);
  324. }

  326. /*!
  327. *  @brief      高电流传感器驱动，只适用于单通道模式。
  328. *  @param      mode     0：正常（最大1.5mA）；1：高电流传感器驱动（>1.5mA）
  329. *  @since      v1.0
  330. *  Sample usage:       FDC2214_SetHighCurrentMode(0);
  331. */
  332. void FDC2214_SetHighCurrentMode(uint8_t mode)
  333. {
  334.     uint16_t temp = 0;
  335.     temp = FDC2214_Read16(FDC2214_Addr, FDC2214_CONFIG);
  336.     temp &= 0xFFBF;
  337.     if(mode)
  338.         temp |= 0x40;

  340.     FDC2214_Write16(FDC2214_Addr, FDC2214_CONFIG, temp);
  341. }

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

  355.     if(autoscan)
  356.     {
  357.         temp = (uint16_t)(autoscan << 15) | (channels << 13) | 0x0208 | bandwidth;
  358.     }
  359.     else
  360.     {
  361.         temp = 0x0208 | bandwidth;
  362.     }

  364.     FDC2214_Write16(FDC2214_Addr, FDC2214_MUX_CONFIG, temp);
  365. }

  367. /*!
  368. *  @brief      传感器复位
  369. *  @since      v1.0
  370. *  Sample usage:       FDC2214_Reset();
  371. */
  372. void FDC2214_Reset(void)
  373. {
  374.     FDC2214_Write16(FDC2214_Addr, FDC2214_RESET_DEV, 0x8000);
  375. }

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

  389.     switch(channel)
  390.     {
  391.         case FDC2214_Channel_0:
  392.             FDC2214_Write16(FDC2214_Addr, FDC2214_DRIVE_CURRENT_CH0, temp);
  393.         break;

  395.         case FDC2214_Channel_1:
  396.             FDC2214_Write16(FDC2214_Addr, FDC2214_DRIVE_CURRENT_CH1, temp);
  397.         break;

  399.         case FDC2214_Channel_2:
  400.             FDC2214_Write16(FDC2214_Addr, FDC2214_DRIVE_CURRENT_CH2, temp);
  401.         break;

  403.         case FDC2214_Channel_3:
  404.             FDC2214_Write16(FDC2214_Addr, FDC2214_DRIVE_CURRENT_CH3, temp);
  405.         break;
  406.     }
  407. }

  409. /*!
  410. *  @brief      计算频率
  411. *  @param      channel      通道
  412. *  @param      datax        读取的转换值
  413. *  @return     频率，单位Hz
  414. *  @since      v1.0
  415. *  Sample usage:       FDC2214_CalculateFrequency(FDC2214_Channel_0, 0xFF);
  416. */
  417. double FDC2214_CalculateFrequency(FDC2214_channel_t channel, uint32_t datax)
  418. {
  419.     double frequency = 0.0;

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

  423.     return frequency;
  424. }

  426. /*!
  427. *  @brief      计算外部电容大小
  428. *  @param      frequency      频率大小，单位Hz
  429. *  @param      inductance     板载电感大小，单位uH
  430. *  @param      capacitance    板载电容大小，单位pF
  431. *  @return     外部电容大小，单位pF
  432. *  @since      v1.0
  433. *  Sample usage:       FDC2214_CalculateCapacitance(FDC2214_Channel_0, 6000000, 18, 33);
  434. */
  435. double FDC2214_CalculateCapacitance(double frequency, float inductance, float capacitance)
  436. {
  437.     double cap = 0.0;

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

  441.     return cap;
  442. }

  444. /*!
  445. *  @brief      FDC2214初始化函数
  446. *  @return     1：成功；0：失败
  447. *  @since      v1.0
  448. *  Sample usage:       FDC2214_Init();
  449. */
  450. uint8_t FDC2214_Init(void)
  451. {
  452.     uint16_t deviceID = 0;
  453.     deviceID = FDC2214_Read16(FDC2214_Addr, FDC2214_DEVICE_ID);//读器件ID
  454.     if(deviceID == FDC2214_ID)
  455.     {
  456.         printf("\r\nFDC2214 ID:%d",deviceID);
  457.         FDC2214_Reset();
  458.         
  459.    
  460.         FDC2214_SetRcount(FDC2214_Channel_0, 5000);//2000us 转换周期
  461.         FDC2214_SetRcount(FDC2214_Channel_1, 5000);//2000us 转换周期
  462.         FDC2214_SetRcount(FDC2214_Channel_2, 5000);//2000us 转换周期
  463.         FDC2214_SetRcount(FDC2214_Channel_3, 5000);//2000us 转换周期
  464.         FDC2214_SetSettleCount(FDC2214_Channel_0, 200);//200 cycles 等待时间
  465.         FDC2214_SetSettleCount(FDC2214_Channel_1, 200);//200 cycles 等待时间
  466.         FDC2214_SetSettleCount(FDC2214_Channel_2, 200);//200 cycles 等待时间
  467.         FDC2214_SetSettleCount(FDC2214_Channel_3, 200);//200 cycles 等待时间
  468.         FDC2214_SetChannelClock(FDC2214_Channel_0, 2, 1);//设置时钟分频，1分频，40MHz
  469.         FDC2214_SetChannelClock(FDC2214_Channel_1, 2, 1);//设置时钟分频，1分频，40MHz
  470.         FDC2214_SetChannelClock(FDC2214_Channel_2, 2, 1);//设置时钟分频，1分频，40MHz
  471.         FDC2214_SetChannelClock(FDC2214_Channel_3, 2, 1);//设置时钟分频，1分频，40MHz
  472.         
  473.         FDC2214_SetINTB(0);//关闭INTB中断
  474.                        
  475.                           FDC2214_SetActiveChannel(FDC2214_Channel_0);//开启通道0  （原来注释）
  476.                        
  477.         FDC2214_SetCurrentMode(0);//全电流激活模式
  478.         FDC2214_SetClockSource(1);//外部时钟源
  479.         FDC2214_SetHighCurrentMode(0);//正常电流传感器驱动
  480.         
  481.         FDC2214_SetMUX_CONFIG(1, FDC2214_Channel_Sequence_0_1_2_3, FDC2214_Bandwidth_10M);//打开自动扫描，10MHz带宽
  482.         
  483.         FDC2214_SetDriveCurrent(FDC2214_Channel_0, FDC2214_Drive_Current_0_081);//通道0驱动电流0.081mA
  484.         FDC2214_SetDriveCurrent(FDC2214_Channel_1, FDC2214_Drive_Current_0_081);//通道1驱动电流0.081mA
  485.         FDC2214_SetDriveCurrent(FDC2214_Channel_2, FDC2214_Drive_Current_0_081);//通道2驱动电流0.081mA
  486.         FDC2214_SetDriveCurrent(FDC2214_Channel_3, FDC2214_Drive_Current_0_081);//通道3驱动电流0.081mA
  487.         
  488.         
  489.         FDC2214_SetSleepMode(0);//退出睡眠状态，开始工作
  490.         delay_ms(100);
  491.         
  492.         return 1;
  493.     }
  494.     else
  495.     {
  496.         printf("\r\nFDC2214 Init Failed!!");
  497.     }

  499.     return 0;
  500. }



复制代码


所有资料51hei提供下载:
FDC2214测试代码.7z (191.77 KB, 下载次数: 13)






欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1