phillip/dezibot
1
0
Fork 0
mirror of https://gitlab.dit.htwk-leipzig.de/phillip.kuehne/dezibot.git synced 2025-08-24 02:38:37 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merged MotionCorrection into Release (including InterfaceChange from motionDetection to motion.detection

Browse Source
This commit is contained in:
hhaupt
2024-06-14 02:51:54 +02:00
parent aa06a3b6a7 2b0cd00ddd
commit 7bc1359d50
14 changed files with 521 additions and 486 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/Dezibot.cpp
View File

@@ -5,7 +5,8 @@
#include "Dezibot.h"
#include <Wire.h>
#define GPIO_LED 48
Dezibot::Dezibot():multiColorLight(){};
void Dezibot::begin(void) {
Wire.begin(SDA_PIN,SCL_PIN);
@@ -15,7 +16,6 @@ void Dezibot::begin(void) {
lightDetection.begin();
colorDetection.begin();
multiColorLight.begin();
motionDetection.begin();
display.begin();
};

1
src/Dezibot.h
View File

@@ -29,7 +29,6 @@ public:
LightDetection lightDetection;
ColorDetection colorDetection;
MultiColorLight multiColorLight;
MotionDetection motionDetection;
InfraredLight infraredLight;
Communication communication;
Display display;

161
src/motion/Motion.cpp
View File

@@ -11,11 +11,10 @@
#include "Motion.h"
TaskHandle_t xMoveTaskHandle = NULL;
TaskHandle_t xClockwiseTaskHandle = NULL;
TaskHandle_t xAntiClockwiseTaskHandle = NULL;
// Initialize the movement component.
void Motion::begin(void) {
ledc_timer_config_t motor_timer = {
.speed_mode = LEDC_MODE,
@@ -27,37 +26,118 @@ void Motion::begin(void) {
ledc_timer_config(&motor_timer);
Motion::left.begin();
Motion::right.begin();
detection.begin();
};
void Motion::moveTask(void * args) {
uint32_t runtime = (uint32_t)args;
Motion::left.setSpeed(LEFT_MOTOR_DUTY);
Motion::right.setSpeed(RIGHT_MOTOR_DUTY);
vTaskDelay((uint32_t) args / portTICK_PERIOD_MS);
Motion::left.setSpeed(0);
Motion::right.setSpeed(0);
vTaskDelete(xMoveTaskHandle);
};
Motion::xLastWakeTime = xTaskGetTickCount();
while(1){
if(runtime>40||runtime==0){
vTaskDelayUntil(&xLastWakeTime,40);
runtime -= 40;
//calc new parameters
//set new parameters
int fifocount = detection.getDataFromFIFO(buffer);
int rightCounter = 0;
int leftCounter = 0;
int changerate = 0;
for(int i = 0;i<fifocount;i++){
if(buffer[i].gyro.z>correctionThreshold){
rightCounter++;
} else if(buffer[i].gyro.z<-correctionThreshold){
leftCounter++;
}
}
int difference = abs(leftCounter-rightCounter);
if (difference>25){
changerate = 200;
} else if(difference>20){
changerate = 100;
} else if(difference >15){
changerate = 50;
} else if(difference > 10){
changerate = 20;
} else{
changerate = 5;
}
// Move forward for a certain amount of time.
void Motion::move(uint32_t moveForMs) {
if (moveForMs > 0){
xTaskCreate(moveTask, "Move", 4096, (void*)moveForMs, 10, &xMoveTaskHandle);
} else{
Motion::left.setSpeed(LEFT_MOTOR_DUTY);
Motion::right.setSpeed(RIGHT_MOTOR_DUTY);
if(leftCounter>rightCounter){ //rotates anticlock
LEFT_MOTOR_DUTY+=changerate;
RIGHT_MOTOR_DUTY-=changerate;
} else if(leftCounter<rightCounter){
LEFT_MOTOR_DUTY-=changerate;
RIGHT_MOTOR_DUTY+=changerate;
}
Motion::left.setSpeed(LEFT_MOTOR_DUTY);
Motion::right.setSpeed(RIGHT_MOTOR_DUTY);
} else {
vTaskDelayUntil(&xLastWakeTime,runtime);
Motion::left.setSpeed(0);
Motion::right.setSpeed(0);
vTaskDelete(xMoveTaskHandle);
}
}
};
// Move forward for a certain amount of time.
void Motion::move(uint32_t moveForMs, uint baseValue) {
if(xMoveTaskHandle){
vTaskDelete(xMoveTaskHandle);
xMoveTaskHandle = NULL;
}
if(xClockwiseTaskHandle){
vTaskDelete(xClockwiseTaskHandle);
xClockwiseTaskHandle = NULL;
}
if(xAntiClockwiseTaskHandle){
vTaskDelete(xAntiClockwiseTaskHandle);
xAntiClockwiseTaskHandle = NULL;
}
LEFT_MOTOR_DUTY = baseValue;
RIGHT_MOTOR_DUTY = baseValue;
xTaskCreate(moveTask, "Move", 4096, (void*)moveForMs, 10, &xMoveTaskHandle);
};
void Motion::leftMotorTask(void * args) {
Motion::left.setSpeed(LEFT_MOTOR_DUTY);
uint32_t runtime = (uint32_t)args;
if(xMoveTaskHandle){
vTaskDelete(xMoveTaskHandle);
xMoveTaskHandle = NULL;
}
if(xAntiClockwiseTaskHandle){
vTaskDelete(xAntiClockwiseTaskHandle);
xAntiClockwiseTaskHandle = NULL;
}
Motion::right.setSpeed(0);
vTaskDelay((uint32_t) args / portTICK_PERIOD_MS);
Motion::left.setSpeed(0);
vTaskDelete(xClockwiseTaskHandle);
Motion::left.setSpeed(LEFT_MOTOR_DUTY);
while(1){
if((runtime>40)||(runtime==0)){
vTaskDelayUntil(&xLastWakeTime,40);
runtime -=40;
} else {
vTaskDelayUntil(&xLastWakeTime,runtime);
Motion::left.setSpeed(0);
vTaskDelete(xClockwiseTaskHandle);
}
vTaskDelayUntil(&xLastWakeTime,40);
}
};
// Rotate clockwise for a certain amount of time.
void Motion::rotateClockwise(uint32_t rotateForMs) {
void Motion::rotateClockwise(uint32_t rotateForMs,uint baseValue) {
LEFT_MOTOR_DUTY = baseValue;
RIGHT_MOTOR_DUTY = baseValue;
if (rotateForMs > 0){
if(xClockwiseTaskHandle){
vTaskDelete(xClockwiseTaskHandle);
}
xTaskCreate(leftMotorTask, "LeftMotor", 4096, (void*)rotateForMs, 10, &xClockwiseTaskHandle);
} else {
Motion::left.setSpeed(LEFT_MOTOR_DUTY);
@@ -66,16 +146,37 @@ void Motion::rotateClockwise(uint32_t rotateForMs) {
};
void Motion::rightMotorTask(void * args) {
uint32_t runtime = (uint32_t)args;
if(xMoveTaskHandle){
vTaskDelete(xMoveTaskHandle);
xMoveTaskHandle = NULL;
}
if(xClockwiseTaskHandle){
vTaskDelete(xClockwiseTaskHandle);
xClockwiseTaskHandle = NULL;
}
Motion::right.setSpeed(RIGHT_MOTOR_DUTY);
Motion::left.setSpeed(0);
vTaskDelay((uint32_t) args / portTICK_PERIOD_MS);
Motion::right.setSpeed(0);
vTaskDelete(xAntiClockwiseTaskHandle);
while(1){
if(runtime>40||runtime==0){
vTaskDelayUntil(&xLastWakeTime,40);
runtime -= 40;
} else {
vTaskDelayUntil(&xLastWakeTime,runtime);
Motion::right.setSpeed(0);
vTaskDelete(xAntiClockwiseTaskHandle);
}
}
};
// Rotate anticlockwise for a certain amount of time.
void Motion::rotateAntiClockwise(uint32_t rotateForMs) {
void Motion::rotateAntiClockwise(uint32_t rotateForMs,uint baseValue) {
LEFT_MOTOR_DUTY = baseValue;
RIGHT_MOTOR_DUTY = baseValue;
if(rotateForMs > 0){
if(xAntiClockwiseTaskHandle){
vTaskDelete(xAntiClockwiseTaskHandle);
}
xTaskCreate(rightMotorTask, "RightMotor", 4096, (void*)rotateForMs, 10, &xAntiClockwiseTaskHandle);
} else {
Motion::right.setSpeed(RIGHT_MOTOR_DUTY);
@@ -84,6 +185,18 @@ void Motion::rotateAntiClockwise(uint32_t rotateForMs) {
};
void Motion::stop(void){
if(xMoveTaskHandle){
vTaskDelete(xMoveTaskHandle);
xMoveTaskHandle = NULL;
}
if(xAntiClockwiseTaskHandle){
vTaskDelete(xAntiClockwiseTaskHandle);
xAntiClockwiseTaskHandle = NULL;
}
if(xClockwiseTaskHandle){
vTaskDelete(xClockwiseTaskHandle);
xClockwiseTaskHandle = NULL;
}
Motion::left.setSpeed(0);
Motion::right.setSpeed(0);
}

61
src/motion/Motion.h
View File

@@ -16,17 +16,37 @@
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include "driver/ledc.h"
#include "motionDetection/MotionDetection.h"
#define LEDC_MODE LEDC_LOW_SPEED_MODE
#define TIMER LEDC_TIMER_2
#define CHANNEL_LEFT LEDC_CHANNEL_3
#define CHANNEL_RIGHT LEDC_CHANNEL_4
#define DUTY_RES LEDC_TIMER_13_BIT // Set duty resolution to 13 bits
#define FREQUENCY (5000) // Frequency in Hertz. Set frequency at 5 kHz
#define DEFAULT_BASE_VALUE 3900
class Motor{
public:
Motor(uint8_t pin, ledc_timer_t timer, ledc_channel_t channel);
/**
* @brief Initializes the motor
*/
void begin(void);
/**
* @brief Set the Speed by changing the pwm. To avoid current peaks, a linear ramp-up is used.
*
* @attention it is requried at any time to use that method to access the motors or methods of the motionclass to avoid such peaks.
*
* @param duty the duty cyle that should be set, can be between 0-8192
*/
void setSpeed(uint16_t duty);
/**
* @brief returns the currently activ speed
*
* @return current speedvalue of the motor
*/
uint16_t getSpeed(void);
protected:
uint8_t pin;
@@ -38,18 +58,28 @@ class Motor{
class Motion{
protected:
static const uint16_t RIGHT_MOTOR_DUTY = 4096;
static const uint16_t LEFT_MOTOR_DUTY = 4096;
static inline uint16_t RIGHT_MOTOR_DUTY = DEFAULT_BASE_VALUE;
static inline uint16_t LEFT_MOTOR_DUTY = DEFAULT_BASE_VALUE;
static const int MOTOR_RIGHT_PIN = 11;
static const int MOTOR_LEFT_PIN = 12;
static void moveTask(void * args);
static void leftMotorTask(void * args);
static void rightMotorTask(void * args);
static inline TaskHandle_t xMoveTaskHandle = NULL;
static inline TaskHandle_t xClockwiseTaskHandle = NULL;
static inline TaskHandle_t xAntiClockwiseTaskHandle = NULL;
static inline TickType_t xLastWakeTime;
static inline FIFO_Package* buffer = new FIFO_Package[64];
static inline int correctionThreshold = 150;
public:
//Shared Timer to sync movement
//Instances of the motors, so they can also be used from outside to set values for the motors directly.
static inline Motor left = Motor(MOTOR_LEFT_PIN,TIMER,CHANNEL_LEFT);
static inline Motor right = Motor(MOTOR_RIGHT_PIN,TIMER,CHANNEL_RIGHT);
//MotionDetection instance, for motion Correction and user (access with dezibot.motion.detection)
static inline MotionDetection detection;
/**
* @brief Initialize the movement component.
@@ -60,23 +90,30 @@ public:
/**
* @brief Move forward for a certain amount of time.
* Call with moveForMs 0 will start movement, that must be stopped explicit by call to stop().
* The function applys a basic algorithm to improve the straigthness of the movement.
* Lifting the robot from the desk may corrupt the results and is not recommended.
*
* @param moveForMs Representing the duration of forward moving in milliseconds.
* @param baseValue The value that is used to start with the calibrated movement. Defaults to 3900.
* If the Dezibot is not moving forward at all increasing the value may help. If the robot is just jumping up and down but not forward, try a lower value.
*/
static void move(uint32_t moveForMs=0);
static void move(uint32_t moveForMs=0,uint baseValue=DEFAULT_BASE_VALUE);
/**
* @brief Rotate clockwise for a certain amount of time.
* Call with moveForMs 0 will start movement, that must be stopped explicit by call to stop().
* @param rotateForMs Representing the duration of rotating clockwise in milliseconds.
* @param rotateForMs Representing the duration of rotating clockwise in milliseconds, or 0 to rotate until another movecmd is issued. Default is 0
* @param baseValue The value that is used to start with the calibrated movement (not released yet, currently just the used value)
*/
static void rotateClockwise(uint32_t rotateForMs=0);
static void rotateClockwise(uint32_t rotateForMs=0,uint baseValue=DEFAULT_BASE_VALUE);
/**
* @brief Rotate anticlockwise for a certain amount of time.
* Call with moveForMs 0 will start movement, that must be stopped explicit by call to stop().
* @param rotateForMs Representing the duration of rotating anticlockwise in milliseconds.
* @param rotateForMs Representing the duration of rotating anticlockwise in milliseconds or 0 to let the robot turn until another movecommand is issued. Default is 0.
* @param baseValue The value that is used to start with the calibrated movement (not released yet, currently just the used value).
*/
static void rotateAntiClockwise(uint32_t rotateForMs=0);
static void rotateAntiClockwise(uint32_t rotateForMs=0,uint baseValue=DEFAULT_BASE_VALUE);
/**
* @brief stops any current movement, no matter if timebased or endless
@@ -84,6 +121,14 @@ public:
*/
static void stop(void);
/**
* @brief Does the same as the move function, but this function does not apply any kind of algorithm to improve the result.
*
* @param moveForMs how many ms should the robot move, or 0 to let the robot move until another move command is mentioned, default is 0
* @param baseValue the duty value that is used for the movement, default is 0
*/
static void moveWithoutCorrection(uint32_t moveForMs=0, uint baseValue = DEFAULT_BASE_VALUE);
};

21
src/motion/Motor.cpp
View File

@@ -23,9 +23,24 @@ void Motor::begin(void){
};
void Motor::setSpeed(uint16_t duty){
this->duty = duty;
ledc_set_duty(LEDC_MODE,this->channel,duty);
ledc_update_duty(LEDC_MODE,this->channel);
int difference = duty-this->getSpeed();
if (difference > 0){
for(int i = 0;i<difference;i+=difference/20){
this->duty += difference/20;
ledc_set_duty(LEDC_MODE,this->channel,duty);
ledc_update_duty(LEDC_MODE,this->channel);
delayMicroseconds(5);
}
} else {
for(int i = 0;i>difference;i-=abs(difference/20)){
this->duty -= abs(difference/20);
ledc_set_duty(LEDC_MODE,this->channel,duty);
ledc_update_duty(LEDC_MODE,this->channel);
delayMicroseconds(5);
}
}
};
uint16_t Motor::getSpeed(void){

49
src/motionDetection/IMU_CMDs.h Normal file
View File

@@ -0,0 +1,49 @@
#ifndef IMU_CMDs
#define IMU_CMDs
#define CMD_READ 0x80
#define CMD_WRITE 0x00
#define ADDR_MASK 0x7F
//Registers
#define MCLK_RDY 0x00
#define REG_TEMP_LOW 0x0A
#define REG_TEMP_HIGH 0X09
#define ACCEL_DATA_X_HIGH 0x0B
#define ACCEL_DATA_X_LOW 0x0C
#define ACCEL_DATA_Y_HIGH 0x0D
#define ACCEL_DATA_Y_LOW 0x0E
#define ACCEL_DATA_Z_HIGH 0x0F
#define ACCEL_DATA_Z_LOW 0x10
#define GYRO_DATA_X_HIGH 0x11
#define GYRO_DATA_X_LOW 0x12
#define GYRO_DATA_Y_HIGH 0x13
#define GYRO_DATA_Y_LOW 0x14
#define GYRO_DATA_Z_HIGH 0x15
#define GYRO_DATA_Z_LOW 0x16
#define PWR_MGMT0 0x1F
#define WHO_AM_I 0x75
#define INTF_CONFIG0 0x35
#define BLK_SEL_W 0x79
#define BLK_SEL_R 0x7C
#define MADDR_W 0x7A
#define MADDR_R 0x7D
#define M_W 0x7B
#define M_R 0x7E
#define FIFO_COUNTH 0x3D
#define FIFO_COUNTL 0x3E
#define FIFO_DATA 0x3F
#define FIFO_CONFIG1 0x28
#define FIFO_CONFIG2 0x29
//MREG1
#define FIFO_CONFIG5 0x01
#define TMST_CONFIG1 0x00
#endif

146
src/motionDetection/MotionDetection.cpp
View File

@@ -1,4 +1,5 @@
#include "MotionDetection.h"
#include <math.h>
MotionDetection::MotionDetection(){
handler = new SPIClass(FSPI);
@@ -8,32 +9,21 @@ void MotionDetection::begin(void){
pinMode(34,OUTPUT);
digitalWrite(34,HIGH);
handler->begin(36,37,35,34);
handler->beginTransaction(SPISettings(frequency,SPI_MSBFIRST,SPI_MODE0));
digitalWrite(34,LOW);
// set Accel and Gyroscop to Low Noise
handler->transfer(PWR_MGMT0);
handler->transfer(0x1F);
this->writeRegister(PWR_MGMT0,0x1F);
//busy Wait for startup
delayMicroseconds(250);
//set accelconfig
this->writeRegister(0x21,0x05);
//set Gyroconfig
handler->transfer(0x20);
handler->transfer(0x25);
this->writeRegister(0x20,0x25);
//set Gyro Filter
handler->transfer(0x23);
handler->transfer(0x37);
digitalWrite(34,HIGH);
handler->endTransaction();
this->writeRegister(0x23,0x37);
//Enable Gyro and Acceldata in FIFO
this->initFIFO();
};
void MotionDetection::end(void){
handler->beginTransaction(SPISettings(frequency,SPI_MSBFIRST,SPI_MODE0));
digitalWrite(34,LOW);
handler->transfer(cmdWrite(PWR_MGMT0));
//turn Accel and Gyroscope off
handler->transfer(0x00);
digitalWrite(34,HIGH);
handler->end();
this->writeRegister(PWR_MGMT0,0x00);
};
IMUResult MotionDetection::getAcceleration(){
IMUResult result;
@@ -175,7 +165,123 @@ uint8_t MotionDetection::readRegister(uint8_t reg){
uint8_t result;
result = handler->transfer(cmdRead(reg));
result = handler->transfer(0x00);
digitalWrite(34,HIGH);
digitalWrite(34,HIGH);
handler->endTransaction();
return result;
};
uint8_t MotionDetection::readFromRegisterBank(registerBank bank,uint8_t reg){
uint8_t result = 0;
switch(bank){
case(MREG1):
this->writeRegister(BLK_SEL_R,0x00);
break;
case(MREG2):
this->writeRegister(BLK_SEL_R,0x28);
break;
case(MREG3):
this->writeRegister(BLK_SEL_R,0x50);
break;
}
this->writeRegister(MADDR_R,reg);
delayMicroseconds(10);
result=this->readRegister(M_R);
delayMicroseconds(10);
this->resetRegisterBankAccess();
return result;
};
void MotionDetection::writeToRegisterBank(registerBank bank, uint8_t reg, uint8_t value){
while((this->readRegister(MCLK_RDY))&0x08!=0x08){
Serial.println("CLK not rdy");
delay(100);
}
uint8_t result = this->readRegister(PWR_MGMT0);
Serial.print("MADDR_W: ");
Serial.println(readRegister(MADDR_W));
//set Idle Bit
this->writeRegister(PWR_MGMT0,result|0x10);
switch(bank){
case(MREG1):
this->writeRegister(BLK_SEL_W,0x00);
break;
case(MREG2):
this->writeRegister(BLK_SEL_W,0x28);
break;
case(MREG3):
this->writeRegister(BLK_SEL_W,0x50);
break;
}
this->writeRegister(MADDR_W,reg);
this->writeRegister(M_W,value);
delayMicroseconds(10);
this->writeRegister(PWR_MGMT0,result&0xEF);
Serial.print("MADDR_W: ");
Serial.println(readRegister(MADDR_W));
this->resetRegisterBankAccess();
};
void MotionDetection::resetRegisterBankAccess(){
this->writeRegister(BLK_SEL_R,0x00);
this->writeRegister(BLK_SEL_W,0x00);
this->writeRegister(MADDR_R,0x00);
this->writeRegister(MADDR_W,0x00);
};
void MotionDetection::initFIFO(){
delay(60);
//set INTF_CONFIG0 FIFO_COUNT_REC_RECORD und Little Endian
this->writeRegister(INTF_CONFIG0,0x60);
//set FIFO_CONFIG1 to Mode Snapshot and BYPASS Off
this->writeRegister(FIFO_CONFIG1,0x00);
//set TMST_CONFIG1_MREG1 TMST_CONFIIG1_TMST_EN
this->writeToRegisterBank(MREG1,TMST_CONFIG1,0x00);
//set FiFO config 5 GYRO_EN,TMST_FSYNC, ACCEL_EN, WM_GT_TH_EN
this->writeToRegisterBank(MREG1,FIFO_CONFIG5,0x23);
//set FOF_CONFIG2 0x1 (INT triggerd each packaged)
this->writeRegister(FIFO_CONFIG2,0x0A);
};
uint MotionDetection::getDataFromFIFO(FIFO_Package* buffer){
int16_t fifocount = 0;
int8_t fifohigh = this->readRegister(FIFO_COUNTH);
int8_t fifolow = this->readRegister(FIFO_COUNTL);
fifocount = (fifohigh<<8)|fifolow;
//fifocount |= this->readRegister(FIFO_COUNTL);
//fifocount = (this->readRegister(FIFO_COUNTH)<<8);
Serial.println(fifolow);
Serial.println(fifohigh);
Serial.println(fifocount);
handler->beginTransaction(SPISettings(frequency,SPI_MSBFIRST,SPI_MODE0));
digitalWrite(34,LOW);
handler->transfer(cmdRead(FIFO_DATA));
handler->transfer(buf,16*fifocount);
digitalWrite(34,HIGH);
handler->endTransaction();
writeRegister(0x02,0x04);
delayMicroseconds(10);
for(int i = 0; i<fifocount;i++){
buffer[i].header = buf[0x00+16*i];
buffer[i].accel.x = (buf[0x02+16*i]<<8)|buf[0x01+16*i];
buffer[i].accel.y = (buf[0x04+16*i]<<8)|buf[0x03+16*i];
buffer[i].accel.z = (buf[0x06+16*i]<<8)|buf[0x05+16*i];
buffer[i].gyro.x = (buf[0x08+16*i]<<8)|buf[0x07+16*i];
buffer[i].gyro.y = (buf[0x0A+16*i]<<8)|buf[0x09+16*i];
buffer[i].gyro.z = (buf[0x0C+16*i]<<8)|buf[0x0B+16*i];
buffer[i].temperature = buf[0x0D+16*i];
buffer[i].timestamp = (buf[0x0F+16*i]<<8)|buf[0x0E +16*i];
}
return fifocount;
};
void MotionDetection::writeRegister(uint8_t reg, uint8_t value){
handler->beginTransaction(SPISettings(frequency,SPI_MSBFIRST,SPI_MODE0));
digitalWrite(34,LOW);
handler->transfer(reg);
handler->transfer(value);
digitalWrite(34,HIGH);
delayMicroseconds(10);
handler->endTransaction();
};

55
src/motionDetection/MotionDetection.h
View File

@@ -12,6 +12,7 @@
#define MotionDetection_h
#include <SPI.h>
#include <Arduino.h>
#include "IMU_CMDs.h"
struct IMUResult{
int16_t x;
int16_t y;
@@ -38,36 +39,25 @@ enum Direction{
Error
};
struct FIFO_Package{
int8_t header;
IMUResult gyro;
IMUResult accel;
int16_t temperature;
int16_t timestamp;
};
class MotionDetection{
protected:
static const uint8_t CMD_READ = 0x80;
static const uint8_t CMD_WRITE = 0x00;
static const uint8_t ADDR_MASK = 0x7F;
//Registers
static const uint8_t REG_TEMP_LOW = 0x0A;
static const uint8_t REG_TEMP_HIGH = 0X09;
static const uint8_t ACCEL_DATA_X_HIGH = 0x0B;
static const uint8_t ACCEL_DATA_X_LOW = 0x0C;
static const uint8_t ACCEL_DATA_Y_HIGH = 0x0D;
static const uint8_t ACCEL_DATA_Y_LOW = 0x0E;
static const uint8_t ACCEL_DATA_Z_HIGH = 0x0F;
static const uint8_t ACCEL_DATA_Z_LOW = 0x10;
static const uint8_t GYRO_DATA_X_HIGH = 0x11;
static const uint8_t GYRO_DATA_X_LOW = 0x12;
static const uint8_t GYRO_DATA_Y_HIGH = 0x13;
static const uint8_t GYRO_DATA_Y_LOW = 0x14;
static const uint8_t GYRO_DATA_Z_HIGH = 0x15;
static const uint8_t GYRO_DATA_Z_LOW = 0x16;
static const uint8_t PWR_MGMT0 = 0x1F;
static const uint8_t WHO_AM_I = 0x75;
static const uint frequency = 10000000;
enum registerBank{MREG1,MREG2,MREG3};
static const uint frequency = 24000000;
static const uint16_t defaultShakeThreshold = 500;
const uint bufferLength = 64*16;
int8_t* buf = new int8_t[bufferLength];
uint8_t readFromRegisterBank(registerBank bank,uint8_t reg);
void writeToRegisterBank(registerBank bank, uint8_t reg, uint8_t value);
void resetRegisterBankAccess();
uint16_t cmdRead(uint8_t regHigh,uint8_t regLow);
uint16_t cmdWrite(uint8_t regHigh,uint8_t regLow);
@@ -76,6 +66,8 @@ protected:
uint8_t readRegister(uint8_t reg);
int16_t readDoubleRegister(uint8_t lowerReg);
void writeRegister(uint8_t reg, uint8_t value);
void initFIFO();
SPIClass * handler = NULL;
@@ -183,6 +175,13 @@ public:
*/
void calibrateZAxis(uint gforceValue);
/**
* @brief will read all availible packages from fifo, after 40ms Fifo is full
*
* @param buffer pointer to FIFO_Package Struct that at least must have size 64 (this is the max package count with APEX Enabled)
*
* @return the amount of acutally fetched packages
*/
uint getDataFromFIFO(FIFO_Package* buffer);
};
#endif //MotionDetection