Added mock driver; renamed enums and fixed a bug

include/sta/drivers/bmi088.hpp

@@ -1,7 +1,7 @@
 #ifndef STA_DRIVERS_BMI088_HPP
 #define STA_DRIVERS_BMI088_HPP
 
-#include <sta/devices/stm32/bus/spi.hpp>
+#include <sta/bus/spi/device.hpp>
 
 #include <sta/drivers/bmi088_defs.hpp>
 
@@ -12,58 +12,58 @@ namespace sta
     public:
     	enum GyroMode
 		{
-    		NORMAL_AWAKE	= 0x00,
+    		NORMAL_AWAKE				= 0x00,
-			SUSPEND			= 0x80,
+			SUSPEND						= 0x80,
-			DEEP_SUSPEND	= 0x20
+			DEEP_SUSPEND				= 0x20
     	};
     	enum GyroRange
 		{
-    		TWOTHOUSAND		= 0x00,
+    		_2000						= 0x00,
-			ONETHOUSAND		= 0x01,
+			_1000						= 0x01,
-			FIVEHUNDRED 	= 0x02,
+			_500 						= 0x02,
-			TWOFIFTY		= 0x03,
+			_250						= 0x03,
-			ONETWENTYFIVE	= 0x04
+			_125						= 0x04
 		};
     	enum GyroBandwidth
 		{
-    		TWOTHOUSAND_FIVETHIRTYTWO	= 0x00,
+    		_2535						= 0x00,
-			TWOTHOUSAND_TWOTHIRTY		= 0x01,
+			_2230						= 0x01,
-			ONETHOUSAND_ONESIXTEEN		= 0x02,
+			_1116						= 0x02,
-			FOURHUNDRED_FORTYSEVEN		= 0x03,
+			_447						= 0x03,
-			TWOHUNDRED_TWENTYTHREE		= 0x04,
+			_223						= 0x04,
-			ONEHUNDRED_TWELVE			= 0x05,
+			_112						= 0x05,
-			TWOHUNDRED_SIXTYFOUR		= 0x06,
+			_264						= 0x06,
-			ONEHUNDRED_THIRTYTWO		= 0x07
+			_132						= 0x07
 		};
 
     	enum AccelMode
 		{
-    		OFF	= 0x00,
+    		OFF							= 0x00,
-			ON	= 0x04
+			ON							= 0x04
 		};
     	enum AccelRange
 		{
-			THREEG		= 0x00,
+			_3G							= 0x00,
-			SIXG		= 0x01,
+			_6G							= 0x01,
-			TWELVEG		= 0x02,
+			_12G						= 0x02,
-			TWENTYFOURG	= 0x03
+			_24G						= 0x03
 		};
     	enum AccelBandwidth
 		{
-    		OSR4				= 0x08,
+    		OSR4						= 0x08,
-			OSR2				= 0x09,
+			OSR2						= 0x09,
-			NORMAL_BANDWIDTH	= 0x0A
+			NORMAL_BANDWIDTH			= 0x0A
 		};
     	enum AccelODR
 		{
-    		TWELVE_FIVE		= 0x05,
+    		_12_5						= 0x05,
-			TWENTYFIVE		= 0x06,
+			_25							= 0x06,
-			FIFTY			= 0x07,
+			_50							= 0x07,
-			ONEHUNDRED		= 0x08,
+			_100						= 0x08,
-			TWOHUNDRED		= 0x09,
+			_200						= 0x09,
-			FOURHUNDRED		= 0x0A,
+			_400						= 0x0A,
-			EIGHTHUNDRED	= 0x0B,
+			_800						= 0x0B,
-			ONESIXHUNDRED	= 0x0C
+			_1600						= 0x0C
 		};
 
     private:
@@ -74,7 +74,7 @@ namespace sta
 		};
 
     public:
-        BMI088(STM32SPIDevice* gyro_device, STM32SPIDevice* accel_device);
+        BMI088(SPIDevice* gyro_device, SPIDevice* accel_device);
 
         bool init();
 
@@ -97,8 +97,8 @@ namespace sta
 
         void convertRawToActual(uint16_t* i, float* f, float f_range);
 
-        Device* gyro_device;
+        SPIDevice* gyro_device;
-		Device* accel_device;
+		SPIDevice* accel_device;
 
         float f_gyro_range = 0;
         float f_accel_range = 0;

src/bmi088.cpp

@@ -2,9 +2,12 @@
 
 #include <sta/debug/assert.hpp>
 
+#include <sta/config.hpp>
+#ifndef STA_SPATZ_ENABLED
+
 namespace sta
 {
-    BMI088::BMI088(STM32SPIDevice* gyro_device, STM32SPIDevice* accel_device)
+    BMI088::BMI088(SPIDevice* gyro_device, SPIDevice* accel_device)
         : gyro_device{gyro_device}, accel_device(accel_device)
     {
         STA_ASSERT(gyro_device != nullptr);
@@ -17,15 +20,15 @@ namespace sta
     	busRead(GYROSCOPE, BMI088_REG_GYRO_CHIP_ID, &id);
     	if(id != BMI088_GYRO_CHIP_ID) return false;
 
-    	setGyroscopeRange(GyroRange::ONETHOUSAND);
+    	setGyroscopeRange(GyroRange::_1000);
-    	setGyroscopeBandwidth(GyroBandwidth::TWOHUNDRED_SIXTYFOUR);
+    	setGyroscopeBandwidth(GyroBandwidth::_264);
     	setGyroscopeMode(GyroMode::NORMAL_AWAKE);
 
     	busRead(ACCELEROMETER, BMI088_REG_ACC_CHIP_ID, &id);
     	if(id != BMI088_ACC_CHIP_ID) return false;
 
-    	setAccelerometerRange(AccelRange::TWENTYFOURG);
+    	setAccelerometerRange(AccelRange::_24G);
-    	setAccelerometerBandwidth(AccelBandwidth::NORMAL_BANDWIDTH, AccelODR::ONEHUNDRED);
+    	setAccelerometerBandwidth(AccelBandwidth::NORMAL_BANDWIDTH, AccelODR::_100);
     	setAccelerometerMode(AccelMode::ON);
 
     	return true;
@@ -41,19 +44,19 @@ namespace sta
 
     	switch(range)
     	{
-    	case TWOTHOUSAND:
+    	case _2000:
     		f_gyro_range = 2000;
     		break;
-    	case ONETHOUSAND:
+    	case _1000:
     		f_gyro_range = 1000;
     		break;
-    	case FIVEHUNDRED:
+    	case _500:
     		f_gyro_range = 500;
     		break;
-    	case TWOFIFTY:
+    	case _250:
     		f_gyro_range = 250;
     		break;
-    	case ONETWENTYFIVE:
+    	case _125:
     		f_gyro_range = 125;
     		break;
     	default:
@@ -102,16 +105,16 @@ namespace sta
 
     	switch(range)
     	{
-    	case THREEG:
+    	case _3G:
     		f_accel_range = 3*9.80665;
     		break;
-    	case SIXG:
+    	case _6G:
     		f_accel_range = 6*9.80665;
     		break;
-    	case TWELVEG:
+    	case _12G:
     		f_accel_range = 12*9.80665;
     		break;
-    	case TWENTYFOURG:
+    	case _24G:
     		f_accel_range = 24*9.80665;
     		break;
     	default:
@@ -143,7 +146,7 @@ namespace sta
     void BMI088::getAcceleration(float* x, float* y, float* z)
     {
     	uint16_t i_x,i_y,i_z;
-		getRawRotation(&i_x, &i_y, &i_z);
+		getRawAcceleration(&i_x, &i_y, &i_z);
 		convertRawToActual(&i_x, x, f_accel_range);
 		convertRawToActual(&i_y, y, f_accel_range);
 		convertRawToActual(&i_z, z, f_accel_range);
@@ -204,3 +207,5 @@ namespace sta
 		}
 	}
 } // namespace sta
+
+#endif // STA_SPATZ_ENABLED

src/mock.cpp

@@ -0,0 +1,103 @@
+#include <sta/config.hpp>
+#ifdef STA_SPATZ_ENABLED
+
+#include <sta/drivers/bmi088.hpp>
+#include <sta/debug/spatz.hpp>
+#include <sta/debug/assert.hpp>
+
+
+#define STA_BMI088_ACC_SPATZ_ID         3
+#define STA_BMI088_GYRO_SPATZ_ID        4
+
+namespace sta
+{
+    BMI088::BMI088(SPIDevice* gyro_device, SPIDevice* accel_device)
+        : gyro_device{gyro_device}, accel_device(accel_device)
+    {
+        STA_ASSERT(gyro_device != nullptr);
+        STA_ASSERT(accel_device != nullptr);
+    }
+
+    bool BMI088::init()
+    {
+    	return true;
+    }
+
+    void BMI088::setGyroscopeMode(GyroMode mode)
+    {
+
+    }
+
+    void BMI088::setGyroscopeRange(GyroRange range)
+    {
+
+    }
+
+    void BMI088::setGyroscopeBandwidth(GyroBandwidth bandwidth)
+    {
+
+    }
+
+    void BMI088::getRawRotation(uint16_t* x, uint16_t* y, uint16_t* z)
+    {
+
+    }
+
+    void BMI088::getRotation(float* x, float* y, float* z)
+    {
+    	float omegas[3];
+        spatz::request(STA_BMI088_GYRO_SPATZ_ID, omegas, 3);
+
+        *x = omegas[0];
+        *y = omegas[1];
+        *z = omegas[2];
+    }
+
+
+    void BMI088::setAccelerometerMode(AccelMode mode)
+    {
+
+    }
+
+    void BMI088::setAccelerometerRange(AccelRange range)
+    {
+
+    }
+
+    void BMI088::setAccelerometerBandwidth(AccelBandwidth bandwidth, AccelODR odr)
+    {
+        
+    }
+    
+    void BMI088::getRawAcceleration(uint16_t* x, uint16_t* y, uint16_t* z)
+    {
+    	
+    }
+
+    void BMI088::getAcceleration(float* x, float* y, float* z)
+    {
+        float acc[3];
+        spatz::request(STA_BMI088_ACC_SPATZ_ID, acc, 3);
+
+        *x = acc[0];
+        *y = acc[1];
+        *z = acc[2];
+    }
+
+    bool BMI088::busRead(Part part, uint8_t reg, uint8_t * buffer)
+    {
+        return true;
+    }
+
+    bool BMI088::busWrite(Part part, uint8_t reg, uint8_t value)
+    {
+		return true;
+    }
+
+    void BMI088::convertRawToActual(uint16_t* i, float* f, float f_range) 
+    {
+
+    }
+} // namespace sta
+
+#endif // STA_SPATZ_ENABLED