Real World Example in Working with I2C Sensor Device

Let’s take a look at what it takes to read sensor data from an I2C interface (aka I2C, IIC, TwoWire, TWI). In particular, we’ll be reading data from the NXP MPL3115A2 Altimeter/Barometer/Temperature sensor. The principles found in this guide can also be applied generically, even to your ambifacient lunar waneshaft positioning sensor of your turboencabulatorHome

Why I2C

I2C is a very popular goto for sensors because of its simplicity and expandability over other interfaces such as UART and SPI. Sparkfun, a Colorado based company which markets to the maker crowd, has a nicely written and friendly tutorial on I2C you should take a look at if you’re interested in more. For this article, it’s sufficient to say I2C has been winning the hearts of sensor manufacturers and has thus become very popular for complex, smart sensors.

Prototyping with MPL3115A2 Breakout Board

NXP’s MPL3115A2 sensor, with its tiny footprint, isn’t what you would call prototyping or breadboard friendly. Therefore, we’re going to be using a convenient, ready-made breakout board from Sparkfun (Part No. SEN-11084). The only assembly required is to add some breakaway headers for ultimate breadboard friendliness. If we were to go into production, we’d order the sensor direct from NXP and printing our own PCB daughter boards for use with our single board computer or module.

Pro Tip: There are many outfits like Sparkfun providing breakout boards to choose from, such as, seeedstudio, pololu, and trossen robotics just to name a few.

Hookup to a Single Board Computer

Now that we have the sensor, it’s obvious we need to connect it to something with an I2C interface to read the data. Most any single board computer or even microcontroller could do the job, but we’re going to reach for our handy TS-7970 high performance industrial SBC with WiFi and Bluetooth, since we have an IoT-like end goal in mind.

The MPL3115A2 breakout board requires no more than 3.3 VDC and a connection to SDA (I2C Data) and SCL (I2C Clock). There are two interrupt pins that can be used for things like events and triggers, but we’re not going to use those in this article. All of this is brought out on the header designated as HD3 on our TS-7970 (see section HD3 of the TS-7970 manual). This is what our prototype connections will look like:

When we’re all hooked up and powered on, the I2C interface is brought out to the Linux device file /dev/i2c-1 (See section TWI of the TS-7970 manual). This number might change depending on your system, so be sure to run i2cdetect -lto get a list of I2C interfaces on your board.

Note: We’re making a couple assumptions at this point. One is that you already know how to boot and connect to your board. If you’re following along with a TS-7970, you may want to take a look at the getting started guide. Another assumption we’re making is that you’re running Linux and have i2c-tools installed.

Programming the I2C Client

Official documentation for programming an I2C client in C can be found in the Linux Kernel in /i2c/dev-interface. We don’t have to be stuck using C though. You can reach for C++, Python, Java, or others. For this article, we’re going to work with C for learning purposes and because we know C is uber fast where hardware is involved.                             Home

Pro Tip: When researching how to interface with the MPL3115A2, I stumbled upon a fantastically convenient repository in the ControlEverything community that has working example code for Python, C, Java, and more. Take a look for yourself at the ControlEverythingCommunity/MPL3115A2 github repository.

Pro Tip: If you are interested in using Python, you’ll need to install python-smbus first.

Once we have a basic understanding of how to program for I2C from looking at examples and documentation, we need to dive into the specifics of our sensor using the MPL3115A2 datasheet. Luckily, NXP also provided a really nice application note, Data Manipulation and Basic Settings of the MPL3115A2 Command Line Interface Driver Code, which helps further our understanding of how to interface with this sensor. In section 11, “Quick start setup”, you’ll find a flowchart showing necessary steps to read altimeter data.

Pro Tip: Since we don’t plan on using the events to trigger an interrupt pin, you should be able to skip the step of enabling data flags in PT_DATA_CFG.

Sanity Check Using i2c-tools

Before we dive into C code, let’s test our connections and do some basic sanity checking using the tools included in i2c-tools, like i2cset, i2cget, and i2cdetect.

First, let’s use i2cdetect to both verify which device file and I2C slave address. By running i2cdetect -l, we see a list of i2c busses like so:

root@ts-imx6:~# i2cdetect -l
i2c-0   i2c             21a0000.i2c                             I2C adapter
i2c-1   i2c             21a4000.i2c                             I2C adapter

On our TS-7970, we know that /dev/i2c-0 is used internally to connect the FPGA with the RTC as mentioned in the manual, so that leaves us with /dev/i2c-1. We can then use that information to detect chips connected to /dev/i2c-1 by running i2cdetect -y 1, like so:

root@ts-imx6:~# i2cdetect -y 1
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- -- 
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
50: UU -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
60: 60 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
70: -- -- -- -- -- -- -- --

This tells us there is a i2c slave device detected at the 0x60 address. We’re on our way! Let’s try reading the register WHO_AM_I, which is defined as 0x0C. According to the datasheet, the value 0xC4 should be returned. Let’s see using i2cget -y 1 0x60 0x0C:

root@ts-imx6:~# i2cget -y 1 0x60 0x0C

Perfect! For now, let’s conclude our little sanity check. If you’re looking for some homework, you could manually step through the flowchart above using i2c-toolsto see what the raw data looks like. We’re going to move onto the C program.

The C Program

We’re going to make things easy on ourselves and use the ControlEverythingCommunity/MPL3115A2 example code as our base. This uses the same principles as taught in the official Linux i2c documentation and is well commented. Let’s take a look:

#include <stdio.h>
#include <stdlib.h>
#include <linux/i2c-dev.h>
#include <sys/ioctl.h>
#include <fcntl.h>

void main() 
    // Create I2C bus
    int file;
    char *bus = "/dev/i2c-1";
    if((file = open(bus, O_RDWR)) < 0) 
        printf("Failed to open the bus. \n");
    // Get I2C device, TSL2561 I2C address is 0x60(96)
    ioctl(file, I2C_SLAVE, 0x60);

    // Select control register(0x26)
    // Active mode, OSR = 128, altimeter mode(0xB9)
    char config[2] = {0};
    config[0] = 0x26;
    config[1] = 0xB9;
    write(file, config, 2);
    // Select data configuration register(0x13)
    // Data ready event enabled for altitude, pressure, temperature(0x07)
    config[0] = 0x13;
    config[1] = 0x07;
    write(file, config, 2);
    // Select control register(0x26)
    // Active mode, OSR = 128, altimeter mode(0xB9)
    config[0] = 0x26;
    config[1] = 0xB9;
    write(file, config, 2);

    // Read 6 bytes of data from address 0x00(00)
    // status, tHeight msb1, tHeight msb, tHeight lsb, temp msb, temp lsb
    char reg[1] = {0x00};
    write(file, reg, 1);
    char data[6] = {0};
    if(read(file, data, 6) != 6)
        printf("Error : Input/Output error \n");

    // Convert the data
    int tHeight = ((data[1] * 65536) + (data[2] * 256 + (data[3] & 0xF0)) / 16);
    int temp = ((data[4] * 256) + (data[5] & 0xF0)) / 16;
    float altitude = tHeight / 16.0;
    float cTemp = (temp / 16.0);
    float fTemp = cTemp * 1.8 + 32;

    // Select control register(0x26)
    // Active mode, OSR = 128, barometer mode(0x39)
    config[0] = 0x26;
    config[1] = 0x39;
    write(file, config, 2);

    // Read 4 bytes of data from register(0x00)
    // status, pres msb1, pres msb, pres lsb
    reg[0] = 0x00;
    write(file, reg, 1);
    read(file, data, 4);

    // Convert the data to 20-bits
    int pres = ((data[1] * 65536) + (data[2] * 256 + (data[3] & 0xF0))) / 16;
    float pressure = (pres / 4.0) / 1000.0;
    // Output data to screen
    printf("Pressure : %.2f kPa \n", pressure);
    printf("Altitude : %.2f m \n", altitude);
    printf("Temperature in Celsius : %.2f C \n", cTemp);
    printf("Temperature in Fahrenheit : %.2f F \n", fTemp);

Once you have this copy/pasted or downloaded to your board, you’re ready to compile and run it. Compiling is simply done using the command gcc mpl3115a2.c -o mpl3115a2. Running ./mpl3115a2will produce the altitude, pressure, and temperature:     Home

root@ts-imx6:~/projects/altimeter-sensor$ gcc mpl3115a2.c -o mpl3115a2
root@ts-imx6:~/projects/altimeter-sensor$ ./mpl3115a2 
Pressure : 85.36 kPa 
Altitude : 20623.69 m 
Temperature in Celsius : 23.56 C 
Temperature in Fahrenheit : 74.41 F

Sweet success! You could do like I did and immediately go check the pressure accuracy against your favorite weather website and the altitude against a GPS or terrain map. However, the point of celebration here is that we were able to successfully interact with an I2C sensor. Now, you should have the skills and know-how to apply to your specific I2C sensor project.

Take it a Step Further

We alluded to the subject of Internet of Things (IoT) earlier, so let’s expand on that. As mentioned, our TS-7970 has WiFi capabilities, and it also has the ability to run a full fledged web server. Meaning, we could take this a step further and periodically record our sensor data to a database and then display the data on a web page, both in real time and historical charts. You could also install node.js and develop a nice REST API, making it easy for others around the world to pull data from. The obvious use for this particular sensor is making a mini-weather station, but surely, you can come up with a more clever use.


In reading this article, you should’ve come away with a bunch of information on how to interface with an I2C sensor device. We started by looking at why I2C is a popular choice and pointed you towards a beginner-friendly I2C tutorial. Then, we looked at what it takes to begin prototyping with a real sensor, from buying a breakout board to referencing documentation for register addresses and doing sanity checks. Finally, we sank our teeth into some C code and came out with altitude, pressure, and temperature data. You should now feel comfortable in applying these development principles to your own sensor for your project. Now, go build something amazing!   Home

Leave a Reply

Your email address will not be published. Required fields are marked *