FDC1004 Kommunikation über I2C mit Arduino Uno

Hallo miteinander,

ich bin neu im Forum als auch in dem Gebiet mit Arduino Programmierung und hoffe es wird für euch alle verständlich sein meiner Problemstellung zu folgen ^^.

In einem Labor (Hochschule) haben wir (Studienkollegen und ich) eine Schaltung gebaut mit dem FDC1004 (Datasheet) und 4 unterschiedlichen Kondensatorflächen, siehe Bild:

Jetzt versuchen wir über I2C die Werte von den Kondensatoren über den FDC1004 auszulesen. Die Kommunikation besteht und wir konnten schon die Manufacturer ID (0x5449, siehe Register Map auf Seite 15 in Datasheet) auslesen.

Daraufhin haben wir uns versucht die Werte der Kondensatorflächen auszulesen und nach paar Tagen tests, haben wir das Gefühl, dass wir was falsch machen. Ich hoffe, dass wir bei der Herstellung der Schaltung nichts falsch gemacht haben.

So sieht der Code von meinem Studienkollgen aus. Er versucht kontinuierlich den Offset zu erhöhen, da wir ansonsten beim Offset=0 maximale Werte bekommen. Zumindest denken wir das.

#include<Wire.h>

int FDC=B1010000;
byte FDC_CONFIG = 0x0C;
byte RegisterValue1=B00000100;
byte RegisterValue21=B10000000;
byte RegisterValue22=B01000000;
byte RegisterValue23=B00100000;
byte RegisterValue24=B00010000;
byte MessConf1=0x08;
byte MessConfval11=B00010000;
byte MessConfval21=B00000000;
byte MessConf2=0x09;
byte MessConfval12=B00110000;
byte MessConfval22=B00000000;
byte MessConf3=0x0A;
byte MessConfval13=B01010000;
byte MessConfval23=B00000000;
byte MessConf4=0x0B;
byte MessConfval14=B01111100;
byte MessConfval24=B00000000;
int num =0;
int num1 =0;
int del=5;


void setup()
{
  Serial.begin(9600);
  Wire.begin();

}
boolean conversion()
{
  byte b=0;
  Wire.beginTransmission(FDC);
  Wire.write(0x0c);
  Wire.endTransmission();
  delay(del);
  Wire.requestFrom(FDC,2);
  b=Wire.read();
  b=Wire.read();
  delay(del);
  b&=B00001111;
  if (b==(B00001111))
  {

    return (0);
  }
  else return (1);
}
unsigned int getinfo(byte pointer)
{
  byte a,b;
  unsigned int c;
  Wire.beginTransmission(FDC);
  Wire.write(pointer);
  Wire.endTransmission();
  delay(del);
  Wire.requestFrom(FDC,2);
  a=Wire.read();
  b=Wire.read();
  delay(del);
  c=a;
  c=c<<8;
  c|=b;
  // Serial.print(a,HEX);
  // Serial.print(b,HEX);
  // Serial.print(c,HEX);
  return(c);
}

unsigned long getdata(byte pointer)
{
  unsigned int a,b;
  unsigned long c=0;
  a = getinfo(pointer);
  delay(del);
  b = getinfo(pointer+1);
  delay(del);
  c=a;
  c=c<<16;
  c|=b;
  // Serial.print(a,HEX);
  // Serial.print(b,HEX);
  // Serial.print(c,HEX);
  return(c);

}
void Config(byte addresse, byte val1, byte val2)
{
  Wire.beginTransmission(FDC);
  Wire.write(addresse);
  Wire.write(val1);
  Wire.write(val2);
  Wire.endTransmission();
  delay (del);

}

void loop()
{

  delay (100);
  while(num<4)
  {
    num1=0;
    MessConfval21=0;
    MessConfval22=0;
    MessConfval23=0;
    MessConfval24=0;
    while(num1<8)
    {

      unsigned long Mess1,Mess2,Mess3,Mess4;
      Config(MessConf1,MessConfval11,MessConfval21);
      Config(FDC_CONFIG,RegisterValue1,RegisterValue21);
      delay(10);
      Mess1=getdata(0x00);
      Config(MessConf2,MessConfval12,MessConfval22);
      Config(FDC_CONFIG,RegisterValue1,RegisterValue22);
      delay(10);
      Mess2=getdata(0x02);
      Config(MessConf3,MessConfval13,MessConfval23);
      Config(FDC_CONFIG,RegisterValue1,RegisterValue23);
      delay(10);
      Mess3=getdata(0x04);
      Config(MessConf4,MessConfval14,MessConfval24);
      Config(FDC_CONFIG,RegisterValue1,RegisterValue24);
      delay(10);
      Mess4=getdata(0x06);
      Mess1=Mess1/256;
      Mess2=Mess2/256;
      Mess3=Mess3/256;
      Mess4=Mess4/256;
      Serial.print("Messung: ");
      Serial.print(Mess1,DEC);
      Serial.print(" , ");
      Serial.print(Mess2,DEC);
      Serial.print(" , ");
      Serial.print(Mess3,DEC);
      Serial.print(" , ");
      Serial.println(Mess4,DEC);



      MessConfval21+=32;
      MessConfval22+=32;
      MessConfval23+=32;
      MessConfval24+=32;
      num1++;
    }
    MessConfval11++;
    MessConfval12++;
    MessConfval13++;
    MessConfval14++;
    num++;

  }

}

Ein weiterer Code ist von mir, wahrscheinlich nicht so gut. Ich habe allgemein den Offset leicht erhöht um zu sehen ob sich die HEX-Werte ändern, wenn man die Permittivität ändert. Beim Auflegen der Hand ändern sich die Werte. Leider können wir mit den "Werten" nichts aussagekräftiges anfangen. Ich hoffe ihr könnt uns hier helfen.

#include <Wire.h>
//I2C_SlaveAddress = B101000;
unsigned char MSB1;
unsigned char LSB1;
unsigned short shift;
byte FDCValue1 =B00000100;
byte FDCValue2 =B11110000; //nur MEAS_1 aktivieren
byte MessConfval11=B00010000;
byte MessConfval12=B00110000;
byte MessConfval13=B01010000;
byte MessConfval14=B01110000;
byte CAPDAC=B11100000;

void setup()
{
  Wire.begin();        // join i2c bus (address optional for master)
  Serial.begin(9600);  // start serial for output
}


void loop()
{
  //Measurement Configuration setting single-ended mode
  //CHA (positiv to GND) für CIN1 = b000
  Serial.print("MEAS");
  //Serial.print(wert);
  Serial.print(": ");
  Wirewrite(0x08,MessConfval11);
  Transmission();
  ReadMeasurementResult(0x00,0x01);
  Serial.print(",");
  Wirewrite(0x09,MessConfval12);
  Transmission();
  ReadMeasurementResult(0x02,0x03);
  Serial.print(",");
  Wirewrite(0x0A,MessConfval13);
  Transmission();
  ReadMeasurementResult(0x04,0x05);
  Serial.print(",");
  Wirewrite(0x0B,MessConfval14);
  Transmission();
  ReadMeasurementResult(0x06,0x07);
  Serial.println("");
}

int BitShiftCombine( unsigned char msb, unsigned char lsb)
{
  int shift;
  shift = msb;              //send msb to rightmost 8 bits
  shift = shift<<8;         //shift msb over to leftmost 8 bits
  shift |= lsb;             //logical OR keeps msb intact in combined and fills in                                                             //rightmost 8 bits
  return shift;
}

int ReadMeasurementResult(char MSB, char LSB)
{
  Wire.beginTransmission(80);
  Wire.write(MSB);
  Wire.endTransmission();
  Wire.requestFrom(80, 2);    
  MSB1 = Wire.read();    
  LSB1 = Wire.read();
  shift = BitShiftCombine(MSB1,LSB1); 
  Serial.print(shift,DEC);         
  delay(100);

  Wire.beginTransmission(80);
  Wire.write(LSB);
  Wire.endTransmission();
  Wire.requestFrom(80, 2);    
  MSB1 = Wire.read();    
  LSB1 = Wire.read();
  shift = BitShiftCombine(MSB1,LSB1); 
  //Serial.print(" ");
  Serial.print(shift,DEC);         
  delay(100);
}

void Wirewrite(char address,byte msb)
{
  Wire.beginTransmission(80);
  Wire.write(address);
  Wire.write(msb);
  Wire.write(CAPDAC);
  Wire.endTransmission();
  delay(100);
}

void Transmission()
{
  Wire.beginTransmission(80);
  Wire.write(0x0C);
  Wire.write(FDCValue1);
  Wire.write(FDCValue2);
  Wire.endTransmission();
  delay(100);
  Wire.requestFrom(80, 2);
  MSB1 = Wire.read();                 // receive MSB 
  LSB1 = Wire.read();
  shift = BitShiftCombine(MSB1,LSB1); //add MSB1 and LSB1
  delay(100);                        //wait 1 sec
}

Ich hoffe ihr könnt uns helfen und danke schon mal im Vorraus :grin:

Hello,

I am also using FDC1004 board for capacitance measurement.
In this board we have options to saving the configuration may be you can make offset there and use those configuration in your code...

if it works please let me know

Looking forward to hear from you

Hallo zusammen,

seit heute bin ich stolzer Besitzer eines
FDC1004 Eval Boards und darum natürlich
neugierig wie eure Erfahrungen sind.

Ich mag mich irren aber sind
die Result Register nicht 24bit breit?

Euer Code:

int ReadMeasurementResult(char MSB, char LSB)

speichert nur 16 bit oder hab ich was überlesen?