At first glance, the differences between the ICM-20948 and the MPU-9250 are not great. If you have worked with my library for the MPU-9250, you will quickly get along with my library for ICM-20948.<\/p>\n
“Under the hood”, i.e. at register level, the differences are considerable. So, even if it seems otherwise – the creation of the library was more than a small modification of the MPU-9250 library.<\/p>\n\n
Features and specifications of the ICM-20948<\/h2>\n\n
The ICM-20948 is called the 9-axis sensor because it combines three sensors, each covering three axes. It is:<\/p>\n
- \n
- Accelerometer<\/strong>,<\/li>\n
- Gyroscope<\/strong>,<\/li>\n
- and magnetometer<\/strong>.<\/li>\n
- In addition, the ICM-20948 is equipped with a thermometer.<\/li>\n<\/ul>\n
Such combined sensors are often referred to as IMU for “Inertial Measurement Unit<\/a>“.<\/p>\n
I have already described how gyroscopes and an accelerometers work in my article about the MPU6050<\/a>. The magnetometer works based on the Hall effect. You find a good explanation here<\/a>.<\/p>\n
<\/p>\n
\n![\"ICM-20948](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/07\/ICM20948_module_small-626x1024.jpg\")
<\/a><\/figure>\n<\/div>\nThe main technical specifications of the ICM-20948 are:<\/p>\n
- \n
- Power supply (VDD)<\/strong>: 1.71 – 3.6 volts\n
- \n
- most modules do not have a voltage regulator<\/li>\n<\/ul>\n<\/li>\n
- VDDIO:<\/strong> 1.71 – 1.95 volts\n
- \n
- Tolerance range for I\/O pins<\/li>\n
- On the module on the right, VDDIO is connected to VDD.<\/li>\n<\/ul>\n<\/li>\n
- Communication via I2C<\/strong>, the addresses are:\n
- \n
- AD0 set to LOW: 0x68<\/li>\n
- AD0 set to HIGH: 0x69<\/li>\n<\/ul>\n<\/li>\n
- Communication via SPI <\/strong><\/li>\n
- Gyroscope<\/strong>:\n
- \n
- Ranges: +\/-250, +\/-500, +\/-1000, +\/-2000 \u00b0\/s<\/li>\n
- Data rate: 4.4 Hz – 9 kHz<\/li>\n<\/ul>\n<\/li>\n
- Accelerometer<\/strong>:\n
- \n
- Ranges: +\/- 2, +\/-4, +\/-8, +\/-16 g<\/li>\n
- Data rate: 4.5 Hz – 4.5 kHz<\/li>\n<\/ul>\n<\/li>\n
- Magnetometer<\/strong> (AK09916):\n
- \n
- Range: +\/- 4900 \u03bcT<\/li>\n
- max. data rate: 100 Hz<\/li>\n<\/ul>\n<\/li>\n
- FIFO<\/strong> (first in, first out) data storage: 512 \/ 4096 bytes<\/li>\n
- Interrupts<\/strong> (the ones I implemented): FIFO overflow, data ready, FSync and “wake-on-motion”<\/li>\n
- Integrated thermometer <\/li>\n<\/ul>\n
The ICM-20948 allows the control of up to five additional sensors via an auxiliary I2C interface. The measured values are stored in the registers of the ICM-20948 and read from there.<\/p>\n
The magnetometer is not really integrated into the ICM-20948. It has seperate registers and its own I2C address. You can only control it via the auxiliary interface just described. But don’t worry, you don’t have to deal with it because my library takes care for everything in the background.<\/p>\n
Further information can be found in the technical data sheetof the ICM-20948<\/a> and in the data sheet of the magnetometer AK09916<\/a>. You can read about the differences between the MPU-9250 and the ICM-20948 here<\/a>.<\/p>\n\n
Digital Motion Processor DMP<\/h3>\n\n
The ICM-20948 offers the possibility to process the data measured by it and other external sensors. That relieves the microcontroller. For this purpose, the ICM-20948 has the so-called Digital Motion ProcessorTM<\/sup>, DMP for short. However, the implementation of the DMP functions would be an effort for me that exceeds my capacities. I have already invested several dozen hours in developing the library. <\/p>\n\n
Controlling the ICM-20948 <\/h2>\n\n
Wiring<\/h3>\n\n
When it comes to the power supply, you must ensure that the ICM-20948 can only be operated with up to 3.6 volts. However, this only applies to VDD. The I\/O pins and VDDIO can only tolerate 1.71 – 1.95 volts. On some modules (such as the one shown above), VDDIO is implemented together with VDD on the VDD pin. In this case, you may only operate it with 1.71-1.95 volts and must use level shifters for both 5-volt and 3.3-volt boards. <\/p>\n
You won’t have these problems with the more expensive boards from Adafruit, SparkFun or Pimoroni, as they are already equipped with the appropriate level shifters.<\/p>\n
Connect the address pin AD0 to HIGH (1.71\u20131.95 V) or GND, depending on which address you want to use. In some example sketches I also use the interrupt pin INT, which I attached to the Arduino pin 2.<\/p>\n
Other pins, not used by me:<\/p>\n
- \n
- ADA and ACL are connections for other sensors that are controlled via the auxiliary I2C interface. I only implemented the auxiliary I2C interface for the magnetometer.<\/li>\n
- NCS is the chip select pin for SPI communication.<\/li>\n
- You can use FYSYNC as an external interrupt pin. I’ll have an example sketch for this later.<\/li>\n<\/ul>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/icm20948_i2c_circuit_arduino_nano-1024x521.webp\")
<\/a>ICM-20948, controlled by an Arduino Nano with 1.8 volt voltage regulator and TXS0108E level converter <\/figcaption><\/figure>\n\n Connection via SPI<\/h3>\n\n
I have also implemented faster control via SPI. You can find a sample sketch as part of the library. <\/p>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/icm20948_spi_circuit_arduino_nano-1024x602.webp\")
<\/a>SPI control of the ICM-20948 with Arduino Nano, 1.8 V voltage regulator, and TXS0108E level converter<\/figcaption><\/figure>\n\n ICM-20948, “version 2”<\/h3>\n\n
There are also modules with the suffix “Version 2”, “v2” or “v2.0”. They have voltage regulators that reduce the input voltage to 1.8 volts. Unfortunately, not all of them have the necessary level shifters for the digital pins. Here are two examples: <\/p>\n\n
![\"ICM-20948,](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/icm20948_version_2-1024x456.webp\")
<\/a>ICM-20948, “version 2”<\/figcaption><\/figure>\n The left module has four MOSFETs for the SDO, SDA, SCL and INT pins. As far as I can tell, the CS pin is unprotected. If you are using SPI, you will need to use a voltage divider. Or you can connect CS to GND if you are only operating one device with the SPI interface. <\/p>\n
The right module only has two MOSFETs, which are combined in the marked 6-pin IC. The MOSFETs handle the SDA and SCL levels. This means you can only use it with I2C. However, there is still a problem with INT. Its HIGH level is 1.8 volts, which is not necessarily interpreted as HIGH by the microcontroller. The ADO pin also appears to be unprotected. <\/p>\n\n
Introduction to the ICM20948_WE library <\/h2>\n\n
I tried some libraries, but I couldn’t really get excited about any of them. That’s why I wrote my own library, which you can find here<\/a> on GitHub. Alternatively, you can install it directly using the library manager of the Arduino IDE.<\/p>\n
The problem with the ICM-20948 is that it has an incredible number of setting options due to its 4 sensors plus I2C auxiliary interface. And although I haven’t implemented all the functions, my library includes fifty-nine public functions. To explain the use of these functions, I have provided the library with thirteen example sketches.<\/p>\n
I will now walk you through the example sketches, which is a pretty dry read. Maybe just try them out and come back here if you don’t understand something.<\/p>\n\n
Determine basic data with the ICM-20948<\/h2>\n\n
ICM20948_01_acceleration_data.ino<\/h3>\n\n
This first sketch is the one I go into most intensively. Much is repeated in the following sketches.<\/p>\n
Before I start, a comment about the data type “xyzFloat”. This is a structure (struct) consisting of three float values. I use xyzFloat for all data that has an x, y, and z component.<\/p>\n<\/p>\n
\n#include <Wire.h>\n#include <ICM20948_WE.h>\n#define ICM20948_ADDR 0x68\n\n\/* There are several ways to create your ICM20948 object:\n * ICM20948_WE myIMU = ICM20948_WE() -> uses Wire \/ I2C Address = 0x68\n * ICM20948_WE myIMU = ICM20948_WE(ICM20948_ADDR) -> uses Wire \/ ICM20948_ADDR\n * ICM20948_WE myIMU = ICM20948_WE(&wire2) -> uses the TwoWire object wire2 \/ ICM20948_ADDR\n * ICM20948_WE myIMU = ICM20948_WE(&wire2, ICM20948_ADDR) -> all together\n * ICM20948_WE myIMU = ICM20948_WE(CS_PIN, spi); -> uses SPI, spi is just a flag, see SPI example\n * ICM20948_WE myIMU = ICM20948_WE(&SPI, CS_PIN, spi); -> uses SPI \/ passes the SPI object, spi is just a flag, see SPI example\n *\/\nICM20948_WE myIMU = ICM20948_WE(ICM20948_ADDR);\n\nvoid setup() {\n \/\/delay(2000); \/\/ maybe needed for some MCUs, in particular for startup after power off\n Wire.begin();\n Serial.begin(115200);\n while(!Serial) {}\n \n if(!myIMU.init()){\n Serial.println(\"ICM20948 does not respond\");\n }\n else{\n Serial.println(\"ICM20948 is connected\");\n }\n\n \/* This is a method to calibrate. You have to determine the minimum and maximum \n * raw acceleration values of the axes determined in the range +\/- 2 g. \n * You call the function as follows: setAccOffsets(xMin,xMax,yMin,yMax,zMin,zMax);\n * The parameters are floats. \n * The calibration changes the slope \/ ratio of raw acceleration vs g. The zero point \n * is set as (min + max)\/2.\n *\/\n \/\/myIMU.setAccOffsets(-16330.0, 16450.0, -16600.0, 16180.0, -16640.0, 16560.0);\n \n \/* The starting point, if you position the ICM20948 flat, is not necessarily 0g\/0g\/1g for x\/y\/z. \n * The autoOffset function measures offset. It assumes your ICM20948 is positioned flat with its \n * x,y-plane. The more you deviate from this, the less accurate will be your results.\n * It overwrites the zero points of setAccOffsets, but keeps the correction of the slope.\n * The function also measures the offset of the gyroscope data. The gyroscope offset does not \n * depend on the positioning.\n * This function needs to be called after setAccOffsets but before other settings since \n * it will overwrite settings!\n * You can query the offsets with the functions:\n * xyzFloat getAccOffsets()\n * You can apply the offsets using:\n * setAccOffsets(xyzFloat yourOffsets)\n *\/\n Serial.println(\"Position your ICM20948 flat and don't move it - calibrating...\");\n delay(1000);\n myIMU.autoOffsets();\n Serial.println(\"Done!\"); \n \n \/* enables or disables the acceleration sensor, default: enabled *\/\n \/\/ myIMU.enableAcc(true);\n\n \/* ICM20948_ACC_RANGE_2G 2 g (default)\n * ICM20948_ACC_RANGE_4G 4 g\n * ICM20948_ACC_RANGE_8G 8 g \n * ICM20948_ACC_RANGE_16G 16 g\n *\/\n myIMU.setAccRange(ICM20948_ACC_RANGE_2G);\n \n \/* Choose a level for the Digital Low Pass Filter or switch it off. \n * ICM20948_DLPF_0, ICM20948_DLPF_2, ...... ICM20948_DLPF_7, ICM20948_DLPF_OFF \n * \n * IMPORTANT: This needs to be ICM20948_DLPF_7 if DLPF is used in cycle mode!\n * \n * DLPF 3dB Bandwidth [Hz] Output Rate [Hz]\n * 0 246.0 1125\/(1+ASRD) (default)\n * 1 246.0 1125\/(1+ASRD)\n * 2 111.4 1125\/(1+ASRD)\n * 3 50.4 1125\/(1+ASRD)\n * 4 23.9 1125\/(1+ASRD)\n * 5 11.5 1125\/(1+ASRD)\n * 6 5.7 1125\/(1+ASRD) \n * 7 473.0 1125\/(1+ASRD)\n * OFF 1209.0 4500\n * \n * ASRD = Accelerometer Sample Rate Divider (0...4095)\n * You achieve lowest noise using level 6 \n *\/\n myIMU.setAccDLPF(ICM20948_DLPF_6); \n \n \/* Acceleration sample rate divider divides the output rate of the accelerometer.\n * Sample rate = Basic sample rate \/ (1 + divider) \n * It can only be applied if the corresponding DLPF is not off!\n * Divider is a number 0...4095 (different range compared to gyroscope)\n * If sample rates are set for the accelerometer and the gyroscope, the gyroscope\n * sample rate has priority.\n *\/\n myIMU.setAccSampleRateDivider(10);\n}\n\nvoid loop() {\n xyzFloat accRaw;\n xyzFloat corrAccRaw;\n xyzFloat gVal;\n myIMU.readSensor();\n myIMU.getAccRawValues(&accRaw);\n myIMU.getCorrectedAccRawValues(&corrAccRaw);\n myIMU.getGValues(&gVal);\n float resultantG = myIMU.getResultantG(&gVal);\n\n \n Serial.println(\"Raw acceleration values (x,y,z):\");\n Serial.print(accRaw.x);\n Serial.print(\" \");\n Serial.print(accRaw.y);\n Serial.print(\" \");\n Serial.println(accRaw.z);\n\n Serial.println(\"Corrected raw acceleration values (x,y,z):\");\n Serial.print(corrAccRaw.x);\n Serial.print(\" \");\n Serial.print(corrAccRaw.y);\n Serial.print(\" \");\n Serial.println(corrAccRaw.z);\n\n Serial.println(\"g-values (x,y,z):\");\n Serial.print(gVal.x);\n Serial.print(\" \");\n Serial.print(gVal.y);\n Serial.print(\" \");\n Serial.println(gVal.z);\n\n Serial.print(\"Resultant g: \");\n Serial.println(resultantG);\n Serial.println(\"*************************************\");\n \n delay(1000);\n}<\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
Initialization and offsets<\/h4>\n\n
I have implemented several constructors. This allows you to pass the I2C address and\/or the I2C object. The latter is interesting if, for example, you want to use both I2C interfaces of an ESP32.<\/p>\n
The function
init()<\/code> first resets the ICM-20948 and writes default values to some registers.init()<\/code> returns “false” if the ICM-20948 does not answer, otherwise true.<\/p>\nIn the motionless state, only the acceleration due to gravity acts on the ICM-20948. If it is positioned flat (i.e. with its x,y plane), the g value should be zero for the x and y axes and one for the z axis. However, these values are more or less shifted. The function
autoOffsets()<\/code> measures the offset values which are subtracted from future measured values. However, it does not correct the slope.<\/p>\nautoOffsets()<\/code> works only then reliably,<\/p>\n- \n
- if the module lies flat with its x,y plane,<\/li>\n
- is not moved, and<\/li>\n
- the function is called as the first function in the setup (because it changes certain settings)<\/li>\n<\/ul>\n
Alternatively, you can use the function
setAccOffsets()<\/code>. It leads to less good results regarding the zero point, but it is more accurate at larger angles. In addition, it corrects the slope, and you do not have to position the module flat at program start.<\/p>\n\nOther settings <\/h4>\n\n
The function
setAccRange()<\/code> sets the range for the acceleration measurements.<\/p>\nTo control the data rate of the accelerometer, use the function
setAccSampleRateDivider(divider)<\/code>.<\/p>\n<\/p>\n<\/span> <\/span>
![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-71de542e43adb4511a5f68317d41b18e_l3.png\" "\\"Rendered")
<\/p>\n\n\n
However, this only works if the digital low pass filter (DLPF) is activated. With
setAccDLPF(level)<\/code> you enable the DLPF and select the level. The parameterICM20948_DLPF_OFF<\/code> disables the DLPF. The higher the level, the lower the noise. Only level 7 does not fit in this series in this respect. The disadvantage of strong noise reduction is reduced response time. This means that when the acceleration changes, it takes a while for the MPU9250 to output the correct value.<\/p>\nWith
enableAcc(true\/false)<\/code> you can switch the accelerometer on or off.<\/p>\n\nThe results<\/h4>\n\n
You can query the measured values with the following functions:<\/p>\n
- \n
readSensor()<\/code> reads the data registers in burst method (i.e. “in one go”) and writes the result to a buffer array.- \n
- Without a previous call of
readSensor()<\/code>, you will not get updated values.<\/li>\n<\/ul>\n<\/li>\ngetAccRawValues()<\/code> provides the raw values of the acceleration in the ICM-20948 data register.<\/li>\ngetCorrectedAccRawValues()<\/code> reads the raw values and corrects them for the offsets.<\/li>\ngetGValues()<\/code> provides the acceleration values in g (based on the corrected raw data).<\/li>\ngetResultantG(gValue)<\/code> calculates the resulting acceleration from a g-value triple, i.e. the absolute value of the sum of the three vectors.<\/li>\n<\/ul>\n<\/p>\n<\/span> <\/span>
![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-e415876d0493a2aebdb57079133d69fc_l3.png\" "\\"Rendered")
<\/p>\n\n\n
If only gravity acts on the ICM-20948, the resultant should always be 1. With the resultant function, you can easily measure accelerations without having to align the movement to one axis. Simply subtract 1 to compensate for gravity.<\/p>\n\n
The output of ICM20948_01_acceleration_data.ino<\/h4>\n\n
![\"ICM-20948](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/07\/output_acc_data.png\")
<\/a>Output of ICM20948_01_acceleration_data.ino<\/figcaption><\/figure>\n\n ICM20948_02_gyroscope_data.ino<\/h3>\n\n
Since you already know some functions, the explanation of the gyroscope sketch can be much shorter.<\/p>\n<\/p>\n
\n#include <Wire.h>\n#include <ICM20948_WE.h>\n#define ICM20948_ADDR 0x68\n\n\/* There are several ways to create your ICM20948 object:\n * ICM20948_WE myIMU = ICM20948_WE() -> uses Wire \/ I2C Address = 0x68\n * ICM20948_WE myIMU = ICM20948_WE(ICM20948_ADDR) -> uses Wire \/ ICM20948_ADDR\n * ICM20948_WE myIMU = ICM20948_WE(&wire2) -> uses the TwoWire object wire2 \/ ICM20948_ADDR\n * ICM20948_WE myIMU = ICM20948_WE(&wire2, ICM20948_ADDR) -> all together\n * ICM20948_WE myIMU = ICM20948_WE(CS_PIN, spi); -> uses SPI, spi is just a flag, see SPI example\n * ICM20948_WE myIMU = ICM20948_WE(&SPI, CS_PIN, spi); -> uses SPI \/ passes the SPI object, spi is just a flag, see SPI example\n *\/\nICM20948_WE myIMU = ICM20948_WE(ICM20948_ADDR);\n\nvoid setup() {\n \/\/delay(2000); \/\/ maybe needed for some MCUs, in particular for startup after power off\n Wire.begin();\n Serial.begin(115200);\n while(!Serial) {}\n \n if(!myIMU.init()){\n Serial.println(\"ICM20948 does not respond\");\n }\n else{\n Serial.println(\"ICM20948 is connected\");\n }\n\n Serial.println(\"Position your ICM20948 flat and don't move it - calibrating...\");\n delay(1000);\n myIMU.autoOffsets();\n Serial.println(\"Done!\"); \n \n \/* The gyroscope data is not zero, even if you don't move the ICM20948. \n * To start at zero, you can apply offset values. These are the gyroscope raw values you obtain\n * using the +\/- 250 degrees\/s range. \n * Use either autoOffsets or setGyrOffsets, not both.\n * You can query the offsets with the function:\n * xyzFloat getGyrOffsets()\n *\/\n \/\/myIMU.setGyrOffsets(-115.0, 130.0, 105.0);\n \n \/* enables or disables the gyroscope sensor, default: enabled *\/\n \/\/ myIMU.enableGyr(false);\n\n \/* ICM20948_GYRO_RANGE_250 250 degrees per second (default)\n * ICM20948_GYRO_RANGE_500 500 degrees per second\n * ICM20948_GYRO_RANGE_1000 1000 degrees per second\n * ICM20948_GYRO_RANGE_2000 2000 degrees per second\n *\/\n myIMU.setGyrRange(ICM20948_GYRO_RANGE_250);\n \n \/* Choose a level for the Digital Low Pass Filter or switch it off. \n * ICM20948_DLPF_0, ICM20948_DLPF_2, ...... ICM20948_DLPF_7, ICM20948_DLPF_OFF \n * \n * DLPF 3dB Bandwidth [Hz] Output Rate [Hz]\n * 0 196.6 1125\/(1+GSRD) \n * 1 151.8 1125\/(1+GSRD)\n * 2 119.5 1125\/(1+GSRD)\n * 3 51.2 1125\/(1+GSRD)\n * 4 23.9 1125\/(1+GSRD)\n * 5 11.6 1125\/(1+GSRD)\n * 6 5.7 1125\/(1+GSRD) \n * 7 361.4 1125\/(1+GSRD)\n * OFF 12106.0 9000\n * \n * GSRD = Gyroscope Sample Rate Divider (0...255)\n * You achieve lowest noise using level 6 \n *\/\n myIMU.setGyrDLPF(ICM20948_DLPF_6); \n \n \/* Gyroscope sample rate divider divides the output rate of the gyroscope.\n * Sample rate = Basic sample rate \/ (1 + divider) \n * It can only be applied if the corresponding DLPF is not OFF!\n * Divider is a number 0...255\n * If sample rates are set for the accelerometer and the gyroscope, the gyroscope\n * sample rate has priority.\n *\/\n \/\/myIMU.setGyrSampleRateDivider(10);\n}\n\nvoid loop() {\n xyzFloat gyrRaw; \n xyzFloat gyr;\n myIMU.readSensor();\n myIMU.getCorrectedGyrRawValues(&gyrRaw);\n myIMU.getGyrValues(&gyr);\n \n Serial.println(\"Raw gyroscope values (x,y,z):\");\n Serial.print(gyrRaw.x);\n Serial.print(\" \");\n Serial.print(gyrRaw.y);\n Serial.print(\" \");\n Serial.println(gyrRaw.z);\n\n Serial.println(\"Gyroscope values (x,y,z):\");\n Serial.print(gyr.x);\n Serial.print(\" \");\n Serial.print(gyr.y);\n Serial.print(\" \");\n Serial.println(gyr.z);\n Serial.println();\n\n delay(500);\n}<\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
Again, you can use the
autoOffsets()<\/code> function. The gyroscope should indicate zero or at least fluctuate around zero for all axes in the motionless state. However, you will notice some offset that is independent of the orientation. Alternatively, apply the values determined in the measuring range +\/-250 \u00b0\/s insetGyrOffsets()<\/code>. I’ll come back to that in the section of the calibration sketch.<\/p>\nYou activate the low-pass filter (DLPF) with
setGyrDLPF(value)<\/code> and set the level. Here, too, a stronger filter leads to reduced reaction speed. Level 7 is an exception in this respect.ICM20948_DLPF_OFF<\/code> disables the DLPF.<\/p>\nOther features:<\/p>\n
- \n
setGyrSampleRateDivider()<\/code> works similar to the accelerometer.<\/li>\nsetGyrRange()<\/code> defines the measuring range.<\/li>\nenableGyr(true\/false)<\/code> enables or disables the gyroscope.<\/li>\ngetGyrRawValues()<\/code> returns the currently available raw data.<\/li>\ngetCorrectedGyrRawValues()<\/code> subtracts the offsets from the raw data and returns the corrected data.<\/li>\ngetGyrValues()<\/code> provides the gyroscope data in degrees\/second, based on the corrected raw data.<\/li>\n<\/ul>\n\nThe output of ICM20948_02_gyroscope_data.ino<\/h4>\n\n
![\"ICM-20948](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/07\/output_gyr_data.png\")
<\/a>Output of ICM20948_02_gyroscope_data.ino<\/figcaption><\/figure>\n\n ICM20948_03_magnetometer.ino<\/h3>\n\n
The magnetometer (AK09916) behaves like a separate component. It has its own I2C address, own registers and must therefore be initialized separately. If you apply an I2C scanner to the ICM-20948, you won’t detect the magnetometer. The magnetometer is not directly accessible, it is behind the ICM-20948, so to speak. You control it via the auxiliary I2C interface described above, which is provided by the ICM-20948. However, you won’t notice any of this, as the library manages everything in the background.<\/p>\n<\/p>\n
\n#include <Wire.h>\n#include <ICM20948_WE.h>\n#define ICM20948_ADDR 0x68\n\n\/* There are several ways to create your ICM20948 object:\n * ICM20948_WE myIMU = ICM20948_WE() -> uses Wire \/ I2C Address = 0x68\n * ICM20948_WE myIMU = ICM20948_WE(ICM20948_ADDR) -> uses Wire \/ ICM20948_ADDR\n * ICM20948_WE myIMU = ICM20948_WE(&wire2) -> uses the TwoWire object wire2 \/ ICM20948_ADDR\n * ICM20948_WE myIMU = ICM20948_WE(&wire2, ICM20948_ADDR) -> all together\n * ICM20948_WE myIMU = ICM20948_WE(CS_PIN, spi); -> uses SPI, spi is just a flag, see SPI example\n * ICM20948_WE myIMU = ICM20948_WE(&SPI, CS_PIN, spi); -> uses SPI \/ passes the SPI object, spi is just a flag, see SPI example\n *\/\nICM20948_WE myIMU = ICM20948_WE(ICM20948_ADDR);\n\nvoid setup() {\n \/\/delay(2000); \/\/ maybe needed for some MCUs, in particular for startup after power off\n Wire.begin();\n Serial.begin(115200);\n while (!Serial) {}\n\n if (!myIMU.init()) {\n Serial.println(\"ICM20948 does not respond\");\n }\n else {\n Serial.println(\"ICM20948 is connected\");\n }\n\n if (!myIMU.initMagnetometer()) {\n Serial.println(\"Magnetometer does not respond\");\n }\n else {\n Serial.println(\"Magnetometer is connected\");\n }\n\n \/* You can set the following modes for the magnetometer:\n * AK09916_PWR_DOWN Power down to save energy\n * AK09916_TRIGGER_MODE Measurements on request, a measurement is triggered by \n * calling setMagOpMode(AK09916_TRIGGER_MODE)\n * AK09916_CONT_MODE_10HZ Continuous measurements, 10 Hz rate\n * AK09916_CONT_MODE_20HZ Continuous measurements, 20 Hz rate\n * AK09916_CONT_MODE_50HZ Continuous measurements, 50 Hz rate\n * AK09916_CONT_MODE_100HZ Continuous measurements, 100 Hz rate (default)\n *\/\n myIMU.setMagOpMode(AK09916_CONT_MODE_20HZ);\n \/\/ delay(50); \/\/ add a delay of 1000\/magRate to avoid first mag value being zero \n}\n\nvoid loop() {\n xyzFloat magValue; \/\/ x\/y\/z magnetic flux density [\u00b5T] \n myIMU.readSensor();\n myIMU.getMagValues(&magValue);\n\n Serial.println(\"Magnetometer Data in \u00b5Tesla: \");\n Serial.print(magValue.x);\n Serial.print(\" \");\n Serial.print(magValue.y);\n Serial.print(\" \");\n Serial.println(magValue.z);\n\n delay(1000);\n}\n<\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
Magnetometer settings<\/h4>\n\n
The magnetometer has a power-down mode, a trigger mode and four continuous modes. The continuous modes differ in data rate, namely 10, 20, 40 or 100 Hz. The mode is set with
setMagOpMode()<\/code>.<\/p>\nYou retrieve the measured values with
getMagValues()<\/code>. The result is output in microtesla. The function returns the values that are currently in the data buffer. Before that, you have to callreadSensor()<\/code> to update the data buffer with the latest sensor data.<\/p>\nIn trigger mode, a measurement is initiated with
setMagOpMode(AK09916_TRIGGER_MODE)<\/code>. If you choose this option, you must give the magnetometer enough time to perform the measurement and transmit the data to the ICM-20948 data registers.<\/p>\n\nThe output of ICM20948_03_magnetometer.ino<\/h4>\n\n
For the following output, I rotated the ICM-20948 flat in its x,y plane:<\/p>\n\n
![\"ICM20948](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/07\/output_mag_data.png\")
<\/a>Output of ICM20948_03_magnetometer.ino<\/figcaption><\/figure>\n\n In Central Europe, the magnetic flux density of the Earth’s magnetic field is about 20 microns in the horizontal and around 44 \u00b5T in the vertical (source: German Wikipedia). Accordingly, the difference between the maximum and minimum value for rotation in the horizontal or vertical should be 40 and 88 \u03bcT respectively. You probably won’t measure that values because:<\/p>\n
- \n
- Again, there are offsets.<\/li>\n
- You are probably measuring indoors, and depending on the construction of the building, the Earth’s magnetic field is shielded.<\/li>\n
- When measuring on a breadboard, the jumper cables and metal inside the breadboard will influence the measurements.<\/li>\n<\/ul>\n\n
ICM20948_04_calibration.ino<\/h3>\n\n
This sketch is designed to help you determine the offsets for the accelerometer and gyroscope. To do this, first set the lowest measuring range and the maximum low-pass filter. This ensures high resolution and low noise.<\/p>\n
For the offset determination of the accelerometer, turn the ICM-20948 slowly (!) around its axes and note the maximum and minimum raw values. It is best to have your elbows on the table when doing this, as any shaking will result in additional acceleration. You then use this data for the
setAccOffsets()<\/code> function. Internally, the offsets are determined from this. When you change the measuring range, the offsets are automatically adjusted. With this method you are no longer dependent on the level orientation of the ICM-20948 at program start. For the determination of precise small angles, however, I still recommend theautoOffsets()<\/code> function.<\/p>\nFor the gyroscope offsets you do not need to rotate the ICM-20948 because the offset is independent of the inclination. You apply the values for the x-, y- and z-axis as parameters in
setGyrOffsets()<\/code>.<\/p>\n<\/p>\n\n#include <Wire.h>\n#include <ICM20948_WE.h>\n#define ICM20948_ADDR 0x68\n\n\/* There are several ways to create your ICM20948 object:\n * ICM20948_WE myIMU = ICM20948_WE() -> uses Wire \/ I2C Address = 0x68\n * ICM20948_WE myIMU = ICM20948_WE(ICM20948_ADDR) -> uses Wire \/ ICM20948_ADDR\n * ICM20948_WE myIMU = ICM20948_WE(&wire2) -> uses the TwoWire object wire2 \/ ICM20948_ADDR\n * ICM20948_WE myIMU = ICM20948_WE(&wire2, ICM20948_ADDR) -> all together\n * ICM20948_WE myIMU = ICM20948_WE(CS_PIN, spi); -> uses SPI, spi is just a flag, see SPI example\n * ICM20948_WE myIMU = ICM20948_WE(&SPI, CS_PIN, spi); -> uses SPI \/ passes the SPI object, spi is just a flag, see SPI example\n *\/\nICM20948_WE myIMU = ICM20948_WE(ICM20948_ADDR);\n\nvoid setup() {\n \/\/delay(2000); \/\/ maybe needed for some MCUs, in particular for startup after power off\n Wire.begin();\n Serial.begin(115200);\n while(!Serial) {}\n \n if(!myIMU.init()){\n Serial.println(\"ICM20948 does not respond\");\n }\n else{\n Serial.println(\"ICM20948 is connected\");\n }\n\n \/* This is a method to calibrate. You have to determine the minimum and maximum \n * raw acceleration values of the axes determined in the range +\/- 2 g. \n * You call the function as follows: setAccOffsets(xMin,xMax,yMin,yMax,zMin,zMax);\n * The parameters are floats. \n * The calibration changes the slope \/ ratio of raw accleration vs g. The zero point is \n * set as (min + max)\/2.\n *\/\n myIMU.setAccOffsets(-16330.0, 16450.0, -16600.0, 16180.0, -16520.0, 16690.0);\n \n \/* The gyroscope data is not zero, even if you don't move the ICM20948. \n * To start at zero, you can apply offset values. These are the gyroscope raw values you obtain\n * using the +\/- 250 degrees\/s range. \n * Use either autoOffset or setGyrOffsets, not both.\n *\/\n myIMU.setGyrOffsets(-115.0, 130.0, 105.0);\n \n \/* ICM20948_ACC_RANGE_2G 2 g (default)\n * ICM20948_ACC_RANGE_4G 4 g\n * ICM20948_ACC_RANGE_8G 8 g \n * ICM20948_ACC_RANGE_16G 16 g\n *\/\n myIMU.setAccRange(ICM20948_ACC_RANGE_2G); \/\/ highest res for calibration\n \n \/* Choose a level for the Digital Low Pass Filter or switch it off. \n * ICM20948_DLPF_0, ICM20948_DLPF_2, ...... ICM20948_DLPF_7, ICM20948_DLPF_OFF \n * \n * IMPORTANT: This needs to be ICM20948_DLPF_7 if DLPF is used in cycle mode!\n * \n * DLPF 3dB Bandwidth [Hz] Output Rate [Hz]\n * 0 246.0 1125\/(1+ASRD) \n * 1 246.0 1125\/(1+ASRD)\n * 2 111.4 1125\/(1+ASRD)\n * 3 50.4 1125\/(1+ASRD)\n * 4 23.9 1125\/(1+ASRD)\n * 5 11.5 1125\/(1+ASRD)\n * 6 5.7 1125\/(1+ASRD) \n * 7 473.0 1125\/(1+ASRD)\n * OFF 1209.0 4500\n * \n * ASRD = Accelerometer Sample Rate Divider (0...4095)\n * You achieve lowest noise using level 6 \n *\/\n myIMU.setAccDLPF(ICM20948_DLPF_6); \/\/ lowest noise for calibration \n \n \/* ICM20948_GYRO_RANGE_250 250 degrees per second (default)\n * ICM20948_GYRO_RANGE_500 500 degrees per second\n * ICM20948_GYRO_RANGE_1000 1000 degrees per second\n * ICM20948_GYRO_RANGE_2000 2000 degrees per second\n *\/\n myIMU.setGyrRange(ICM20948_GYRO_RANGE_250); \/\/highest resolution for calibration\n \n \/* Choose a level for the Digital Low Pass Filter or switch it off. \n * ICM20948_DLPF_0, ICM20948_DLPF_2, ...... ICM20948_DLPF_7, ICM20948_DLPF_OFF \n * \n * DLPF 3dB Bandwidth [Hz] Output Rate [Hz]\n * 0 196.6 1125\/(1+GSRD) \n * 1 151.8 1125\/(1+GSRD)\n * 2 119.5 1125\/(1+GSRD)\n * 3 51.2 1125\/(1+GSRD)\n * 4 23.9 1125\/(1+GSRD)\n * 5 11.6 1125\/(1+GSRD)\n * 6 5.7 1125\/(1+GSRD) \n * 7 361.4 1125\/(1+GSRD)\n * OFF 12106.0 9000\n * \n * GSRD = Gyroscope Sample Rate Divider (0...255)\n * You achieve lowest noise using level 6 \n *\/\n myIMU.setGyrDLPF(ICM20948_DLPF_6); \/\/ lowest noise for calibration\n \n \/* Choose a level for the Digital Low Pass Filter. \n * ICM20948_DLPF_0, ICM20948_DLPF_2, ...... ICM20948_DLPF_7, ICM20948_DLPF_OFF \n * \n * DLPF Bandwidth [Hz] Output Rate [Hz]\n * 0 7932.0 9\n * 1 217.9 1125\n * 2 123.5 1125\n * 3 65.9 1125\n * 4 34.1 1125\n * 5 17.3 1125\n * 6 8.8 1125\n * 7 7932.0 9\n * \n * \n * GSRD = Gyroscope Sample Rate Divider (0...255)\n * You achieve lowest noise using level 6 \n *\/\n myIMU.setTempDLPF(ICM20948_DLPF_6); \/\/ lowest noise for calibration\n}\n\nvoid loop() {\n xyzFloat accRaw;\n xyzFloat gyrRaw;\n xyzFloat corrAccRaw;\n xyzFloat corrGyrRaw;\n xyzFloat gVal;\n myIMU.readSensor();\n myIMU.getAccRawValues(&accRaw);\n myIMU.getGyrRawValues(&gyrRaw);\n myIMU.getCorrectedAccRawValues(&corrAccRaw);\n myIMU.getCorrectedGyrRawValues(&corrGyrRaw);\n myIMU.getGValues(&gVal);\n \n Serial.println(\"Acceleration raw values without offset:\");\n Serial.print(accRaw.x);\n Serial.print(\" \");\n Serial.print(accRaw.y);\n Serial.print(\" \");\n Serial.println(accRaw.z);\n\n Serial.println(\"Gyroscope raw values without offset:\");\n Serial.print(gyrRaw.x);\n Serial.print(\" \");\n Serial.print(gyrRaw.y);\n Serial.print(\" \");\n Serial.println(gyrRaw.z);\n\n Serial.println(\"Acceleration raw values with offset:\");\n Serial.print(corrAccRaw.x);\n Serial.print(\" \");\n Serial.print(corrAccRaw.y);\n Serial.print(\" \");\n Serial.println(corrAccRaw.z);\n\n Serial.println(\"Gyroscope raw values with offset:\");\n Serial.print(corrGyrRaw.x);\n Serial.print(\" \");\n Serial.print(corrGyrRaw.y);\n Serial.print(\" \");\n Serial.println(corrGyrRaw.z);\n\n Serial.println(\"g-values, based on corrected raws (x,y,z):\");\n Serial.print(gVal.x);\n Serial.print(\" \");\n Serial.print(gVal.y);\n Serial.print(\" \");\n Serial.println(gVal.z);\n\n\n Serial.println(\"********************************************\");\n\n delay(500);\n}<\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
All together: ICM20948_05_acc_gyr_temp_mag_data.ino<\/h3>\n\n
Using this sketch, you can determine the acceleration, gyroscope values, magnetometer values and temperature. You query the temperature with
getTemperature()<\/code>. I have already explained all other functions. You can find the sketch in the examples.<\/p>\nThe thermometer is not so much used to measure the ambient temperature as to track the temperature in the ICM-20948. It is higher than the room temperature and increases in operation depending on the measurement conditions.<\/p>\n\n
The output of ICM20948_05_acc_gyr_temp_mag_data.ino<\/h4>\n\n
![\"The](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/07\/output_all_data.png\")
<\/a>The output of ICM20948_05_acc_gyr_temp_mag_data.ino<\/figcaption><\/figure>\n\n How to measure angles with the ICM-20948 <\/h2>\n\n
You can use the (earth) acceleration data to calculate tilt angles. You have to make sure that no additional acceleration acts on the ICM-20948. I have implemented two methods for this.<\/p>\n\n
ICM20948_06_angles_and_orientation.ino <\/h3>\n\n
With the method presented in this sketch, the angle \u03b1 between the axes and the horizontal is calculated quite simply from the arcussine of the acceleration value.<\/p>\n<\/p>\n
<\/span> <\/span>
![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-40230c45220cd74948b1272b34862579_l3.png\" "\\"Rendered")
<\/p>\n\n\n
For small angles this works perfectly, at larger angles the error increases. Why this is the case, I explained in my article about the MMA7361<\/a>. Up to 60\u00b0, the deviation in my experiments was less than one degree.<\/p>\n
For this sketch, I recommend to use
autoOffset()<\/code>. With this function, you start at an angle of 0\u00b0 for the x- and y-axis. For the z-axis you get a starting value around 90\u00b0. Since this is a large angle, the z-axis angle fluctuates strongly. For the tilt angles, you will only get reasonable values if you position the ICM-20948 flat for calibration.<\/p>\n<\/p>\n\n#include <Wire.h>\n#include <ICM20948_WE.h>\n#define ICM20948_ADDR 0x68\n\n\/* There are several ways to create your ICM20948 object:\n * ICM20948_WE myIMU = ICM20948_WE() -> uses Wire \/ I2C Address = 0x68\n * ICM20948_WE myIMU = ICM20948_WE(ICM20948_ADDR) -> uses Wire \/ ICM20948_ADDR\n * ICM20948_WE myIMU = ICM20948_WE(&wire2) -> uses the TwoWire object wire2 \/ ICM20948_ADDR\n * ICM20948_WE myIMU = ICM20948_WE(&wire2, ICM20948_ADDR) -> all together\n * ICM20948_WE myIMU = ICM20948_WE(CS_PIN, spi); -> uses SPI, spi is just a flag, see SPI example\n * ICM20948_WE myIMU = ICM20948_WE(&SPI, CS_PIN, spi); -> uses SPI \/ passes the SPI object, spi is just a flag, see SPI example\n *\/\nICM20948_WE myIMU = ICM20948_WE(ICM20948_ADDR);\n\nvoid setup() {\n \/\/delay(2000); \/\/ maybe needed for some MCUs, in particular for startup after power off\n Wire.begin();\n Serial.begin(115200);\n while(!Serial) {}\n \n if(!myIMU.init()){\n Serial.println(\"ICM20948 does not respond\");\n }\n else{\n Serial.println(\"ICM20948 is connected\");\n }\n\n \/* This is a method to calibrate. You have to determine the minimum and maximum \n * raw acceleration values of the axes determined in the range +\/- 2 g. \n * You call the function as follows: setAccOffsets(xMin,xMax,yMin,yMax,zMin,zMax);\n * The parameters are floats. \n * The calibration changes the slope \/ ratio of raw acceleration vs g. The zero point is \n * set as (min + max)\/2.\n *\/\n \/\/myIMU.setAccOffsets(-16330.0, 16450.0, -16600.0, 16180.0, -16520.0, 16690.0);\n \n \/* The starting point, if you position the ICM20948 flat, is not necessarily 0g\/0g\/1g for x\/y\/z. \n * The autoOffset function measures offset. It assumes your ICM20948 is positioned flat with its \n * x,y-plane. The more you deviate from this, the less accurate will be your results.\n * It overwrites the zero points of setAccOffsets, but keeps the correction of the slope.\n * The function also measures the offset of the gyroscope data. The gyroscope offset does not \n * depend on the positioning.\n * This function needs to be called after setAccOffsets but before other settings since \n * it will overwrite settings!\n * You can query the offsets with the function:\n * xyzFloat getAccOffsets()\n * You can apply the offset using:\n * setAccOffsets(xyzFloat yourOffsets)\n *\/\n Serial.println(\"Position your ICM20948 flat and don't move it - calibrating...\");\n delay(1000);\n myIMU.autoOffsets();\n Serial.println(\"Done!\"); \n \n \/* enables or disables the acceleration sensor, default: enabled *\/\n \/\/ myIMU.enableAcc(true);\n\n \/* ICM20948_ACC_RANGE_2G 2 g (default)\n * ICM20948_ACC_RANGE_4G 4 g\n * ICM20948_ACC_RANGE_8G 8 g \n * ICM20948_ACC_RANGE_16G 16 g\n *\/\n myIMU.setAccRange(ICM20948_ACC_RANGE_2G);\n \n \/* Choose a level for the Digital Low Pass Filter or switch it off. \n * ICM20948_DLPF_0, ICM20948_DLPF_2, ...... ICM20948_DLPF_7, ICM20948_DLPF_OFF \n * \n * IMPORTANT: This needs to be ICM20948_DLPF_7 if DLPF is used in cycle mode!\n * \n * DLPF 3dB Bandwidth [Hz] Output Rate [Hz]\n * 0 246.0 1125\/(1+ASRD) \n * 1 246.0 1125\/(1+ASRD)\n * 2 111.4 1125\/(1+ASRD)\n * 3 50.4 1125\/(1+ASRD)\n * 4 23.9 1125\/(1+ASRD)\n * 5 11.5 1125\/(1+ASRD)\n * 6 5.7 1125\/(1+ASRD) \n * 7 473.0 1125\/(1+ASRD)\n * OFF 1209.0 4500\n * \n * ASRD = Accelerometer Sample Rate Divider (0...4095)\n * You achieve lowest noise using level 6 \n *\/\n myIMU.setAccDLPF(ICM20948_DLPF_6); \n \n \/* Acceleration sample rate divider divides the output rate of the accelerometer.\n * Sample rate = Basic sample rate \/ (1 + divider) \n * It can only be applied if the corresponding DLPF is not off!\n * Divider is a number 0...4095 (different range compared to gyroscope)\n * If sample rates are set for the accelerometer and the gyroscope, the gyroscope\n * sample rate has priority.\n *\/\n myIMU.setAccSampleRateDivider(10);\n}\n\nvoid loop() {\n xyzFloat gValue;\n xyzFloat angle;\n myIMU.readSensor();\n myIMU.getGValues(&gValue);\n myIMU.getAngles(&angle);\n \n\/* For g-values the corrected raws are used *\/\n Serial.print(\"g-x = \");\n Serial.print(gValue.x);\n Serial.print(\" | g-y = \");\n Serial.print(gValue.y);\n Serial.print(\" | g-z = \");\n Serial.println(gValue.z);\n\n\/* Angles are also based on the corrected raws. Angles are simply calculated by\n angle = arcsin(g Value) *\/\n Serial.print(\"Angle x = \");\n Serial.print(angle.x);\n Serial.print(\" | Angle y = \");\n Serial.print(angle.y);\n Serial.print(\" | Angle z = \");\n Serial.println(angle.z);\n\n Serial.print(\"Orientation of the module: \");\n Serial.println(myIMU.getOrientationAsString());\n\n delay(1000);\n}<\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
The following functions are added here:<\/p>\n
- \n
getAngles()<\/code> returns the angle of the x, y, and z axes to the horizontal in degrees.\n- \n
- g-values above 1 are truncated to 1 because the arc sine function is not defined for larger values.<\/li>\n<\/ul>\n<\/li>\n
getOrientationAsString()<\/code> indicates which axis has the largest positive angle.\n- \n
- Possible return values are: x up, x down, y up, y down, z up, z down.<\/li>\n
- An alternative is
getOrientation()<\/code>. The return value is an enum (ICM20948_orientation). For the definition look in ICM20948_WE.h.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\nOutput of ICM20948_06_angles_and_orientation.ino<\/h4>\n\n
For the following output I have rotated the module around the y-axis, i.e. I have erected the x-axis.<\/p>\n\n
![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/07\/output_angles_and_orientation-1024x457.png\")
<\/a>Output of ICM20948_06_angles_and_orientation.ino<\/figcaption><\/figure>\n\n ICM20948_07_pitch_and_roll.ino<\/h3>\n\n
This method uses multiple axes to calculate the angles. As a result, the values are more accurate at large angles than with the simple arc sine method. On the other hand, at small angles, the latter method is preferable. To delineate the method, I used the nomenclature of other libraries and referred to the x-axis tilt angle as “pitch” and the y-axis tilt angle as “roll angle”. You can find a definition here<\/a>, for example.<\/p>\n<\/p>\n
<\/span> <\/span>
![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-fe5dff7e366ac98e2576b38fdf36d048_l3.png\" "\\"Rendered")
<\/p>\n\n<\/p>\n
<\/span> <\/span>
![\"\[](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/ql-cache\/quicklatex.com-9820af5f8281ad481115acad0b2fafcb_l3.png\" "\\"Rendered")
<\/p>\n\n\n
For comparison, I use both methods in this sketch. Try it out and choose what suits you more.<\/p>\n<\/p>\n
\n#include <Wire.h>\n#include <ICM20948_WE.h>\n#define ICM20948_ADDR 0x68\n\n\/* There are several ways to create your ICM20948 object:\n * ICM20948_WE myIMU = ICM20948_WE() -> uses Wire \/ I2C Address = 0x68\n * ICM20948_WE myIMU = ICM20948_WE(ICM20948_ADDR) -> uses Wire \/ ICM20948_ADDR\n * ICM20948_WE myIMU = ICM20948_WE(&wire2) -> uses the TwoWire object wire2 \/ ICM20948_ADDR\n * ICM20948_WE myIMU = ICM20948_WE(&wire2, ICM20948_ADDR) -> all together\n * ICM20948_WE myIMU = ICM20948_WE(CS_PIN, spi); -> uses SPI, spi is just a flag, see SPI example\n * ICM20948_WE myIMU = ICM20948_WE(&SPI, CS_PIN, spi); -> uses SPI \/ passes the SPI object, spi is just a flag, see SPI example\n *\/\nICM20948_WE myIMU = ICM20948_WE(ICM20948_ADDR);\n\nvoid setup() {\n \/\/delay(2000); \/\/ maybe needed for some MCUs, in particular for startup after power off\n Wire.begin();\n Serial.begin(115200);\n while(!Serial) {}\n \n if(!myIMU.init()){\n Serial.println(\"ICM20948 does not respond\");\n }\n else{\n Serial.println(\"ICM20948 is connected\");\n }\n\n \/* This is a method to calibrate. You have to determine the minimum and maximum \n * raw acceleration values of the axes determined in the range +\/- 2 g. \n * You call the function as follows: setAccOffsets(xMin,xMax,yMin,yMax,zMin,zMax);\n * The parameters are floats. \n * The calibration changes the slope \/ ratio of raw acceleration vs g. The zero point \n * is set as (min + max)\/2.\n *\/\n \/\/myIMU.setAccOffsets(-16330.0, 16450.0, -16600.0, 16180.0, -16520.0, 16690.0);\n \n \/* The starting point, if you position the ICM20948 flat, is not necessarily 0g\/0g\/1g for x\/y\/z. \n * The autoOffset function measures offset. It assumes your ICM20948 is positioned flat with its \n * x,y-plane. The more you deviate from this, the less accurate will be your results.\n * It overwrites the zero points of setAccOffsets, but keeps the correction of the slope.\n * The function also measures the offset of the gyroscope data. The gyroscope offset does not \n * depend on the positioning.\n * This function needs to be called after setAccsOffsets but before other settings since it will \n * overwrite settings!\n * You can query the offsets with the functions:\n * xyzFloat getAccOffsets() and xyzFloat getGyrOffsets()\n * You can apply the offsets using:\n * setAccOffsets(xyzFloat yourOffsets) and setGyrOffsets(xyzFloat yourOffsets)\n *\/\n Serial.println(\"Position your ICM20948 flat and don't move it - calibrating...\");\n delay(1000);\n myIMU.autoOffsets();\n Serial.println(\"Done!\"); \n \n \/* enables or disables the acceleration sensor, default: enabled *\/\n \/\/ myIMU.enableAcc(true);\n\n \/* ICM20948_ACC_RANGE_2G 2 g (default)\n * ICM20948_ACC_RANGE_4G 4 g\n * ICM20948_ACC_RANGE_8G 8 g \n * ICM20948_ACC_RANGE_16G 16 g\n *\/\n myIMU.setAccRange(ICM20948_ACC_RANGE_2G);\n \n \/* Choose a level for the Digital Low Pass Filter or switch it off. \n * ICM20948_DLPF_0, ICM20948_DLPF_2, ...... ICM20948_DLPF_7, ICM20948_DLPF_OFF \n * \n * IMPORTANT: This needs to be ICM20948_DLPF_7 if DLPF is used in cycle mode!\n * \n * DLPF 3dB Bandwidth [Hz] Output Rate [Hz]\n * 0 246.0 1125\/(1+ASRD) \n * 1 246.0 1125\/(1+ASRD)\n * 2 111.4 1125\/(1+ASRD)\n * 3 50.4 1125\/(1+ASRD)\n * 4 23.9 1125\/(1+ASRD)\n * 5 11.5 1125\/(1+ASRD)\n * 6 5.7 1125\/(1+ASRD) \n * 7 473.0 1125\/(1+ASRD)\n * OFF 1209.0 4500\n * \n * ASRD = Accelerometer Sample Rate Divider (0...4095)\n * You achieve lowest noise using level 6 \n *\/\n myIMU.setAccDLPF(ICM20948_DLPF_6); \n \n \/* Acceleration sample rate divider divides the output rate of the accelerometer.\n * Sample rate = Basic sample rate \/ (1 + divider) \n * It can only be applied if the corresponding DLPF is not off!\n * Divider is a number 0...4095 (different range compared to gyroscope)\n * If sample rates are set for the accelerometer and the gyroscope, the gyroscope\n * sample rate has priority.\n *\/\n \/\/myIMU.setAccSampleRateDivider(10);\n}\n\nvoid loop() {\n xyzFloat gValue;\n xyzFloat angle;\n myIMU.readSensor();\n myIMU.getGValues(&gValue);\n myIMU.getAngles(&angle);\n \n float pitch = myIMU.getPitch();\n float roll = myIMU.getRoll();\n \n Serial.println(\"G values (x,y,z):\");\n Serial.print(gValue.x);\n Serial.print(\" \");\n Serial.print(gValue.y);\n Serial.print(\" \");\n Serial.println(gValue.z);\n Serial.println(\"Angles (x,y,z):\");\n Serial.print(angle.x);\n Serial.print(\" \");\n Serial.print(angle.y);\n Serial.print(\" \");\n Serial.println(angle.z);\n\n Serial.print(\"Pitch = \"); \n Serial.print(pitch); \n Serial.print(\" | Roll = \"); \n Serial.println(roll); \n \n Serial.println();\n Serial.println();\n\n delay(1000);\n}<\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
Two new functions are used here:<\/p>\n
- \n
getPitch()<\/code> returns the pitch angle (x-axis).<\/li>\ngetRoll()<\/code> returns the roll angle (y-axis).<\/li>\n<\/ul>\n\nOutput of ICM20948_07_pitch_and_roll.ino<\/h4>\n\n
![\"ICM-20948](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/07\/output_pitch_and_roll.png\")
<\/a>Output of ICM20948_07_pitch_and_roll.ino<\/figcaption><\/figure>\n\n Outlook<\/h2>\n\n
- Without a previous call of
- Interrupts<\/strong> (the ones I implemented): FIFO overflow, data ready, FSync and “wake-on-motion”<\/li>\n
- Gyroscope<\/strong>:\n
- Gyroscope<\/strong>,<\/li>\n