{"id":771,"date":"2025-05-17T00:59:07","date_gmt":"2025-05-17T07:59:07","guid":{"rendered":"https:\/\/nuclearprojects.com\/blog\/?p=771"},"modified":"2025-05-19T22:46:29","modified_gmt":"2025-05-20T05:46:29","slug":"communicating-with-bmi088-using-i2c-and-spi","status":"publish","type":"post","link":"https:\/\/nuclearprojects.com\/blog\/communicating-with-bmi088-using-i2c-and-spi\/","title":{"rendered":"Communicating with BMI088 using I2C and SPI"},"content":{"rendered":"

I<\/strong>n my continued work with inertial sensors, specifically IMU’s for use in autonomous navigation systems, the latest sensor I’ve been using is the BMI088<\/strong> from Bosch. It’s well regarded for it’s ability to handle vibrations and is supposed to be well suited for robotics and drones. Onboard is a 3-axis accelerometer and 3-axis gyro. While they are on the same chip, they exist as two separate sensors, so communication with each must be handled individually with some uniqueness between the two. The IMU can handle both I2C and SPI protocols. This page aims mostly to keep track of notes for myself, but hopefully helpful to others as well (computer science + electrical engineering from the perspective of a mechanical engineer, oh joy!<\/span>)<\/em>.<\/p>\r\n

I2C<\/h1>\r\n

The first BMI088 breakout board I tried was the Grove board from Seeed Studios. It is configured for I2C only (no SPI connections).<\/p>\r\n

\"\"<\/a><\/p>\r\n

There are some good libraries for this, including ones from Seeed<\/a> and Bolder Flight Systems<\/a>. These provide a good option to get up and running. However, wanting to develop a better understanding of this IMU and the communication protocols, I began to write my down drivers, starting development in Arduino, then porting to STM32 (which I’m also learning).<\/p>\r\n

Physical connections are straight forward: Power, GND, SDA and SCL.<\/p>\r\n

BMI088 spec sheet, diagram for I2C:<\/p>\r\n

\r\n\r\n<\/p>\r\n

\"\"<\/a><\/figure>\r\n

\r\n\r\n<\/p>\r\n

 <\/p>\r\n

Communication works by the master<\/strong> (microcontroller) sending a message to the slave<\/strong> (BMI088) device and awaiting a reply. Each device connected to the I2C bus has it’s own address, which we must utilize in each communication. I think of the I2C bus (and similarly for SPI), as a neighborhood. The I2C bus (literal wires connecting to the SDA and SCL pins) is like the main street through the neighborhood. Each ‘house’ has an address. In this case, the ‘houses’ are the gyro and accelerometer sensors. Within each ‘house’ are a bunch of ‘rooms’, or in terms of the sensor, registers<\/em>, each having their own address. These addresses are generally represented in hexadecimal form (0x00<\/em>, 0x69<\/em>, etc.).<\/p>\r\n

\"\"<\/a><\/p>\r\n

 <\/p>\r\n

The registers<\/strong> are where all the sensor data and settings reside. As an example, if we wish to read the device ID from the gyro, we must send a message to the gyro that contains both the sensor address and the register address we’re interested in. These addresses are all outlined in the BMI088 data sheet. This is the register information for the gyro ID:<\/p>\r\n

\"\"<\/a><\/p>\r\n

We can see the register is at 0x00<\/em>. The reset value<\/strong>, or the default value at power-on is 0x0F<\/em>. Each register will have it’s own default setting. Some are read-only (such as the ID value above), others can be configured, such as the gyro range<\/em> shown here at register 0x0F<\/em>:<\/p>\r\n

\"\"<\/a><\/p>\r\n

The reset value for the gyro range is 0x00<\/em>, which corresponds to a default setting of +\/-2000 degrees\/second.<\/p>\r\n

Let’s look at a couple example code snippets for working with both of the registers presented above, starting with reading the chip ID<\/em> for the gyro. To refresh:<\/p>\r\n

Gyro address on I2C bus: 0x69<\/strong><\/p>\r\n

GYRO_CHIP_ID register: 0x00<\/strong><\/p>\r\n

\r\n
Arduino Code: <\/strong>(using Wire.h library)<\/div>\r\n
Wire.beginTransmission(0x69); \/\/ Start communication with device at address 0x69<\/span>
Wire.write(0x00); \/\/ Send the register address we're interested in (0x00)<\/span>
Wire.endTransmission(false); \/\/ use 'false' to retain control of bus<\/span>

Wire.requestFrom(0x69, 1); \/\/ requesting 1 byte from device at address 0x69<\/span>
uint8_t<\/span><\/strong> gyroID = Wire.read(); \/\/ read the byte (device ID)<\/span><\/pre>\r\n
\r\n
 <\/p>\r\n
Now, lets see how to write a value to the gyro. Specifically, let’s change the GYRO_RANGE from 2000 deg\/s to 500 deg\/s by changing the default register value from 0x00<\/em> to 0x02<\/em>.<\/p>\r\n
Arduino Code:<\/strong> (using Wire.h library)<\/p>\r\n
\r\n
Wire.beginTransmission(0x69); \/\/ Start communication with device at address 0x69<\/span>
Wire.write(0x0F); \/\/ Send the register address we're interested in (0x00)<\/span>
Wire.write(0x02); \/\/ Write the value 0x02 to the above specified register<\/span>
Wire.endTransmission();<\/pre>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n
 <\/p>\r\n
Taking this over to the STM32 environment (using STM32CubeIDE), to read the gyro rates for all 3 axis:<\/p>\r\n
\r\n
\r\n
#define<\/span><\/strong> GYRO_ADDR 0x69
#define<\/span><\/strong> GYRO_RATE_X_LSB_ADDR 0x02

<\/span><\/span><\/span><\/span><\/span>uint8_t<\/strong><\/span> sensorBuffer[6];
<\/span><\/span>
\/\/ Tell gyro we want gyro rate<\/span><\/span>
uint8_t<\/span><\/strong> buf[1] = { GYRO_RATE_X_LSB_ADDR };<\/span>
HAL_I2C_Master_Transmit(&hi2c1, GYRO_ADDR<<1, buf, 1, 200);<\/span>

\/\/ Request 6 bytes - the BMI088 will autoincrement the register address after each byte read
<\/span><\/span>\/\/ We must shift the sensor address over 1 bit (Arduino does this automatically)<\/span>
HAL_I2C_Master_Receive(&hi2c1, GYRO_ADDR<<1, sensorBuffer, 6, 500); \/\/ 500=timeout(ms)<\/span><\/span>

\/\/ Process gyro data<\/span>
for<\/span>(<\/span>int<\/span> i=0; i<3; i++){<\/span>
  uint8_t<\/span><\/strong> byteLSB, byteMSB;<\/span>
  int16_t<\/strong><\/span> twoByte;<\/span>

  byteLSB = sensorBuffer[i*2]; <\/span>\/\/ Pull bytes into their own variables so we can manipulate them<\/span>
  byteMSB = sensorBuffer[(i*2)+1];<\/span>

  twoByte = byteMSB << 8 | byteLSB; <\/span>\/\/ Combine both bytes<\/span>

  float<\/span> rate = twoByte \/ 16.384; <\/span>\/\/ (32768 \/ 2000deg\/s = 16.384) --- 32768 is largest signed number in 16-bit variable<\/span>

  gyro[i] = rate;<\/span>
 }<\/span><\/pre>\r\n<\/div>\r\n<\/div>\r\n
With regards to bit shifting the address on the STM32, this is because addresses are 7 bits long. You send the address plus the read\/write bit – for a total of 8 bits. The Arduino Wire library does this automatically, but we have to do this manually on the STM32.<\/p>\r\n
This diagram may be helpful to visualizing the address frame (7-bit address + 1-bit read\/write bit), from Texas instruments<\/a> (page 8).<\/em> Note that the MSB is sent first.<\/p>\r\n
 <\/p>\r\n
\"\"<\/a><\/p>\r\n
 <\/p>\r\n
\r\n
Important Notes:<\/strong><\/p>\r\n