设为首页收藏本站
切换到宽版

EDABOSS电子论坛

 找回密码
 立即注册
搜索
热搜: 活动 交友 discuz
EDABOSS电子论坛»技术社区 › 开源硬件/智能硬件/智能控制 › Arduino › 基于Arduino驱动FDC2214程序(测试通过)
返回列表 发新帖
查看: 555|回复: 0

[资料共享] 基于Arduino驱动FDC2214程序(测试通过)

[复制链接]
红土

5

主题

0

回帖

26

E币

技术员

Rank: 2

积分
10
发表于 2019-12-4 17:27:44 | 显示全部楼层 |阅读模式
  1. /**************************************************************************/
  2. /*!
  3.     @file     NelsonsLog_FDC2214.cpp
  4.     @author   dlsc

  6. */
  7. /**************************************************************************/

  9. #include "Arduino.h"
  10. #include <Wire.h>
  11. #include "FDC2214.h"

  13. FDC2214::FDC2214(uint8_t i2caddr) {
  14.         _i2caddr = i2caddr;
  15.     //_i2caddr = FDC2214_I2C_ADDRESS;
  16. }

  18. // Checking for chip ID, if OK, calls chip init
  19. boolean FDC2214::begin(uint8_t chanMask, uint8_t autoscanSeq, uint8_t deglitchValue) {
  20.     Wire.begin();

  22.     int devId = read16FDC(FDC2214_DEVICE_ID);
  23.     if (devId != 0x3054) {
  24.         if (devId != 0x3055) {
  25.             //two valid device ids for FDC2214 0x3054 and 0x3055
  26.             return false;
  27.         }
  28.     }

  30.     loadSettings(chanMask, autoscanSeq, deglitchValue);
  31. //    setGain();

  33.     return true;
  34. }


  37. //Internal routine to do actual chip init
  38. void FDC2214::loadSettings(uint8_t chanMask, uint8_t autoscanSeq, uint8_t deglitchValue) {

  40.         //Configuration register
  41.         //        Active channel Select: b00 = ch0; b01 = ch1; b10 = ch2; b11 = ch3;
  42.         //  |Sleep Mode: 0 - device active; 1 - device in sleep;
  43.         //  ||Reserved, reserved, set to 1
  44.         //  |||Sensor Activation Mode: 0 - drive sensor with full current. 1 - drive sensor with current set by DRIVE_CURRENT_CHn
  45.         //  ||||Reserved, set to 1
  46.         //  |||||Reference clock: 0 - use internal; 1 - use external clock
  47.         //  ||||||Reserved, set to 0
  48.         //  |||||||Disable interrupt. 0 - interrupt output on INTB pin; 1 - no interrupt output
  49.         //  ||||||||High current sensor mode: 0 - 1.5mA max. 1 - > 1.5mA, not available if Autoscan is enabled
  50.         //  |||||||||     Reserved, set to 000001
  51.         //  |||||||||     |
  52.         // CCS1A1R0IH000000 -> 0001 1110 1000 0001 -> 0x1E81
  53.         write16FDC(FDC2214_CONFIG, 0x1E81);  //set config

  55.         //If channel 1 selected, init it..
  56.         if (chanMask & 0x01) {

  58.                 //settle count maximized, slow application
  59.                 write16FDC(FDC2214_SETTLECOUNT_CH0, 0x64);

  61.                 //rcount maximized for highest accuracy
  62.                 write16FDC(FDC2214_RCOUNT_CH0, 0xFFFF);

  64.                 //no offset
  65.                 write16FDC(FDC2214_OFFSET_CH0, 0x0000);
  66.                
  67.                 // Set clock dividers
  68.                 //  Reserved
  69.                 //  | Sensor Frequency Select. b01 = /1 = sensor freq 0.01 to 8.75MHz; b10 = /2 = sensor freq 0.01 to 10 or 5 to 10 MHz
  70.                 //  | | Reserved
  71.                 //  | | |         Reference divider. Must be > 1. fref = fclk / this register`
  72.                 //  | | |         |
  73.                 // 00FF00RRRRRRRRRR -> 0010000000000001 -> 0x2001
  74.                 write16FDC(FDC2214_CLOCK_DIVIDERS_CH0, 0x2001);
  75.                 //set drive register
  76.                 write16FDC(FDC2214_DRIVE_CH0, 0xF800);
  77.         }
  78.         // Init chan2, if selected by channel init mask
  79.         if (chanMask & 0x02) {
  80.                 write16FDC(FDC2214_SETTLECOUNT_CH1, 0x64);
  81.                 write16FDC(FDC2214_RCOUNT_CH1, 0xFFFF);
  82.                 write16FDC(FDC2214_OFFSET_CH1, 0x0000);
  83.                 write16FDC(FDC2214_CLOCK_DIVIDERS_CH1, 0x2001);
  84.                 write16FDC(FDC2214_DRIVE_CH1, 0xF800);        
  85.         }        
  86.         if (chanMask & 0x04) {
  87.                 write16FDC(FDC2214_SETTLECOUNT_CH1, 0x64);
  88.                 write16FDC(FDC2214_RCOUNT_CH1, 0xFFFF);
  89.                 write16FDC(FDC2214_OFFSET_CH1, 0x0000);
  90.                 write16FDC(FDC2214_CLOCK_DIVIDERS_CH1, 0x2001);
  91.                 write16FDC(FDC2214_DRIVE_CH1, 0xF800);        
  92.         }        
  93.         if (chanMask & 0x08) {
  94.                 write16FDC(FDC2214_SETTLECOUNT_CH1, 0x64);
  95.                 write16FDC(FDC2214_RCOUNT_CH1, 0xFFFF);
  96.                 write16FDC(FDC2214_OFFSET_CH1, 0x0000);
  97.                 write16FDC(FDC2214_CLOCK_DIVIDERS_CH1, 0x2001);
  98.                 write16FDC(FDC2214_DRIVE_CH1, 0xF800);        
  99.         }        
  100.         // Autoscan: 0 = single channel, selected by CONFIG.ACTIVE_CHAN
  101.         // | Autoscan sequence. b00 for chan 1-2, b01 for chan 1-2-3, b02 for chan 1-2-3-4
  102.         // | |         Reserved - must be b0001000001
  103.         // | |         |  Deglitch frequency. b001 for 1 MHz, b100 for 3.3 MHz, b101 for 10 Mhz, b111 for 33 MHz
  104.         // | |         |  |
  105.     // ARR0001000001DDD -> b0000 0010 0000 1000 -> h0208
  106.         uint16_t muxVal = 0x0208 | ((uint16_t)autoscanSeq << 13) | deglitchValue;
  107.         //
  108.     write16FDC(FDC2214_MUX_CONFIG, muxVal);  //set mux config for channels
  109. }

  111. ///**************************************************************************/
  112. ///*!
  113. //    @brief  Given a reading calculates the sensor frequency
  114. //*/
  115. ///**************************************************************************/
  116. //long long NelsonsLog_FDC2214::calculateFsensor(unsigned long reading){
  117. ////    Serial.println("reading: "+ String(reading));
  118. //    //fsensor = (CH_FIN_SEL * fref * data) / 2 ^ 28
  119. //    //should be mega hz so can truncate to long long
  120. //    Serial.println("FDC reading: " + String(reading));
  121. //    unsigned long long temp;
  122. //    temp = 1 * 40000000 * reading;
  123. //    temp = temp / (2^28);
  124. ////    Serial.println("frequency: " + String((long)temp));
  125. //    return temp;
  126. //}

  128. ///**************************************************************************/
  129. ///*!
  130. //    @brief  Given sensor frequency calculates capacitance
  131. //*/
  132. ///**************************************************************************/
  133. //double NelsonsLog_FDC2214::calculateCapacitance(long long fsensor){
  134. //    //differential configuration
  135. //    //c sensor = 1                            - (Cboard + Cparacitic)
  136. //    //             / (L * (2*pi * fsensor)^2)
  137. //
  138. //    double pi = 3.14159265359;
  139. //    double L = 18; //uH
  140. //    double Cboard = 33; //pf
  141. //    double Cparacitic = 3; //pf
  142. //
  143. //    double temp = 2 * pi * fsensor;
  144. //    temp = temp * temp;
  145. //
  146. //    temp = temp / 1000000; //uH
  147. //    temp *= L;
  148. //
  149. ////    Serial.println("capacitance: " + String(temp));
  150. //    return temp;
  151. //
  152. //}



  156. // Gets 28bit reading for FDC2212 and FDC2214
  157. // Takes in channel number, gives out the formatted 28 bit reading.
  158. unsigned long FDC2214::getReading28(uint8_t channel) {
  159.     int timeout = 100;
  160.     unsigned long reading = 0;
  161.     long long fsensor = 0;
  162.     int status = read16FDC(FDC2214_STATUS);
  163.     uint8_t addressMSB;
  164.         uint8_t addressLSB;
  165.         uint8_t bitUnreadConv;
  166.         switch (channel){
  167.                 case (0):
  168.                         addressMSB = FDC2214_DATA_CH0_MSB;
  169.                         addressLSB = FDC2214_DATA_CH0_LSB;
  170.                         bitUnreadConv = FDC2214_CH0_UNREADCONV;
  171.                 break;
  172.                 case (1):
  173.                         addressMSB = FDC2214_DATA_CH1_MSB;
  174.                         addressLSB = FDC2214_DATA_CH1_LSB;
  175.                         bitUnreadConv = FDC2214_CH1_UNREADCONV;
  176.                 break;
  177.                 case (2):
  178.                         addressMSB = FDC2214_DATA_CH1_MSB;
  179.                         addressLSB = FDC2214_DATA_CH1_LSB;
  180.                         bitUnreadConv = FDC2214_CH1_UNREADCONV;
  181.                 break;
  182.                 case (3):
  183.                         addressMSB = FDC2214_DATA_CH1_MSB;
  184.                         addressLSB = FDC2214_DATA_CH1_LSB;
  185.                         bitUnreadConv = FDC2214_CH1_UNREADCONV;
  186.                 break;
  187.                 default: return 0;
  188.         }
  189.         
  190.         while (timeout && !(status & FDC2214_CH0_UNREADCONV)) {
  191.         status = read16FDC(FDC2214_STATUS);
  192.         timeout--;
  193.     }
  194.     if (timeout == 100) {
  195. // #####################################################################################################
  196. // There was this weird double read, as "first readout could be stale" in Nelsons file.
  197. // I have not confirmed the existence of this silicon bug.
  198. // I suspect that it might be due to crappy breadboard or rats nest wiring or lack of signal integrity for other reason
  199. //
  200. // On the other hand, I have done far too little testing to be sure, so I am leaving that bit in for now.
  201. //        
  202. // #####################################################################################################
  203.                 //could be stale grab another //could it really it? ?????
  204.         //read the 28 bit result
  205.         reading = (uint32_t)(read16FDC(addressMSB) & FDC2214_DATA_CHx_MASK_DATA) << 16;
  206.         reading |= read16FDC(addressLSB);
  207.         while (timeout && !(status & FDC2214_CH0_UNREADCONV)) {
  208.             status = read16FDC(FDC2214_STATUS);
  209.             timeout--;
  210.         }
  211.     }
  212.     if (timeout) {
  213.         //read the 28 bit result
  214.         reading = (uint32_t)(read16FDC(addressMSB) & FDC2214_DATA_CHx_MASK_DATA) << 16;
  215.         reading |= read16FDC(addressLSB);
  216.         return reading;
  217.     } else {
  218.                 // Could not get data, chip readynes flag timeout
  219.         return 0;
  220.     }
  221. }

  223. // Gets 16bit reading for FDC2112 and FDC2114
  224. // Takes in channel number, gives out the formatted 28 bit reading.
  225. unsigned long FDC2214::getReading16(uint8_t channel) {
  226.     int timeout = 100;
  227.     unsigned long reading = 0;
  228.     long long fsensor = 0;
  229.     int status = read16FDC(FDC2214_STATUS);
  230.     uint8_t addressMSB;
  231.         uint8_t bitUnreadConv;
  232.         switch (channel){
  233.                 case (0):
  234.                         addressMSB = FDC2214_DATA_CH0_MSB;
  235.                         bitUnreadConv = FDC2214_CH0_UNREADCONV;
  236.                 break;
  237.                 case (1):
  238.                         addressMSB = FDC2214_DATA_CH1_MSB;
  239.                         bitUnreadConv = FDC2214_CH1_UNREADCONV;
  240.                 break;
  241.                 case (2):
  242.                         addressMSB = FDC2214_DATA_CH1_MSB;
  243.                         bitUnreadConv = FDC2214_CH1_UNREADCONV;
  244.                 break;
  245.                 case (3):
  246.                         addressMSB = FDC2214_DATA_CH1_MSB;
  247.                         bitUnreadConv = FDC2214_CH1_UNREADCONV;
  248.                 break;
  249.                 default: return 0;
  250.         }
  251.         
  252.         while (timeout && !(status & FDC2214_CH0_UNREADCONV)) {
  253.         status = read16FDC(FDC2214_STATUS);
  254.         timeout--;
  255.     }
  256.     if (timeout == 100) {
  257. // #####################################################################################################
  258. // There was this weird double read, as "first readout could be stale" in Nelsons file.
  259. // I have not confirmed the existence of this silicon bug.
  260. // I suspect that it might be due to crappy breadboard or rats nest wiring or lack of signal integrity for other reason
  261. //
  262. // On the other hand, I have done far too little testing to be sure, so I am leaving that bit in for now.
  263. //        
  264. // #####################################################################################################
  265.                 //could be stale grab another //could it really it? ?????
  266.         //read the 28 bit result
  267.         reading = (uint32_t)(read16FDC(addressMSB) & FDC2214_DATA_CHx_MASK_DATA) << 16;
  268.         while (timeout && !(status & FDC2214_CH0_UNREADCONV)) {
  269.             status = read16FDC(FDC2214_STATUS);
  270.             timeout--;
  271.         }
  272.     }
  273.     if (timeout) {
  274.         //read the 16 bit result
  275.         reading = (uint32_t)(read16FDC(addressMSB) & FDC2214_DATA_CHx_MASK_DATA) << 16;
  276.         return reading;
  277.     } else {
  278.                 // Could not get data, chip readynes flag timeout
  279.                 return 0;
  280.     }
  281. }

  283. ///**************************************************************************/
  284. ///*!
  285. //    @brief  Takes a reading and calculates capacitance from it
  286. //*/
  287. ///**************************************************************************/
  288. //double NelsonsLog_FDC2214::readCapacitance() {
  289. //    int timeout = 100;
  290. //    unsigned long reading = 0;
  291. //    long long fsensor = 0;
  292. //    int status = read16FDC(FDC2214_STATUS_REGADDR);
  293. //    while (timeout && !(status & FDC2214_CH0_UNREADCONV)) {
  294. ////        Serial.println("status: " + String(status));
  295. //        status = read16FDC(FDC2214_STATUS_REGADDR);
  296. //        timeout--;
  297. //    }
  298. //    if (timeout) {
  299. //        //read the 28 bit result
  300. //        reading = read16FDC(FDC2214_DATA_CH0_REGADDR) << 16;
  301. //        reading |= read16FDC(FDC2214_DATA_LSB_CH0_REGADDR);
  302. //        fsensor = calculateFsensor(reading);
  303. //        return calculateCapacitance(fsensor);
  304. //    } else {
  305. //        //error not reading
  306. //        Serial.println("error reading fdc");
  307. //        return 0;
  308. //    }
  309. //}


  312. /**************************************************************************/
  313. /*!
  314.     @brief  Scans various gain settings until the amplitude flag is cleared.
  315.             WARNING: Changing the gain setting will generally have an impact on the
  316.             reading.
  317. */
  318. /**************************************************************************/
  319. //void NelsonsLog_FDC2214::setGain(void) {
  320. //    //todo
  321. //}
  322. /**************************************************************************/
  323. /*!
  324.     @brief  I2C low level interfacing
  325. */
  326. /**************************************************************************/


  329. // Read 1 byte from the FDC at 'address'
  330. uint8_t FDC2214::read8FDC(uint16_t address) {
  331.     uint8_t data;
  332.     Wire.beginTransmission(_i2caddr);
  333.     Wire.write(address >> 8);
  334.     Wire.write(address);
  335.     Wire.endTransmission(false);
  336.     Wire.requestFrom(_i2caddr, (uint8_t) 1);
  337.     uint8_t r = Wire.read();
  338.     return r;
  339. }

  341. // Read 2 byte from the FDC at 'address'
  342. uint32_t FDC2214::read32FDC(uint16_t address) {
  343.     uint32_t retVal = 0;
  344.         uint8_t data;

  346.     Wire.beginTransmission(_i2caddr);
  347. //    Wire.write(address >> 8);
  348.     Wire.write(address);
  349.     Wire.endTransmission(false);

  351.     Wire.requestFrom(_i2caddr, (uint8_t) 2);
  352.     while (!Wire.available());
  353.     data = Wire.read();
  354.     retVal |= (uint32_t)data << 24;
  355.     while (!Wire.available());
  356.     data = Wire.read();
  357.     retVal |= (uint32_t)data << 16;
  358.     while (!Wire.available());
  359.     data = Wire.read();
  360.     retVal |= (uint32_t)data << 8;
  361.     while (!Wire.available());
  362.     data = Wire.read();
  363.     retVal |= data;
  364.     return retVal;
  365. }

  367. // Read 2 byte from the FDC at 'address'
  368. uint16_t FDC2214::read16FDC(uint16_t address) {
  369.     uint16_t data;

  371.     Wire.beginTransmission(_i2caddr);
  372. //    Wire.write(address >> 8);
  373.     Wire.write(address);
  374.     Wire.endTransmission(false); //restart

  376.     Wire.requestFrom(_i2caddr, (uint8_t) 2);
  377.     while (!Wire.available());
  378.     data = Wire.read();
  379.     data <<= 8;
  380.     while (!Wire.available());
  381.     data |= Wire.read();
  382.     Wire.endTransmission(true); //end
  383.     return data;
  384. }

  386. // write 1 byte to FDC
  387. void FDC2214::write8FDC(uint16_t address, uint8_t data) {
  388.     Wire.beginTransmission(_i2caddr);
  389.     Wire.write(address >> 8);
  390.     Wire.write(address);
  391.     Wire.write(data);
  392.     Wire.endTransmission();
  393. }

  395. // write 2 bytes to FDC  
  396. void FDC2214::write16FDC(uint16_t address, uint16_t data) {
  397.     Wire.beginTransmission(_i2caddr);
  398.     Wire.write(address & 0xFF);
  399.     Wire.write(data >> 8);
  400.     Wire.write(data);
  401.     Wire.endTransmission();
  402. }
复制代码


基于Arduino驱动FDC2214程序(测试通过).rar

83.63 KB, 下载次数: 0, 下载积分: E币 -5 元
积分规则
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

Archiver|手机版|小黑屋|EDABOSS电子论坛

GMT+8, 2024-4-26 01:55 , Processed in 0.044893 second(s), 23 queries .

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

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