In lack of any new projects (which are currently all in an very intermediate state) Interactive Matter presents yet another ‘how to connect a cool I2C sensor to Arduino’ post.

This time it is all about pressure. The BMP085 pressure sensor combines a absolute barometric pressure sensor (aka barometer) with an temperature sensor. It is build by Bosch Sensortec and intended to help GPS navigation units to detect their height above sea level. It combines the advantage of being quite cheap (~5$) and precise.

But of course there are myriads of other applications as well, like using it in a digital weather station, detecting the force of slammed doors or …

The information about this sensor is very sparse and Bosch is not very keen to give any information to makers. But fortunately Jeelabs offers it as an extension module for their Jeenode and published some very helpful code for it (which helped a lot – check out they are doing really amazing stuff).

Hardware

Hooking up the BMP085 to the Arduino works just like any other I2C part: Connect VCC to VCC and GND to GND, SCL goes to analogue pin 5, SDA to analogue pin4. Adding some pull up resistors (1K to 20K, most often something like 4.7K) between SDA, SCL and VCC finishes the setup (this was included in my breakout board).

The BMP08 accepts 1.8 to 3.6 Volts – so no chance to connect it directly to 5 Volts. The BMP085 has an additional EOC (end of conversion) pin indicating the successful data capture. This was connected to analogue pin 2 – but not used in the software implementation.

Software

Fortunately the code by Jeenode contained all the functionality, you need, taken directly from the datasheet. The only thing I added was the ability to use all oversampling modes (the BMP085 offers 4 oversampling mode, each on taking longer than the other and using more energy, but delivering more precise results).

First we need the ability to read 16 bit values from the BMP085 registers. Nearly all registers of the BMP085 are 16 bit wide:

int read_int_register(unsigned char r)
{
  unsigned char msb, lsb;
  Wire.beginTransmission(I2C_ADDRESS);
  Wire.send(r);  // register to read
  Wire.endTransmission();
 
  Wire.requestFrom(I2C_ADDRESS, 2); // read a byte
  while(!Wire.available()) {
    // waiting
  }
  msb = Wire.receive();
  while(!Wire.available()) {
    // waiting
  }
  lsb = Wire.receive();
  return (((int)msb<<8) | ((int)lsb));
}

Second you need a function to write a 8 bit register:

char read_register(unsigned char r)
{
  unsigned char v;
  Wire.beginTransmission(I2C_ADDRESS);
  Wire.send(r);  // register to read
  Wire.endTransmission();
 
  Wire.requestFrom(I2C_ADDRESS, 1); // read a byte
  while(!Wire.available()) {
    // waiting
  }
  v = Wire.receive();
  return v;
}

Now we can define some global variables to read the Eeprom calibration data:

//just taken from the BMP085 datasheet
int ac1;
int ac2;
int ac3;
unsigned int ac4;
unsigned int ac5;
unsigned int ac6;
int b1;
int b2;
int mb;
int mc;
int md;

void  bmp085_get_cal_data() {
  Serial.println("Reading Calibration Data");
  ac1 = read_int_register(0xAA);
  Serial.print("AC1: ");
  Serial.println(ac1,DEC);
  ac2 = read_int_register(0xAC);
  Serial.print("AC2: ");
  Serial.println(ac2,DEC);
  ac3 = read_int_register(0xAE);
  Serial.print("AC3: ");
  Serial.println(ac3,DEC);
  ac4 = read_int_register(0xB0);
  Serial.print("AC4: ");
  Serial.println(ac4,DEC);
  ac5 = read_int_register(0xB2);
  Serial.print("AC5: ");
  Serial.println(ac5,DEC);
  ac6 = read_int_register(0xB4);
  Serial.print("AC6: ");
  Serial.println(ac6,DEC);
  b1 = read_int_register(0xB6);
  Serial.print("B1: ");
  Serial.println(b1,DEC);
  b2 = read_int_register(0xB8);
  Serial.print("B2: ");
  Serial.println(b1,DEC);
  mb = read_int_register(0xBA);
  Serial.print("MB: ");
  Serial.println(mb,DEC);
  mc = read_int_register(0xBC);
  Serial.print("MC: ");
  Serial.println(mc,DEC);
  md = read_int_register(0xBE);
  Serial.print("MD: ");
  Serial.println(md,DEC);
}

The Eeprom readout can be done more efficiently by reading all the values with just one register write. But it is more comprehensible like this and in the initialization phase we have good amount of time.
The raw temperature (ut) and pressure (up) data can be readout as 16 bit and 24 bit value:

unsigned int bmp085_read_ut() {
  write_register(0xf4,0x2e);
  delay(5); //longer than 4.5 ms
  return read_int_register(0xf6);
}

long bmp085_read_up() {
  write_register(0xf4,0x34+(oversampling_setting<<6));
  delay(pressure_waittime[oversampling_setting]);
 
  unsigned char msb, lsb, xlsb;
  Wire.beginTransmission(I2C_ADDRESS);
  Wire.send(0xf6);  // register to read
  Wire.endTransmission();
 
  Wire.requestFrom(I2C_ADDRESS, 3); // read a byte
  while(!Wire.available()) {
    // waiting
  }
  msb = Wire.receive();
  while(!Wire.available()) {
    // waiting
  }
  lsb |= Wire.receive();
  while(!Wire.available()) {
    // waiting
  }
  xlsb |= Wire.receive();
  return (((long)msb<<16) | ((long)lsb<<8) | ((long)xlsb)) >>(8-oversampling_setting);
}

The conversion between the raw data and the real temperature data in 0.1 °C an Pascal is taken from the datasheet (combined with the corrections of Jeenodes):

void bmp085_read_temperature_and_pressure(int* temperature, long* pressure) {
  int  ut= bmp085_read_ut();
  long up = bmp085_read_up();
  long x1, x2, x3, b3, b5, b6, p;
  unsigned long b4, b7;
 
  //calculate the temperature
  x1 = ((long)ut - ac6) * ac5 >> 15;
  x2 = ((long) mc << 11) / (x1 + md);
  b5 = x1 + x2;
  *temperature = (b5 + 8) >> 4;
 
  //calculate the pressure
  b6 = b5 - 4000;
  x1 = (b2 * (b6 * b6 >> 12)) >> 11;
  x2 = ac2 * b6 >> 11;
  x3 = x1 + x2;
  b3 = (((int32_t) ac1 * 4 + x3)<> 2;
  x1 = ac3 * b6 >> 13;
  x2 = (b1 * (b6 * b6 >> 12)) >> 16;
  x3 = ((x1 + x2) + 2) >> 2;
  b4 = (ac4 * (uint32_t) (x3 + 32768)) >> 15;
  b7 = ((uint32_t) up - b3) * (50000 >> oversampling_setting);
  p = b7 < 0x80000000 ? (b7 * 2) / b4 : (b7 / b4) * 2;
 
  x1 = (p >> 8) * (p >> 8);
  x1 = (x1 * 3038) >> 16;
  x2 = (-7357 * p) >> 16;
  *pressure = p + ((x1 + x2 + 3791) >> 4);
 
}

Unfortunately temperature and pressure had to be computed at the same time (the temperature value is used for the pressure calculation). int* means a pointer to an integer value, which is written like *temperature = (b5 + 8 ) >> 4;. the function is called like

  int  temperature = 0;
  long pressure = 0;
 
  bmp085_read_temperature_and_pressure(&temperature,&pressure);

It is very simple and gives very good results.
If you want to try it yourself get the BMP085 Arduino Sketch. If there is any interest in the breakout board (assembled or unassembled) just drop me a note.

And big thanks to Jeelabs. Their code helped me a lot they real awesome stuff!

Related posts:

• BMP085 Barometric Pressure Sensor Breakout Boards arrived!
• Arduino & LIS302DL
• Arduino & AD7746

In my ongoing series about cool sensors Interactive Matter presents the AD7746 capacity sensor:

What is a capacity sensor good for? You can of course make a device to identify small capacitance (up to 4pF) but that’s boring. Much more interesting is how it reacts to touching.

Read on how to connect it to the Arduino and how to use it to sense touching

Fortunately there is a basic sketch how to use an AD7746 with Arduino. Unfortunately this sketch has one or two awkward structures and inconsistencies. Much more unfortunately it somehow works. So lets clean this thing a bit up.

I2C Basics

The I2C on Arduino uses analog pin 4 as SDA and analog pin 5 as SCL . With the Sparkfun AD7746 breakout board you need some pull up resistors for the I2C lines – So I added some 4.7k resistors to VCC (forgetting the pull up resistors is the most common source for an I2C connection not working – at least for me).

Connecting AD7746 to Arduino

The Sparkfun Ad7746 breakout board comes with two long lines to direct the sensing away from the logic and some ‘touch plate’. As you can see in the above photo you just connect the I2C pins, GND and VCC. Despite the marking ‘3.3V‘ on the breakout board the AD7746 accepts up to 5Volt as input voltage. So no special 3.3V voltage supply is needed.

The software part was a little more tricky. I used the AD7746 Arduino sketch I found and refactored it a bit. First of all I used my convenience extensions to read and write I2C registers conveniently (download the whole sketch – it is far too long to list here). Next we define our ADD7746 registers for convenience reasons:

#include <Wire.h>
 
//AD7746 definitions
#define I2C_ADDRESS  0x48 //0x90 shift one to the right
 
#define REGISTER_STATUS 0x00
#define REGISTER_CAP_DATA 0x01
#define REGISTER_VT_DATA 0x04
#define REGISTER_CAP_SETUP 0x07
#define REGISTER_VT_SETUP 0x08
#define REGISTER_EXC_SETUP 0x09
#define REGISTER_CONFIGURATION 0x0A
#define REGISTER_CAP_DAC_A 0x0B
#define REGISTER_CAP_OFFSET 0x0D
#define REGISTER_CAP_GAIN 0x0F
#define REGISTER_VOLTAGE_GAIN 0x11
 
#define RESET_ADDRESS 0xBF
 
#define CAP_ZERO 0x800000L

Now we can write a little startup routine to initialize the AD7746. It performs a reset (you never know), enables uses channel 1 for measuring capacitance and tries to calibrate the AD7746:

void setup()
{
  […]
  Serial.println("Initializing");
 
  Wire.beginTransmission(I2C_ADDRESS); // start i2c cycle
  Wire.send(RESET_ADDRESS); // reset the device
  Wire.endTransmission(); // ends i2c cycle
 
  //wait a tad for reboot
  delay(1);
 
  writeRegister(REGISTER_EXC_SETUP, _BV(3) | _BV(1) | _BV(0)); // EXC source A
 
  writeRegister(REGISTER_CAP_SETUP,_BV(7)); // cap setup reg - cap enabled
 
  Serial.println("Getting offset");
  offset = ((unsigned long)readInteger(REGISTER_CAP_OFFSET)) << 8;
  Serial.print("Factory offset: ");
  Serial.println(offset);
 
  writeRegister(0x0A, _BV(7) | _BV(6) | _BV(5) | _BV(4) | _BV(3) | _BV(2) | _BV(0));  // set configuration to calib. mode, slow sample
 
  //wait for calibration
  delay(10);
 
  displayStatus();
  Serial.print("Calibrated offset: ");
  offset = ((unsigned long)readInteger(REGISTER_CAP_OFFSET)) << 8;
  Serial.println(offset);
 
  […]
}

The calibration is a bit more tricky, later more on that. First we have to get an readout of the sensor:

long readValue() {
 long ret = 0;
 uint8_t data[3];
 
 char status = 0;
 //wait until a conversion is done
 while (!(status & (_BV(0) | _BV(2)))) {
 status= readRegister(REGISTER_STATUS);
 }
 
 unsigned long value =  readLong(REGISTER_CAP_DATA);
 
 value >>=8;
 //we have read one byte to much, now we have to get rid of it
 ret =  value;
 
 return ret;
}

It waits until an measurement has finished an reads the data value from the data register. The read routine returns a 32 bit long value. We just need the first three bytes, so we shift it one byte to the left. The datasheet specifies 0×800000 as null point, so we should subtract this value from readout. This was omitted here, since the datasheet also say that the value in REGISTER_CAP_OFFSET contains the real zero point after an calibration. So we just give back the value of REGISTER_CAP_OFFSET as offset. The content of REGISTER_CAP_OFFSET can be used in the external program logic (later more on that).

The AD7746 is not very nice to read from. The datasheet says, that you can write an address and then read as many bytes from the chip as you like. But not if you sent a STOP after you have written the address. But this is exactly what the Wire library does. So the readout routine (e.g. for Long values) looks a bit nasty since the address pointer is set back to 0:

unsigned long readLong(unsigned char r) {
  union {
    char data[4];
    unsigned long value;
  }
  byteMappedLong;
 
  byteMappedLong.value = 0L;
 
  Wire.beginTransmission(I2C_ADDRESS); // begin read cycle
  Wire.send(0); //pointer to first data register
  Wire.endTransmission(); // end cycle
  //the data pointer is reset anyway - so read from 0 on
 
  Wire.requestFrom(I2C_ADDRESS,r+4); // reads 2 bytes plus all bytes before the register
 
    while (!Wire.available()==r+4) {
      ; //wait
    }
  for (int i=r+3; i>=0; i--) {
    uint8_t c = Wire.receive();
    if (i<4) {
      byteMappedLong.data[i]= c;
    }
  }
 
  return byteMappedLong.value;
 
}

Now that we are getting some real values we can try to calibrate the chip. It comes factory calibrated, which is reset after each reset. First of all we try to perform an built in calibration:

void calibrate() {
  calibration = 0;
 
  Serial.println("Calibrating CapDAC A");
 
  long value = readValue();
 
  while (value>VALUE_UPPER_BOUND && calibration < 128) {
    calibration++;
    writeRegister(REGISTER_CAP_DAC_A, _BV(7) | calibration);
    value = readValue();
  }
  Serial.println("done");
}

After this i done we just switch over to continuous read mode, read out a value, print it with all calibration settings to the serial port:

  writeRegister(REGISTER_CAP_SETUP,_BV(7)); // cap setup reg - cap enabled
 
  writeRegister(REGISTER_EXC_SETUP, _BV(3)); // EXC source A
 
  writeRegister(REGISTER_CONFIGURATION, _BV(7) | _BV(6) | _BV(5) | _BV(4) | _BV(3) | _BV(0)); // continuous mode

void loop() // main program begins
{
 
  […]
 
  long value = readValue();
  Serial.print(offset);
  Serial.print("/");
  Serial.print((int)calibration);
  Serial.print("/");
  Serial.println(value);
 
  if ((valueVALUE_UPPER_BOUND)) {
    outOfRangeCount++;
  }
  if (outOfRangeCount>MAX_OUT_OF_RANGE_COUNT) {
    if (value < VALUE_LOWER_BOUND) {
      calibrate(-CALIBRATION_INCREASE);
    }
    else {
      calibrate(CALIBRATION_INCREASE);
    }
    outOfRangeCount=0;
  }
 
  delay(50);
}

The whole sketch contains a bit more code and can be much better understood if you got all the code – but that would be too much code for this post. So download the whole Arduino AD7746 Sketch and try it yourself.

Displaying the results

The results are displayed with an simple processing sketch, mimicking some kind of cheapo oscilloscope. It reads the values from the serial port and displays them. Anybody interested in the details of the sketch can download the whole AD7746 processing sketch.

The formula used to calculate the real capacitance is derrived by th datasheet:

capacitance = (value-calibration) * 2.44e-07-capdac*0.164;

I do not know if it completely perfect, but it gives some useful values, interestingly always smaller than 0 – despite the fact that the sensor should be calibrated to 0. For getting absolute capacitance readouts I suggest quadruple checking this to the datasheet and trying to optimize the adjustment of the sensor.

Leaving the sensor alone leads to some graphics like this:

As you can see we there is some noise present, we could filter out, but for now we live with it. It is not very strong. Especially if you compare it with the next graph.

If you tap on the sensing wires it gets a very strong readout – just by touching the two fine lines on the board:

This gives a much stronger readout (you can still see the noise – but that is very easy to distinct from the ‘signal’). This should be very easy to detect. If you look closer you will see that the readout does not really get back to the values just before touching the wires – It will go down slowly. So for detecting a signal it should be fairly easy to just compare the difference between two readouts and if it is bigger than some threshold it will interpreted as a ‘touch’.

If you use the touch pad, which comes with the AD7746 breakout board and touch the bare metal you get readout which is extremely strong – but that seems impractical because you would probably never you would never expose such big pads on your design, without some kind of coating.

But if you lay a cover of paper over the sensor you get still an extremely sharp signal:

The Bottom Line

In the end you see that the AD7746 is very interesting for creating some kind of hidden input elements. But it is some dificult part. The read routines are not really compatible with the wire library. Combing all the different possibilities to adjust the sensor and the complexity of calculationg the real value (the datasheet is a bit hard to understand on that topic) makes it very difficutl to tune the sensor optimally. But I hope that this material gives enough hints to use this sensor for a project. But nevertheless there are perhaps easier capacitive input sensors out there.

You can find the full source code over at github or directly download it from github.

Related posts:

• Arduino & LIS302DL
• Arduino & Barometric Pressure Sensor BMP085
• Tinkering with ADJD-S371-Q999

After I successfully shed some light its time to see some light. For this you normally use photo diodes, photo transistors or photo resistors. But there are two nice little detectors which I came across, special enough to post them here:

The Osram SFH 3710 and SFH 5711. Both are photo diodes respectively transistors adapted to the human eye sensitivity (V?). They are very insensitive in the infrared spectrum (typical for humans, untypical for photo detectors) and have a detection curve close to the human eye. But more details after the click.

SFH 3710

The SFH 3710 is more or less a very normal photo diode. Nothing special about it. It outputs something between 4 µA and 12 mA depending on the amount of light shining on the sensor. Unfortunately it has current output. So you need an sensing resistor to ground to get some voltage (you remember the law of Mr. Ohm).

But it hast two very special advantages:

1. It got a very nice 0805-like tiny SMT package. So it consumes very little board space.
2. But much more important it has a similar detection curve as the human eye.

The last point is very important (so I used it for may ‘How was your day darling‘ project). Normal photo detectors are very sensitive in the infrared spectrum, the humane eye is not. What is the effect? Artificial light (especially from normal light bulbs) have an high amount of infrared light and a low amount of visible light (One of the reasons for the inefficiency of light bulbs). For normal photo sensor the light of a light bulb seems to be as bright as daylight (figuratively spoken).

So if you want to detect light in the same way as it is perceived by an human the SFH 3710 is your friend. BTW: The SFH 3310 is the same detector in a more or less ‘normal’ T1 (3mm) LED package.

SFH 5711

The SFH 5711 is quite a different beast. It is an photo transistor. Nothing special about this. It also got an V? curve. Fine. But it is logarithmic. To understand the advantages of an logarithmic light sensor you have to understand how the human eye works:

The human eye interprets lights in logarithmic levels. If you see an light level X than 2*X will not appear twice as bright, X*X appears twice as bright. This enables the human eye to see things in a dark cave and bright sun light. To understand how light something appears to a human you have to apply the logarithmic scale.

This is exactly the work done by the SFH 5711. It outputs an current from 5 to 50 µA – depending on the light level. But it puts out about 10 µA per decade (of brightness). The details are a bit complex – but the result is quite easy: If the readout is quite as big the light will be interpreted as twice as bright by the human eye. So you get an more or less constant resolution over the whole spectrum of brightness – as perceived by the human eye. Very useful to adapt the brightness of a display according to the ambient light levels.

The disadvantage: The SFH 5711 contains an amplifier to get an readout – so you have to suplly VCC (from 2.3V to 5.5V) and GND. The sensor is bigger and needs a special footprint. In the end still very practical.

Related posts:

• How was your day: The first prototype

Ages ago I bought an LIS302DL from Sparkfun. One of the old (little bit) messed up ones, but still 3 axis accelerometer with I2C output. No external parts. No pain. Fine!

Before I go in any further investigation. I need to get it up & running with my arduino (actually an boarduino – but who cares?). Read all the nifty details after the break.

The hookup is very easy (but a little bit off standard) – remember we use I2C:

• VCC is connected to pin 13 – so you can power this from the arduino. But you should also be able to power it directly from VCC. Remember it was 3.3V
• GND is connected to GND – this was a bit obvious.
• SCL is connected to analog pin 5 (arduino’s I2C SCL)
• SCA is connect to analog pin 4 (arduino’s I2C SCA)
• MISO was tied to GND – in order to select the I2C address 28 – tie this to VCC and you got address 29 – if you want to use two LIS302DL – there is perhaps some reason for this – who knows?
• INT2 is connected to pin 2 – in order to be able to use the interrupt. I did not – who knows? Perhaps I will do it later

The basic setup was the same as with my ADJD experiments. A 3.3V breadboard and the same I2C-routines for reading and setting registers:

void writeRegister(unsigned char r, unsigned char v)
{
  Wire.beginTransmission(I2C_ADDRESS);
  Wire.send(r);
  Wire.send(v);
  Wire.endTransmission();
}
 
unsigned char readRegister(unsigned char r)
{
  unsigned char v;
  Wire.beginTransmission(I2C_ADDRESS);
  Wire.send(r);  // register to read
  Wire.endTransmission();
 
  Wire.requestFrom(I2C_ADDRESS, 1); // read a byte
  while(!Wire.available()) {
    // waiting
  }
  v = Wire.receive();
  return v;
}

First of all we power up the LIS302DL and initialize it:

void setupLIS() {
 
  Serial.println("Setting up LIS302DL");
 
  pinMode(LIS302_POWER_PIN, OUTPUT); //the power pin
  pinMode(LIS302_INT2_PIN, INPUT); //the int2 pin
 
  digitalWrite(LIS302_POWER_PIN,LOW); //switch off the LIS302
 
  Wire.begin();        // join i2c bus (address optional for master)
 
}
 
void startLIS() {
 
  Serial.println("Powering up LIS302DL");
  digitalWrite(LIS302_POWER_PIN,HIGH); //switch off the LIS302
 
  delay(POWER_UP_DELAY);
  writeRegister(CTRL_REG1 , _BV(CTRL_PD) | _BV(CTRL_XEN) | _BV(CTRL_YEN) | _BV(CTRL_ZEN));
 
  //read who am i
  char myself = readRegister(REGISTER_WHO_AM_I);
  if (myself == WHO_AM_I_RESULT) {
    Serial.println("yippie got an lis302DL!");
  } else {
    Serial.print("found an ");
    Serial.print(myself, HEX);
    Serial.println("! very strange!");
  }
}

The routine setupLIS() does the basic initialization while startLIS() does everything to power it up (I put it in two routines since I thought I would write an power down routine – but this did not happen until now).
Most of the magic is in the routine

  writeRegister(CTRL_REG1 , _BV(CTRL_PD) | _BV(CTRL_XEN) | _BV(CTRL_YEN) | _BV(CTRL_ZEN));

It stops internal power down (CTRL_PD), and enables all three axis for detection. After this is done I check if the LIS302DL does correctly report to ‘who am I’ – register 0x0f. This is more or less an sanity check (as you can see by the diagnostic output).
After you have down the right initialization magic the readout is an charm:

  char x = readRegister(X_OUT);
  char y = readRegister(Y_OUT);
  char z = readRegister(Z_OUT);

Right now I just read it out every 100ms – you could of courser do it in a more sophisticated way by waiting until new data is ready by watching the status registers or using interrupts. But there is always something better to do. Perhaps I will add it later.

And before you ask how to do it yourself: Check the source code!

Related posts:

• Arduino & Barometric Pressure Sensor BMP085
• Arduino & AD7746
• Decoupling LIS302DL – There I fixed it!

The ADJD breakout board by Sparkfun

The initial idea of “How was your day, darling” was to record the colors for a day. You know a morning is golden, evening is reddish, thunderstorm is greenish and so on. Measuring this with a simple RGB LED is a brave approach – but hard and cumbersome. So I ordered an ADJD-S371-Q999 color sensor breakout board from Sparkfun and played around with it.

Finding resource on this chip is very hard and getting it really working is much harder. Dealing with this complex topic is much more difficult than I thought. So I prepared some arduino code to get you started (after the break).

First of all: How to feed it? It takes voltages up to 3.6 volt. An USB Buarduino loves 5 volt. First I tried to take the 3V from the FTDI232R on the Boardino. Don’t try this at home. The 3.3V is go for 50mA but neither enough to power the whole Boardino, nor to power the color sensor or a RGB LED. The FTD232R got so hot that I thought I fried it – the Boardino and USB port acted quite weird. But it was just overheated.

The ADJD with Buardino on the breadboard

So I grabbed my 3.3V breadboard (see above, just a breadboard with some batteries, regulated down to 3.3V), disabled the Boardnio power supply, hooked up the I2C connection, enabled TWI in my sketch – and here we go:

The TWI/I2C uses the following ports on the Arduino:

• SCL – the serial clock – is connected to a5 (analog input 5)
• SDA – the serial data line – is connected to a5 (analog input 4)
• SLEEP was tied to GND
• LED was connected to pin 2
• XCLK – the external clock was left floating.

TWI can be enabled quite simple, just by including the header “wire.h”:

#include

Grab the data sheet, find some application note, read it and pretend to understand what you are doing. Fine. But how do I actually talk to that thing? Google! At the end I came up with a sketch in a thread on the Sparkfun Forums. It got everything to write. But reading was more or less random. Until I found out that the reading from the ADJD was like writing the adress of the register and waiting for the answer. Somewhere in the Internet I found a piece of code to use (if you know where, please leave a note in the comments – I would really like to give the correct credit. But I did not find it again.):

#include <Wire.h>
 
const int serialSpeed=9600;
int ledPin = 2;    // the light
 
//ADJD Settings
#define ADJD 0x74
 
#define CAP_RED 0x06
#define CAP_GREEN 0x07
#define CAP_BLUE 0x08
#define CAP_CLEAR 0x09
 
#define INT_RED_LO 0x0A
#define INT_RED_HI 0x0B
#define INT_GREEN_LO 0x0C
#define INT_GREEN_HI 0x0D
#define INT_BLUE_LO 0x0E
#define INT_BLUE_HI 0x0F
#define INT_CLEAR_LO 0x10
#define INT_CLEAR_HI 0x11
 
#define DATA_RED_LO 0x40
#define DATA_RED_HI 0x41
#define DATA_GREEN_LO 0x42
#define DATA_GREEN_HI 0x43
#define DATA_BLUE_LO 0x44
#define DATA_BLUE_HI 0x45
#define DATA_CLEAR_LO 0x46
#define DATA_CLEAR_HI 0x47
 
#define OFFSET_RED 0x48
#define OFFSET_GREEN 0x49
#define OFFSET_BLUE 0x4A
#define OFFSET_CLEAR 0x4B
 
void setup() {
  pinMode(ledPin, OUTPUT);  // declare the ledPin as an OUTPUT
  Serial.begin(serialSpeed);           // set up Serial library at 9600 bps
  Wire.begin();
  Serial.println("Sending Calibration data ... ");
  adjd_init();
  Serial.println("Calibration data sent. ");
}
 
void loop() {
  digitalWrite(ledPin,HIGH);
  read_register(DATA_RED_LO);
  digitalWrite(ledPin,LOW);
 
  delay(4000);
}
 
static void adjd_init()
{
  write_register(CAP_RED, 0x05);
  write_register(CAP_GREEN, 0x05);
  write_register(CAP_BLUE, 0x05);
  write_register(CAP_CLEAR, 0x05);
 
  write_register(INT_RED_LO, 0xC4);
  write_register(INT_RED_HI, 0x09);
  write_register(INT_GREEN_LO, 0xC4);
  write_register(INT_GREEN_HI, 0x09);
  write_register(INT_BLUE_LO, 0xC4);
  write_register(INT_BLUE_HI, 0x09);
  write_register(INT_CLEAR_LO, 0xC4);
  write_register(INT_CLEAR_HI, 0x09);
} 
 
void read_adjd_offset() {
}
 
static void write_register(uint8_t register_name, uint8_t register_value)
{
  Wire.beginTransmission(ADJD);
  Wire.send(register_name);
  Wire.send(register_value);
  Wire.endTransmission();
}
 
static uint8_t read_register(uint8_t register_name)
{
  Wire.beginTransmission(ADJD);
  Wire.send(register_name);
  Wire.endTransmission();
  Wire.requestFrom(ADJD,2);
  Serial.print("read:");
  while (Wire.available()&lt;1) {
    Serial.print(".");
  }
  int result = Wire.receive();
  Serial.println(result);
  return 0;
}

The routine for reading the register did the trick:

static uint8_t read_register(uint8_t register_name)
{
  Wire.beginTransmission(ADJD);
  Wire.send(register_name);
  Wire.endTransmission();
  Wire.requestFrom(ADJD,2);
  Serial.print("read:");
  while (Wire.available()>1) {
    Serial.print(".");
  }
  int result = Wire.receive();
  Serial.println(result);
  return 0;
}

That was a promising beginning! But the sketch did miss one big feature of the ADJD: It did not adapt to different light levels. I had to come up with a very clever idea how to calibrate it. The calibration was done adapting the integration time of the sensors to the light level. First for the clear channel (it is allays a bit more sensitive than the color levels):

int getClearGain() {
  int gainFound = 0;
  int upperBox=4096;
  int lowerBox = 0;
  int half;
  while (!gainFound) {
    half = ((upperBox-lowerBox)/2)+lowerBox;
    //no further halfing possbile
    if (half==lowerBox) {
      gainFound=1;
    }
    else {
      set_gain(REG_INT_CLEAR_LO,half);
      performMeasurement();
      int halfValue = get_readout(REG_DATA_CLEAR_LO);
 
      if (halfValue>1000) {
        upperBox=half;
      }
      else if (halfValue<1000) {
        lowerBox=half;
      }
      else {
        gainFound=1;
      }
    }
  }
  return half;
}

After this worked flawlessly the same trick was used to get the perfect color detection gain. According to the data sheet in both cases 1000 was used as target value (for the clear readout or the one of the colors).

int getColorGain() {
  int gainFound = 0;
  int upperBox=4096;
  int lowerBox = 0;
  int half;
  while (!gainFound) {
    half = ((upperBox-lowerBox)/2)+lowerBox;
    //no further halfing possbile
    if (half==lowerBox) {
      gainFound=1;
    }
    else {
      set_gain(REG_INT_RED_LO,half);
      set_gain(REG_INT_GREEN_LO,half);
      set_gain(REG_INT_BLUE_LO,half);
      performMeasurement();
      int halfValue = 0;
 
      halfValue=max(halfValue,get_readout(REG_DATA_RED_LO));
      halfValue=max(halfValue,get_readout(REG_DATA_GREEN_LO));
      halfValue=max(halfValue,get_readout(REG_DATA_BLUE_LO));
 
      if (halfValue>1000) {
        upperBox=half;
      }
      else if (halfValue<1000) {
        lowerBox=half;
      }
      else {
        gainFound=1;
      }
    }
  }
  return half;
}

Two small helper method were used to read or write the 16bit registers (and yes they could have been named better. The gain setting routine is this:

void set_gain(int gainRegister, int gain) {
  if (gain < 4096) {
    uint8_t hi = gain >> 8;
    uint8_t lo = gain;
 
    set_register(gainRegister, lo);
    set_register(gainRegister+1, hi);
  }

and the read routine is this:

int get_readout(int readRegister) {
  return read_register(readRegister) + (read_register(readRegister+1) << 8);
}

Now I was able to get perfect readouts from the chip. The next, quite complicated task was to calibrate the ADJD. The whole setup was again covered by a half table tennis ball. But somehow the internal LED of the ADJD was far to weak to illuminate table tennis ball. So I added a second (white) LED to get a bit more effect. The calibration was done adding capacitors from the measurement (anyone who read the datasheet knows what I mean): You can set the number of capacitors used during the measurement. Unfortunately the data sheet only tells that the more capacitor you use the lower readout you get. How the capacitors work or what they are remains unclear. Now matter. The sketch was just implemented that way:

• The white LED is lighted
• Each color is read and the capacitors are trimmed to get more or less the same readout from each color channel, this is repeated until the gap between the readouts do not get smaller (I know – I will come up with a better routine for this).
• The capacitor values are stored as defaults.

The sketch tries to keep the values as low as possible – since the drop between the clear and the color channels is high enough – this gives at least a comparable readout (for example if you use the same integration time for the clear and color values:

void calibrateChip() {
  calibrationRed = 0;
  calibrationBlue = 0;
  calibrationGreen = 0;
  byte calibrated = 0;
 
  //neede to store detect better calibration
  int oldDiff = 5000;
 
  while (!calibrated) {
    //enabled the white light
    digitalWrite(ledPin, HIGH);
    // calibrate the sensor
 
    // sensor gain setting (Avago app note 5330)
    // CAPs are 4bit (higher value will result in lower output)
    set_register(REG_CAP_RED, calibrationRed);
    set_register(REG_CAP_GREEN, calibrationGreen);
    set_register(REG_CAP_BLUE, calibrationBlue);
 
    int colorGain = getColorGain();
    set_gain(REG_INT_RED_LO,colorGain);
    set_gain(REG_INT_GREEN_LO,colorGain);
    set_gain(REG_INT_BLUE_LO,colorGain);
 
    int maxRead = 0;
    int minRead = 4096;
    int red=0;
    int green=0;
    int blue=0;
    for (int i=0; i<4 ;i ++) {
      performMeasurement();
      red +=get_readout(REG_DATA_RED_LO);
      green +=get_readout(REG_DATA_GREEN_LO);
      blue +=get_readout(REG_DATA_BLUE_LO);
    }
    red /=4;
    green /=4;
    blue /=4;
 
    maxRead = max (maxRead, red);
    maxRead = max (maxRead, green);
    maxRead = max (maxRead, blue);
 
    minRead = min(minRead, red);
    minRead = min(minRead, green);
    minRead = min(minRead, blue);
 
    int diff = maxRead - minRead;
 
    if (oldDiff != diff) {
      if ((maxRead==red) &&; (calibrationRed<15)) {
        calibrationRed++;
      }
      else if ((maxRead == green) && (calibrationGreen<15)) {
        calibrationGreen++;
      }
      else if ((maxRead == blue) && (calibrationBlue<15)) {
        calibrationBlue++;
      }
    }
    else {
      calibrated = 1;
    }
    oldDiff=diff;
 
    int rCal = calibrationRed;
    int gCal = calibrationGreen;
    int bCal = calibrationBlue;
 
    Serial.print("calibration :");
    Serial.print(diff);
    Serial.print(" r=");
    Serial.print(rCal);
    Serial.print("/");
    Serial.print(red);
    Serial.print(", g=");
    Serial.print(gCal);
    Serial.print("/");
    Serial.print(green);
    Serial.print(" b=");
    Serial.print(bCal);
    Serial.print("/");
    Serial.println(blue);
  }
 
  digitalWrite(ledPin, LOW);
}

The next step was to calibrate the RGB LED against the ADJD. If you send the same courrent to each color of the RGB LED you get some red result. Since the red LED normally is the most efficient. The least efficient LED is normally the blue one. So I developed a way to calibrate the different LED colors:

These routines use floating point variables, tis might not be the most efficient way – but the math was complex enough. In the end the calibration is calculated the following way:

float redFactor=1;
float blueFactor=1;
float greenFactor=1;
 
void calibrateRGB() {
  digitalWrite(redPin,HIGH);
  digitalWrite(bluePin,HIGH);
  digitalWrite(greenPin,HIGH);
  int ledGain = getColorGain();
  set_gain(REG_INT_RED_LO,ledGain);
  set_gain(REG_INT_GREEN_LO,ledGain);
  set_gain(REG_INT_BLUE_LO,ledGain);
  performMeasurement();
  int red=get_readout(REG_DATA_RED_LO);
  int green=get_readout(REG_DATA_GREEN_LO);
  int blue=get_readout(REG_DATA_BLUE_LO);
  digitalWrite(redPin,0);
  digitalWrite(bluePin,0);
  digitalWrite(greenPin,0);
  int m=2000; //bigger anyway
  m=min(m,red);
  m=min(m,green);
  m=min(m,blue);
  redFactor=((float)m*255.0)/(1000*(float)red);
  greenFactor=((float)m*255.0)/(1000*(float)green);
  blueFactor=((float)m*255.0)/(1000*(float)blue);
}

And the replay of the 10bit readouts goes like this:

  float rv = (float)red*redFactor;
  float gv = (float)green*greenFactor;
  float bv = (float)blue*blueFactor;
  int r = rv;
  int g = gv;
  int b = bv;
  analogWrite(redPin,r);
  analogWrite(bluePin,g);
  analogWrite(greenPin, b);

In the end it gives quite usefull results.

I tinkered around with it a bit further and got a complete working program: ADJD-S371. It contains a lot of rubbish and the organization of the code is less than perfect. But at least it gives a good overview of how it can be done.

Related posts:

• Arduino & LIS302DL
• Arduino & Barometric Pressure Sensor BMP085
• Arduino & AD7746