#include <Wire.h>
 
#define sht21address B1000000
#define sht21temp  B11110011
#define sht21humid B11110101
 
float readSHT21Temp() {
  Wire.beginTransmission(sht21address);
  Wire.write(sht21temp);   
  Wire.endTransmission();
  delay(100);
  Wire.requestFrom(sht21address, 3);
 
  byte msb = Wire.read();
  byte lsb = Wire.read();
  int t = (msb << 8) + lsb;
  int crc = Wire.read();
 
  float temperature = -46.85 + 175.72 * t / 65536.0;
  Serial.print("temperature:");
  Serial.println(temperature);
  return temperature;
}
 
float readSHT21Humidity() {
  Wire.beginTransmission(sht21address);
  Wire.write(sht21humid);
  Wire.endTransmission();
  delay(100);
  Wire.requestFrom(sht21address, 3);
 
  byte msb = Wire.read();
  byte lsb = Wire.read();
  int h = (msb << 8) + lsb;
  int crc = Wire.read();
 
  float humidity = -6 + 125 * h / 65536.0;
  Serial.print("humidity:");
  Serial.println(humidity);
  return humidity;
}
 
void setup() {
  Serial.begin(9600);
  while(!Serial); 
  Serial.println("---- I2C tutorial ----");
  Wire.begin();
}
 
void loop(){
  float temp = readSHT21Temp();
  float hum = readSHT21Humidity();
  delay(500);
}  

Run your application

To run your sketch on the LinkIt ONE development board, follow the instructions in the Create and run your first sketch of the Get Started with the LinkIt ONE Development Platform. You can then view the serial output data for temperature and humidity; open the Serial Monitor by clicking the button on the right upper corner of Arduino, as shown below, or open it from Tools menu by clicking Serial Monitor.

And you’ll see something similar to this, showing the temperature and pressure reading from the sensors.

Analyze the process

If you have a logic analyzer you might want to look in more detail at how your board interacts with the sensor — if you don’t have a logic analyzer the following section might still be of interest, you can jump straight to Receiving data from the sensor.

Connecting the logic analyzer and collecting waveforms

To acquiring waveforms through an analyzer — the analyzer used in this tutorial is the Saleae Logic16 USB Logic Analyzer but, these instructions should be similar for any analyzer:

1. Connect GND, CH0 and CH1 of the logic analyzer to GND, SDA and SCL respectively of the TPH board using an I2C cable, as shown below.

    
   

2. Run the sketch then launch the logic analyzer’s software.
3. Add a protocol analyzer from the Analyzers drop down menu for the I2C, as shown below.

   

4. In the top menu provide the sampling rate (250MSamples) and frequency (8MHz).
5. Click Start to observe the waveform behavior in the logic analyzer, as shown below.

   

The waveform shows that there are 9 sets of data captured (one set contains temperature and humidity data). The first set is captured at 6 seconds (you can find the timeline on the top of the waveform) and the last one at around 12 seconds. Since there is a  delay(500)  in the  loop()  function (see Add a loop() function ), there is a 0.5 second delay between every set of the captured data.

A closer look to a single set of data shows it took 0.224 seconds to read the set, as shown below.

Next, you can analyze the I2C communication step by step for temperature and humidity data.

Receiving data from the sensor

There is an eight step process to obtain the temperature (or humidity data) in a single cycle. Each cycle contains write and read sessions. This is the implementation detail of the process to collect the temperature data:

1. The master device sends a start signal to the slave device.

2. The master sends the slave’s I2C address with a Read/Write bit assigned to 0 to indicate to the slave that a write operation is wanted. The slave sends an ACK/NACK bit back to the master. The implementation of the steps using the I2C APIs is described below.

   Function

   Wire.beginTransmission(sht21address); // where sht21address is B1000000

   Description

   Master sends a begin signal. The slave accepts the signal as an SDA falling edge from high to low, when the SCL is on high. Next, it starts the transmission of the address bits. The master sends 1000000 bits to the slave. From the waveform, the first byte is 1000_0000, the left 7 bits are the address and the last bit is Read/Write bit (0 for write operation). After these bits are received by the slave, an ACK is sent from the slave to the master.

3. If the master receives an ACK, it sends the command to the slave device to request data from the slave’s register. Slave sends an ACK/NACK bit to the master.  The implementation of the step using the I2C APIs is described below:

   Function	Wire.write(sht21temp); // where sht21temp is B11110011
   Description	From the waveform, we can see that the byte sent to slave is 1111_0011, which asks the slave to send the data. And it receives an ACK signal.

4. The master sends a stop signal to end the write session. The implementation of the step using the I2C APIs is described below.

   Function	Wire.endTransmission();
   Description	Master ends the writing session by sending an end signal. The end signal is a SDA rising edge when the SCL is high, as marked with the red point as shown below.

   

   

5. The master sends another start signal to the slave to start a read session. The implementation of the step using the I2C APIs is described below.

   Function	Wire.requestFrom(sht21address, 3);
   Description	Function requestFrom() requests 3 bytes of data from the slave. Then it sends a start signal to the slave to write. Master sends 1000000_1_0 ( 1000000 is the slave address, 1 is the Write/Read bit that represents a read operation, 0 is the ACK signal from the slave). After that, the master receives data from the slave.

   

6. If the master receives an ACK, it resends the slave device’s address with a Read/Write bit assigned to 1 to indicate it’s a read operation and requests the slave to send data. The slave sends an ACK/NACK bit to the master.
7. If the master receives an ACK, the master begins to read data byte by byte from the slave.

8. The master sends a stop signal after data is successfully read. Then the master continues with the next cycle. The implementation of steps 6 to 8 is as follows:

   byte msb = Wire.read();
   byte lsb = Wire.read();
   int h = (msb << 8) + lsb;

   The  read()  method of Wire class reads a byte after  requestFrom()  is called. The values of  msb ,  lsb  and  crc  are  0110_0111 , 0010_0100 ,  1011_1001 . 

   int crc = Wire.read();

   The sketch calculates the temperature in degrees Celsius by concatenating the  msb  and  lsb  together, such as  0110_0111_ 0010_0100 . Converting the binary into decimal provides the value of 26404. Using the formula to calculate the temperature will provide the final value of 23.95C which is the first data shown on the serial monitor for the temperature.

   -46.85 + 175.72 * t / 65536.0 = 23.95 (where t is 26404)

   Once the bytes are properly received, the master sends a stop signal, marked with a red point, as shown in the last figure.

   To read the humidity data, the same steps are applied. Once the new cycle starts the humidity data is read, as shown below.
   and the final result is shown below:
   The  msb  and  lsb  bytes concatenate to become  0110_0000_1010_1110 . Converting to decimal provides the value of 24750. Applying the formula described in Reading the humidity data  will result in 41.21, which is the first humidity data shown on the Serial Monitor. 

   -6 + 125 * h / 65536.0 = 41.21%

Your next steps

This tutorial provides an example of I2C communication through the Wire library. There are also other third-party library options to support specific I2C devices. These libraries usually encapsulate methods provided by the Wire library and only expose easy-to-use methods to public. You can download your I2C device’s library and import it in your LinkIt SDK development board’s installation folder to be able to use the public methods of the library.

FAQ

Can LinkIt ONE development board act like a slave device?

No, it cannot. The LinkIt ONE development board can be only configured as a master. The behavior is different from Arduino boards that can be configured as both master and slave. Note the behavior of Wire.begin() method. In Arduino API, Wire.begin()means the LinkIt ONE development board connects to the I2C bus as a master, while Wire.begin(address) initiates the I2C bus as a slave with the I2C address specified in the parameter. Since the LinkIt ONE development board cannot be configured as a slave,Wire.begin(address) shouldn’t be used on LinkIt ONE development board, although there is no compilation error when using it. The parameter should always be empty when using the LinkIt ONE development board.