You may know that I played around a bit with the BMP085 barometric pressure sensor. Now I am proud to announce that the BMP085 barometric pressure sensor is available as breakout board in the Interactive Matter Shop.

The BMP085 Breakout Board is a limited offer. I just got some at hand and supplies last as long as supplies last and are gone after they are gone. They come completely pre-assembled and tested.

Related posts:

• Arduino & Barometric Pressure Sensor BMP085
• Interactive Matter goes Kit

Interactive Matter proudly present the first Interactive Matter SMT Kit
The Blinken Button! Head over to the shop to grab yours!

The Blinken Button is a kit for a 8×8 LED Matrix button (the jacket one). It is based on the Space Invaders Button you may already know. Get all the information on the product page.

History

The Blinken Button is a direct descendant of the Space Invaders Button. It is optimized to be an entry level SMT kit. It did not really work out to be total entry level, since all the electronics is behind the display, which makes it a great gift or fashion accessory, but if you made a mistake in soldering – there is no way to fix it (easily). So very intensive testing is needed. But if this is not your first kit and you already did some mistakes, you can handle it.
It is basically Arduino compatible. But it comes without the Arduino code out of the box. This is something that will be enabled quite soon.

The need for a name

Coming up with a name was the most complicated thing. I positively did not wanted to use the name Space Invaders Button. I do not want to fight with Atari or whoever got the name now.
Using then name 64 Pixels Button was something I tried and it really made it onto the PCB – but Alex had concerns that it interferes with his 64 Pixels project. And he was right.
So the name was Blinken Button. It is so for three reasons: First my girlfriend calls it like that anyway, second it is basically just some Blinkenlights and third it is a homage to the CCC Blinkenlights, I really enjoyed some years ago.

The Future

It will not stop here.

• First the Arduino compatibility will be explored. This will most probably work out with the current version with an software update.
• There is an USB version planned, with much more control for users who do not have an AVR programmer.

Thats all for now. So go over to the shop , join Interactive Matter in the grand shop opening and grab yours.

Related posts:

• Space Invaders Button
• 64 Pixels Roundup

Die deutsche Version gibt es nach dem Klick (und dann weiter unten).

This time it is all non-technical (technically not – but that starts to get complicated). To further encourage tinkering in Hamburg, Alex and I have established a regularly tinker drinkup every Thursday (nearly) at Saal II.

Currently it is a very cosy drinkup, just a few guests. Hopefully this will change. We post announcements with very short notice on Twitter via #palo_altona. If you want to join to discuss some tinker stuff or present your Arduino or tinker projects, just tell Alex or me and we will tell when the next #palo_altona takes place.

Und nun zur deutschen Version:

Um auch in Hamburg einen regelmäßige Austauch zu Arduino, Tinkern und Open Source Hardware zu etablieren haben Alex und ich ‘Palo Altona’ gegründet. Ein regelmäßiges, manchmal auch unregelmäßiges, Treffen, jeden Donnerstag, im Saal II in der Schanze. Gäste sind gerne willkommen!

Die Koordination erfolgt recht kurzfristig (leider bisher meist erst am selben Tag) über Twitter (#palo_atona). Meldet euch bei Alex oder mir und wir geben Bescheid ob und wann das nächste Treffen ist. Wir freuen uns über jeden Gast.

Und falls jemand eine bessere Idee zur Koordination hat, einfach in den Kommentare melden.

No related posts.

This is definitively the last post for this year. So I wish everybody Merry Christmas or whatever you want to celebrate and a pleasant & successful new year!

Even I stopped tinkering and went on to hacking cookies. Have fun & take care!

Related posts:

• Last year in electronics

Some days ago I wrote about noise with a LIS302DL accelerometer. There is obviously something wrong with my hardware. But before I get a new version out I need to implement some software filtering.

After some unsuccessful results with low pass filters I choose the Kalman Filter. The Kalman Filter involves an awful lot of complicated mathematics. But fortunately I just needed a simple one dimensional Kalman Filter without any driving information, which makes the filter much easier.

Implementing the Kalman Filter

If you check the Kalman Filter formulas, you will encounter a lot of complicated matrix and vector math. But after some research on the application domain for an LIS302DL accelerometer I found out that a simple one dimensional filter will do the job. The accelerometer puts out three dimensional acceleration data. But if you just want to get clean acceleration data from it all formulas simply deal with one dimension. So it was easier to use three different one dimensional Kalman filters. It all ended in a small set of formulas:

x = x
p = p + q;

k = p / (p + r);
x = x + k * (measurement – x);
p = (1 – k) * p;

The first two formulas represent the prediction of the Kalman Filter. And since there is no information about the driving forces it is very simple. The second three formulas calculate the measurement update. The variables are x for the filtered value,  q for the process noise, r for the sensor noise, p for the estimated error and k for the Kalman Gain. The state of the filter is defined by the values of these variables.

The filter is applied with each measurement and initialized with the process noise q, the sensor noise r, the initial estimated error p and the initial value x. The initial values for p is not very important since it is adjusted during the process. It must be just high enough to narrow down. The initial value for the readout is also not very important, since it is updated during the process.

But tweaking the values for the process noise and sensor noise is essential to get clear readouts.

Tweaking the Kalman Filter

The first results were less than ideal. So I decided to use processing and my good old LIS302DL breakout board to get some insight of the optimal values of the different parameters:

First I looked into the importance of the process noise q, starting by a very high value of 128 (which is the maximum output of the accelerometer):

You see there is nearly no difference between the filtered data (white) and the original data (grey) – since you just see the white line.
If you turn down the process noise, e.g. to a value of 4 things start to change:

If you look closely you see that the sensor data often overshoots the filtered value. The filtered value is pretty close to the real value, but is missing a lot of noise. For my application I needed a more static output, smoothing out nearly all of the noise, giving a clean an steady signal. So lets turn down the process noise value a bit more, e.g. something like 0.125:

Now we got a quite a clean signal from quite a noisy source. It lags a bit behind the real data, but that is not critical for my application. Compared to the amount of noise reduction it is still quite fast.
After this is set let’s play a bit around with the sensor noise r:
We start back at r=1:

As expected if we turn down the assumed noise of the sensor the Kalman filter ‘relies’ more on the sensor data and gives more noisy results. If we increase the noise factor of the sensor to 4 we get a more stable result again:

If we go up extreme and assume a noise level of 32 we get the expected steady result:

As expected the filtered value lags significantly behind the real measurement. But it is a much cleaner signal. But  it is questionable if this is still useful.

Implementing Kalman in C

Implementing this filter in C code (e.g. for an Arduino) is quite simple. First of all we define a state for a kalman filter:

typedef struct {
  double q; //process noise covariance
  double r; //measurement noise covariance
  double x; //value
  double p; //estimation error covariance
  double k; //kalman gain
} kalman_state;

Next we need a function to initialize the kalman filter:

kalman_state
kalman_init(double q, double r, double p, double intial_value)
{
  kalman_state result;
  result.q = q;
  result.r = r;
  result.p = p;
  result.x = intial_value;
 
  return result;
}

And a function to update the kalman state, by calculating a prediction and verifying that against the real measurement:

void
kalman_update(kalman_state* state, double measurement)
{
  //prediction update
  //omit x = x
  state->p = state->p + state->q;
 
  //measurement update
  state->k = state->p / (state->p + state->r);
  state->x = state->x + state->k * (measurement - state->x);
  state->p = (1 - state->k) * state->p;
}

What did we learn from this?

First of all the Kalman filter can be much easier to implement if the underlying model is simple. We had not several dimensions, nor different sensor data to combine. The results are pretty good, but it is a challenge to find the right values for the process and sensor noise. Instead of just coming up with some guesses for the values, they can of course be estimated, but than we have to live with the result of the estimation.

In the end it is a good, robust, simple filter (in one dimension).

I think that in lack of several sensors we throw out the most advantage of the filter to combine several sensor data to a combined result. I think going a bit more in this direction can lead to real interesting results.

Or is there a much easier filter to use for my problem, leading to better results?

Related posts:

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

As you probably know, I really like I2C sensors and especially the LIS302DL. But adding this accelerometer to your circuit is not as straight forward as I thought. But in the end I got it quite right.

It all started out with a 0.1µF ceramic capacitor. For good measure I put a ferrite bead in front. But this lead to terrible readouts. So I threw in a 10µF 0805 ceramic capacitor and a 4.7µF tantalum capacitor. It does not look nice, nor does it look terribly solid, but it works fine.
So read on, what my analysis of the situation is.
My original layout had just a small ferrite bead and a way too small capacitor. And this on a board hosting a ATmega168 and four alphanumeric displays, drawing from 0 to 300mA, from a step up voltage controller. Of course I had about 400µF decoupling capacitors on board, but the direct power supply of the LIS302DL had still about 0.1 Volts of noise on the power supply line. And the readouts were extremely noisy (>10%).

Not good.

Throwing in some capacitance was a good idea and reduced the noise by something like factor 2. But still it is very noisy. The LIS302DL datasheet suggest using at least a 10µF and a 0.1µF capacitor of different types (e.g. ceramic and tantalum) – I think it is just some minimum requirements. Proper voltage supply with as less noise as possible is a must.

So my next try will be:

• Redoing the complete layout so that the power supply of the LEDs is uses separate VCC and ground paths than the digital circuit.
• Redoing the same for both chips, so that I got some star like grounding and supply system. Or some carefully laid out power planes.
• Adding bigger ferrite beads in the supply line of the LEDs and both chips, so that each component has its own supply line with ferrite beads and capacitors, to reduce cross talk.
• Perhaps adding some LDO regulator to drive the digital circuitry from 3V instead of 3.3V to reduce the noise of the LEDs or power supply.

I alwayys thought good power supply design is just for audio stuff or other high quality applications, but I learned (the hard way) that you also need it for just some basic tinkering.

So off to the next design.

Related posts:

• Filtering Sensor Data with a Kalman Filter
• Arduino & LIS302DL

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 …

Update: For a limited time the BMP085 break out board is available in the Interactive Matter Shop.

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

Just another good example of ‘lesson learned’. I often use the very common CR2032 coin cell batteries to drive my circuits. Small, cheap, easy to get and there is a quite a range of good and cheap battery holders.

But recently I have tested an complete over the top design which pushed the poor little CR2032 far beyond its limits. Time to grab a few facts from the datasheet for further reference.

To get a good example I found a quite elaborate CR2032 datasheet from Duracell. I think other batteries behave quite similar to this.

The Issue

The general key fact of an CR2032 are obvious and quite easy to grab from the datasheet:

Voltage: 3V

Capacity: 240mAh (to 2.0V)

If you study the datasheet more closely you will see that the voltages drop sharply after it reaches 2.8V (after it has delivered about 170mAh).

ESR (Equivalent Series Resistor):about 18 to 20 Ohms.

The ESR (Equivalent Series Resistor) or IR (Internal Resistance) is quite flat up to 150mAh of capacitance – there it reaches about 20 Ohms. At 170mAh it reaches something like 30 Ohms. This is quite hefty. In comparison good capacitors have a series resistance from some Ohms to a fraction of an Ohm – so it is always good to put some (even electrolytic) capacitors in series with the battery. If you are concerned that switching on or of of your circuits discharges the battery to much by charging up the capacitors – there is a simple trick to prevent it: put the capacitors in front of the ‘on’ switch so that are always charged and will not charge after your circuit is switched on. The leakage current will be so small that it will be neglectable in most cases.

But if you want to calculate how much constant current you can draw from these batteries you have to use Ohm’s law:

V = R * I or I = V /R

If you take the later and say you want no voltage drop higher that 1.2 Volts – because after that your circuit reaches 1.8 Volts which makes your microcontroller most probably going brown out. Applying these with the ESR of 20 Ohms, you will get something like 60 mA you can draw by them (I = 1.2V/20Ohm). You if calculate more conservative and do not want to go below 2.8V – which gives you some 0.2 Volts head room  – you will only be able to draw 10 mA (I = 0.2V/20Ohm) – just enough for an LED. These calculations do not consider the voltage drop of the battery of its life time.

In the bottom line: If you use those batteries you have to consider the 20-30 Ohms series resistance. Especially if you draw some constant current (spikes can be easily removed using capacitors). Yo have to assume 170mAh as maximum capacitance because then the CR2032 reaches 2.8Volts and the ESR goes up to a whopping 30 Ohms – going up from there very steep. Because of the high ESR of the CR2032 you will most probably not be able to draw more than 20-30 mAh safely (as constant current).

Perhaps it is even better to get a boost converter to 3 or 3.3V – to suck out all the juice in the battery. This should should be good for the environment too. Or even better get rechargeable Lithium Cells.

So driving an RGB with an 5V boost op converter is impossible. At white (all three LEDs draw 20mA) it is 60mA current at 5V, considering a efficiency of 80% this will give you more than 120 mAh at 3.3V. Impossible or the CR2032. So my intended design will never work. I wish I had done those calculations before I designed it and not after I saw that the prototype does not work.

You live and learn!

Some Closer Look

As we see the higher the current is the more loss we get by the ESR of 20 Ohms. So the question is how much power we can get from an CR2032. If we want to draw the maximum amount of power over a short time we simply take the power:

P=V*I

And we know that the voltage is

v=3-20*I

And we get

P=(3-20*I)*I

If we create a little graph from it we get

So we see that the maximum is somewhere at 75mA and somwhere at 0,1125 Watts. Perhaps the real theoretical value is a bit off – but most real batteries will be a bit off too, so it is a good enough aproximation.

So that is somewhat consistent to our previous calculations to not exceed 80mA to avoid a too big voltage drop.

But how many energy can we draw from an CR2032? For this we simply calculate the watt hour of the battery:

e=P*t and t=0,24A/I

so we get

e=(0,24/I)*P

or

But this is not very astonishing. The less current you draw the less loss you got at the internal resistor. But I am unsure if there is this resistor, which burns energy to heat. But since the batteries get hot if you draw too much power you will get some loss. But I do not think that the loss is equal to a 20 Ohm resistor. But the main finding is clear – the more current you draw the more loss you have.

What to do?

From the comments I got the tip to put the lithium coin cells in series to get a higher coltage at the current draw. But this will enlarge the voltage swing at different current levels (from 6V at 0mA to 3V at 150mA). This can be dangerous for your circuit. A better approach would be to put the batteries in parallel to half the internal ESR – so you would still get 1.5 Volts at 150mA.

Of course to counter current spikes you should allways put sufficiently sized capacitors in parallel. Sufficiently sized depends on the level of current spikes and there time. Just check out how a Farad is defined and you can derrive the needed value (which is the product of voltage change and time).

But in most of my designs space is a rare good. So no parallel batteries and no big capacitor banks.

Something that could work is sucking the power with a boost converter to get a steady output voltage independent of the current draw. This would of course enhance the loss but at least we get the voltage we want at an expense of the efficiency. Right now the calculations are a bit too complicated for this evening. But updates will follow

Lets see how that works.

No related posts.

Unbelievable that this is just the first year of Interactive Matter. But still there happened a lot of things.

Lets have a look on what Interactive Matter has managed to achieve.

The Beginning

It all started with the little idea of having a ‘time replay device’. How was your Day Darling was born. It samples the light levels during the day and if you take in your hand it plays it back.

The first prototype was still a bit rough but functional:

But soon it evolved in perhaps the nicest PCB I have done yet:

The final ‘How was your Day Darling‘ was nice, but till a bit week. I think this is a project I have to come back to.

Gravitron

After the first success of How was your day darling I did something very dumb. After some beers I promised to create some Cylon/KITT like device in half a ping pong ball. Of course the concept got completely out of hand. After thinking how to switch it on I realized that the ‘easiest’ would be to include an accelerometer and detect motion. But if you have a accelerometer in it you can also play around with gravity, implement some minimalistic physics engine and implement a ‘air bubble’ with LEDs:

The original KITT-like animation was just used to indicate that the device is going to sleep. But this design ultimately got me to SMT. First of all it was hard to solder the ADXL accelerometer. So I bought an hot air rework station. And after that I was able to solder nearly any SMT device. Which is way cool.

Long Term Goal: Space Invaders Button

The idea for my Space Invaders Button is very old. I existed before I started with all this electronics stuff. I promised a friend of mine to get here some button for her jacket, displaying space invaders characters. I thought that it cannot be that easy. In the end it was more complicated than I thought- but at the end I was able to achieve it:

It was a great success, I must admit. People love it so much that I am currently working on a kit. So stay tuned and see what will be coming along. This design has still a lot of potential. It should be still able to use the LEDs as inputs (e.g. to detect touch or ambient light level). And there could also be some easier way to download custom animations on it. Another design which I have to revisit if I got some time.

µTVBG

The µTVBG was just some kind of SMT exercise. I questioned myself how small can you go tu build an TV-B-Gone clone. Ther result was quite nice. A working TV-B-Gone on approximate 2cm²:

Surely you will be able to make it smaller. Lets see how this evolves.

Whats coming up?

There are still a lot of projects in the pipeline. They rank from funny simple pranks to full scale product ideas. Of course all of them are in a much to early state to talk about. But stay tuned. They will be coming.

Another big issue right now is creating kits. Interactive Matter will offer solder-yourself SMT kits for all skill levels. But this topics needs some time too to evolve.

Related posts:

• Interactive Matter goes Kit

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.

Related posts:

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