Merge branch 'release-candidate' into main

Author: PaulZC

examples/Example22-Tare/Example22-Tare.ino

@@ -0,0 +1,87 @@
+/*
+  Using the BNO080 IMU
+
+  Example : Tare function
+  By: Sofian Audry
+  Date: March 2nd, 2022
+
+  Based on: Example9-Calibrate
+  By: Nathan Seidle
+  SparkFun Electronics
+  Date: December 21st, 2017
+  SparkFun code, firmware, and software is released under the MIT License.
+	Please see LICENSE.md for further details.
+
+  Feel like supporting our work? Buy a board from SparkFun!
+  https://www.sparkfun.com/products/14586
+
+  This example shows how to use the tare functionalities.
+  It is best to run a calibration before using the tare functions.
+  
+  It takes about 1ms at 400kHz I2C to read a record from the sensor, but we are polling the sensor continually
+  between updates from the sensor. Use the interrupt pin on the BNO080 breakout to avoid polling.
+
+  Hardware Connections:
+  Attach the Qwiic Shield to your Arduino/Photon/ESP32 or other
+  Plug the sensor onto the shield
+  Serial.print it out at 115200 baud to serial monitor.
+*/
+#include <Wire.h>
+
+#include "SparkFun_BNO080_Arduino_Library.h" // Click here to get the library: http://librarymanager/All#SparkFun_BNO080
+BNO080 myIMU;
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.println();
+  Serial.println("BNO080 Read Example");
+
+  Wire.begin();
+
+  myIMU.begin();
+
+  Wire.setClock(400000); //Increase I2C data rate to 400kHz
+
+  //Enable Game Rotation Vector output
+  myIMU.enableRotationVector(100); //Send data update every 100ms
+
+  //Once magnetic field is 2 or 3, run the Save DCD Now command
+  Serial.println(F("'t' to tare according to xyz"));
+  Serial.println(F("'z' to tare according to z axis only"));
+  Serial.println(F("'s' to save tare settings"));
+  Serial.println(F("'r' to reset/clear tare orientation registry"));
+  Serial.println(F("Output in form x, y, z, in uTesla"));
+}
+
+void loop()
+{
+  if(Serial.available())
+  {
+    byte incoming = Serial.read();
+    
+    switch (incoming) {
+    case 't': myIMU.tareNow();     break;
+    case 'z': myIMU.tareNow(true); break;
+    case 's': myIMU.saveTare();    break;
+    case 'r': myIMU.clearTare();   break;
+    default:;
+    }
+  }
+
+  //Look for reports from the IMU
+  if (myIMU.dataAvailable() == true)
+  {
+    float roll = (myIMU.getRoll()) * 180.0 / PI; // Convert roll to degrees
+    float pitch = (myIMU.getPitch()) * 180.0 / PI; // Convert pitch to degrees
+    float yaw = (myIMU.getYaw()) * 180.0 / PI; // Convert yaw / heading to degrees
+
+    Serial.print(roll, 1);
+    Serial.print(F(","));
+    Serial.print(pitch, 1);
+    Serial.print(F(","));
+    Serial.print(yaw, 1);
+
+    Serial.println();
+  }
+}

examples/Example23-Gravity/Example23-Gravity.ino

@@ -0,0 +1,81 @@
+/*
+  Using the BNO085 for finding the direction of gravity.
+  By: Anant Sharma
+
+  Date: January 23rd, 2023
+  SparkFun code, firmware, and software is released under the MIT License.
+  Please see LICENSE.md for further details.
+  Feel like supporting our work? Buy a board from SparkFun!
+  https://www.sparkfun.com/products/14586
+  This example outputs a vector pointing towards the ground.
+
+  It takes about 1ms at 400kHz I2C to read a record from the sensor, but we are polling the sensor continually
+  between updates from the sensor. Use the interrupt pin on the BNO080 breakout to avoid polling.
+  
+  Hardware Connections:
+  Attach the Qwiic Shield to your Arduino/Photon/ESP32 or other
+  Plug the sensor onto the shield
+  
+  Serial.print it out at 9600 baud to serial monitor.
+*/
+
+#include <Wire.h>
+#include "SparkFun_BNO080_Arduino_Library.h" // Click here to get the library: http://librarymanager/All#SparkFun_BNO080
+BNO080 myIMU;
+
+
+
+void setup() {
+  Serial.begin(9600);
+  Serial.println();
+  Serial.println("BNO080 Read Example");
+
+  Wire.begin();
+
+    //Are you using a ESP? Check this issue for more information: https://github.com/sparkfun/SparkFun_BNO080_Arduino_Library/issues/16
+//  //=================================
+//  delay(100); //  Wait for BNO to boot
+//  // Start i2c and BNO080
+//  Wire.flush();   // Reset I2C
+//  IMU.begin(BNO080_DEFAULT_ADDRESS, Wire);
+//  Wire.begin(4, 5);
+//  Wire.setClockStretchLimit(4000);
+//  //=================================
+
+  if (myIMU.begin() == false)
+  {
+    Serial.println("BNO080 not detected at default I2C address. Check your jumpers and the hookup guide. Freezing...");
+    while (1);
+  }
+
+  Wire.setClock(400000); //Increase I2C data rate to 400kHz
+
+  myIMU.enableGravity(10); //Send data update every 50ms
+
+  Serial.println(F("Rotation vector enabled"));
+  Serial.println(F("Output in form i, j, k, real, accuracy"));
+
+}
+
+void loop() {
+    //Look for reports from the IMU
+  if (myIMU.dataAvailable() == true)
+  {
+    float gravityX = myIMU.getGravityX();
+    float gravityY = myIMU.getGravityY();
+    float gravityZ = myIMU.getGravityZ();
+    float gravityAccuracy = myIMU.getGravityAccuracy();
+
+    Serial.print(gravityX, 2);
+    Serial.print(F(","));
+    Serial.print(gravityY, 2);
+    Serial.print(F(","));
+    Serial.print(gravityZ, 2);
+    Serial.print(F(","));
+    Serial.print(gravityAccuracy, 2);
+    Serial.print(F(","));
+    
+
+    Serial.println();
+  }
+}

keywords.txt

@@ -40,6 +40,7 @@ enableARVRStabilizedGameRotationVector	KEYWORD2
 enableAccelerometer	KEYWORD2
 enableGyro	KEYWORD2
 enableUncalibratedGyro	KEYWORD2
+enableGravity KEYWORD2
 enableMagnetometer	KEYWORD2
 enableTapDetector	KEYWORD2
 enableStepCounter	KEYWORD2
@@ -85,6 +86,11 @@ getUncalibratedGyroBiasX	KEYWORD2
 getUncalibratedGyroBiasY	KEYWORD2
 getUncalibratedGyroBiasZ	KEYWORD2
 
+getGravity KEYWORD2
+getGravityX KEYWORD2
+getGravityY KEYWORD2
+getGravityZ KEYWORD2
+getGravityAccuracy KEYWORD2
 
 getFastGyro	KEYWORD2
 getFastGyroX	KEYWORD2

src/SparkFun_BNO080_Arduino_Library.cpp

@@ -417,6 +417,13 @@ uint16_t BNO080::parseInputReport(void)
 			calibrationStatus = shtpData[5 + 5]; //R0 - Status (0 = success, non-zero = fail)
 		}
 	}
+	else if(shtpData[5] == SENSOR_REPORTID_GRAVITY)
+	{
+		gravityAccuracy = status;
+		gravityX = data1;
+		gravityY = data2;
+		gravityZ = data3;
+	}
 	else
 	{
 		//This sensor report ID is unhandled.
@@ -761,6 +768,40 @@ uint8_t BNO080::getUncalibratedGyroAccuracy()
 	return (UncalibGyroAccuracy);
 }
 
+//Gets the full gravity vector
+//x,y,z output floats
+void BNO080::getGravity(float &x, float &y, float &z, uint8_t &accuracy)
+{
+	x = qToFloat(gravityX, gravity_Q1);
+	y = qToFloat(gravityX, gravity_Q1);
+	z = qToFloat(gravityX, gravity_Q1);
+	accuracy = gravityAccuracy;
+}
+
+float BNO080::getGravityX()
+{
+	float x = qToFloat(gravityX, gravity_Q1);
+	return x;
+}
+
+//Return the gravity component
+float BNO080::getGravityY()
+{
+	float y = qToFloat(gravityY, gravity_Q1);
+	return y;
+}
+
+//Return the gravity component
+float BNO080::getGravityZ()
+{
+	float z = qToFloat(gravityZ, gravity_Q1);
+	return z;
+}
+
+uint8_t BNO080::getGravityAccuracy()
+{
+	return (gravityAccuracy);
+}
 
 //Gets the full mag vector
 //x,y,z output floats
@@ -1185,6 +1226,12 @@ void BNO080::enableLinearAccelerometer(uint16_t timeBetweenReports)
 	setFeatureCommand(SENSOR_REPORTID_LINEAR_ACCELERATION, timeBetweenReports);
 }
 
+//Sends the packet to enable the gravity vector
+void BNO080::enableGravity(uint16_t timeBetweenReports)
+{
+	setFeatureCommand(SENSOR_REPORTID_GRAVITY, timeBetweenReports);
+}
+
 //Sends the packet to enable the gyro
 void BNO080::enableGyro(uint16_t timeBetweenReports)
 {
@@ -1300,6 +1347,21 @@ boolean BNO080::calibrationComplete()
 	return (false);
 }
 
+void BNO080::tareNow(bool zAxis, uint8_t rotationVectorBasis)
+{
+	sendTareCommand(TARE_NOW, zAxis ? TARE_AXIS_Z : TARE_AXIS_ALL, rotationVectorBasis);
+}
+
+void BNO080::saveTare()
+{
+	sendTareCommand(TARE_PERSIST);
+}
+
+void BNO080::clearTare()
+{
+	sendTareCommand(TARE_SET_REORIENTATION);
+}
+
 //Given a sensor's report ID, this tells the BNO080 to begin reporting the values
 void BNO080::setFeatureCommand(uint8_t reportID, uint16_t timeBetweenReports)
 {
@@ -1399,6 +1461,23 @@ void BNO080::sendCalibrateCommand(uint8_t thingToCalibrate)
 	sendCommand(COMMAND_ME_CALIBRATE);
 }
 
+void BNO080::sendTareCommand(uint8_t command, uint8_t axis, uint8_t rotationVectorBasis)
+{
+	for (uint8_t x = 3; x < 12; x++) //Clear this section of the shtpData array
+		shtpData[x] = 0;
+
+	shtpData[3] = command;
+	
+	if (command == TARE_NOW)
+	{
+		shtpData[4] = axis; // axis setting
+		shtpData[5] = rotationVectorBasis; // rotation vector
+	}
+	
+	//Using this shtpData packet, send a command
+	sendCommand(COMMAND_TARE);
+}
+
 //Request ME Calibration Status from BNO080
 //See page 51 of reference manual
 void BNO080::requestCalibrationStatus()
@@ -1768,4 +1847,4 @@ void BNO080::printHeader(void)
 		}
 		_debugPort->println();
 	}
-}
+}

src/SparkFun_BNO080_Arduino_Library.h

@@ -123,6 +123,20 @@ const byte CHANNEL_GYRO = 5;
 #define CALIBRATE_ACCEL_GYRO_MAG 4
 #define CALIBRATE_STOP 5
 
+#define TARE_NOW 0
+#define TARE_PERSIST 1
+#define TARE_SET_REORIENTATION 2
+
+#define TARE_AXIS_ALL 0x07
+#define TARE_AXIS_Z   0x04
+
+#define TARE_ROTATION_VECTOR 0
+#define TARE_GAME_ROTATION_VECTOR 1
+#define TARE_GEOMAGNETIC_ROTATION_VECTOR 2
+#define TARE_GYRO_INTEGRATED_ROTATION_VECTOR 3
+#define TARE_AR_VR_STABILIZED_ROTATION_VECTOR 4
+#define TARE_AR_VR_STABILIZED_GAME_ROTATION_VECTOR 5
+
 #define MAX_PACKET_SIZE 128 //Packets can be up to 32k but we don't have that much RAM.
 #define MAX_METADATA_SIZE 9 //This is in words. There can be many but we mostly only care about the first 9 (Qs, range, etc)
 
@@ -156,6 +170,7 @@ class BNO080
 	void enableARVRStabilizedGameRotationVector(uint16_t timeBetweenReports);
 	void enableAccelerometer(uint16_t timeBetweenReports);
 	void enableLinearAccelerometer(uint16_t timeBetweenReports);
+	void enableGravity(uint16_t timeBetweenReports);
 	void enableGyro(uint16_t timeBetweenReports);
 	void enableUncalibratedGyro(uint16_t timeBetweenReports);
 	void enableMagnetometer(uint16_t timeBetweenReports);
@@ -220,6 +235,12 @@ class BNO080
 	float getMagZ();
 	uint8_t getMagAccuracy();
 
+	void getGravity(float &x, float &y, float &z, uint8_t &accuracy);
+	float getGravityX();
+	float getGravityY();
+	float getGravityZ();
+	uint8_t getGravityAccuracy();
+
 	void calibrateAccelerometer();
 	void calibrateGyro();
 	void calibrateMagnetometer();
@@ -230,6 +251,10 @@ class BNO080
 	void requestCalibrationStatus(); //Sends command to get status
 	boolean calibrationComplete();   //Checks ME Cal response for byte 5, R0 - Status
 
+	void tareNow(bool zAxis=false, uint8_t rotationVectorBasis=TARE_ROTATION_VECTOR);
+	void saveTare();
+	void clearTare();
+	
 	uint8_t getTapDetector();
 	uint32_t getTimeStamp();
 	uint16_t getStepCount();
@@ -256,6 +281,7 @@ class BNO080
 	void setFeatureCommand(uint8_t reportID, uint16_t timeBetweenReports, uint32_t specificConfig);
 	void sendCommand(uint8_t command);
 	void sendCalibrateCommand(uint8_t thingToCalibrate);
+	void sendTareCommand(uint8_t command, uint8_t axis=TARE_AXIS_ALL, uint8_t rotationVectorBasis=TARE_ROTATION_VECTOR);
 
 	//Metadata functions
 	int16_t getQ1(uint16_t recordID);
@@ -299,6 +325,7 @@ class BNO080
 	uint16_t rawMagX, rawMagY, rawMagZ, magAccuracy;
 	uint16_t rawQuatI, rawQuatJ, rawQuatK, rawQuatReal, rawQuatRadianAccuracy, quatAccuracy;
 	uint16_t rawFastGyroX, rawFastGyroY, rawFastGyroZ;
+	uint16_t gravityX, gravityY, gravityZ, gravityAccuracy;
 	uint8_t tapDetector;
 	uint16_t stepCount;
 	uint32_t timeStamp;
@@ -319,4 +346,5 @@ class BNO080
 	int16_t gyro_Q1 = 9;
 	int16_t magnetometer_Q1 = 4;
 	int16_t angular_velocity_Q1 = 10;
-};
+	int16_t gravity_Q1 = 8;
+};