eive/eive-obsw
13
4
Fork 0
Code Issues 4 Pull Requests 1 Releases 121 Wiki Activity

arduino stuff added

Browse Source
This commit is contained in:
Robin Müller
2020-10-01 02:06:39 +02:00
committed by Robin.Mueller
parent 436275c61d
commit 4337ab6690
17 changed files with 1192 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

246
mission/devices/MGMHandlerLIS3MDL.cpp
View File

@ -14,29 +14,88 @@ MGMHandlerLIS3MDL::MGMHandlerLIS3MDL(object_id_t objectId,
MGMHandlerLIS3MDL::~MGMHandlerLIS3MDL() {
}
void MGMHandlerLIS3MDL::doStartUp() {
switch (internalState) {
case STATE_NONE:
internalState = STATE_FIRST_CONTACT;
break;
case STATE_FIRST_CONTACT:
internalState = STATE_SETUP;
break;
case STATE_SETUP:
internalState = STATE_CHECK_REGISTERS;
break;
case STATE_CHECK_REGISTERS:
if (setupMGM() == RETURN_OK) {
for (size_t i = 1; i <= MGMLIS3MDL::NR_OF_CTRL_REGISTERS; i++) {
if (registers[i - 1] != commandBuffer[i]) {
break;
}
}
setMode(_MODE_TO_ON);
}
break;
default:
break;
}
}
void MGMHandlerLIS3MDL::doShutDown() {
setMode(_MODE_POWER_DOWN);
}
ReturnValue_t MGMHandlerLIS3MDL::buildTransitionDeviceCommand(
DeviceCommandId_t *id) {
switch (internalState) {
case STATE_FIRST_CONTACT:
*id = MGMLIS3MDL::IDENTIFY_DEVICE;
break;
case STATE_SETUP:
*id = MGMLIS3MDL::SETUP_MGM;
break;
case STATE_CHECK_REGISTERS:
*id = MGMLIS3MDL::READALL_MGM;
break;
default:
break;
}
return buildCommandFromCommand(*id, NULL, 0);
}
uint8_t MGMHandlerLIS3MDL::readCommand(uint8_t command, bool continuousCom) {
command |= (1 << RW_BIT);
command |= (1 << MGMLIS3MDL::RW_BIT);
if (continuousCom == true) {
command |= (1 << MS_BIT);
command |= (1 << MGMLIS3MDL::MS_BIT);
}
return command;
}
uint8_t MGMHandlerLIS3MDL::writeCommand(uint8_t command, bool continuousCom) {
command &= ~(1 << RW_BIT);
command &= ~(1 << MGMLIS3MDL::RW_BIT);
if (continuousCom == true) {
command |= (1 << MS_BIT);
command |= (1 << MGMLIS3MDL::MS_BIT);
}
return command;
}
ReturnValue_t MGMHandlerLIS3MDL::setupMGM() {
registers[0] = (1 << TEMP_EN) | (1 << OM1) | (1 << DO0) | (1 << DO1)
| (1 << DO2);
registers[0] = (1 << MGMLIS3MDL::TEMP_EN) | (1 << MGMLIS3MDL::OM1)
| (1 << MGMLIS3MDL::DO0) | (1 << MGMLIS3MDL::DO1)
| (1 << MGMLIS3MDL::DO2);
registers[1] = 0;
registers[2] = 0;
registers[3] = (1 << OMZ1);
registers[3] = (1 << MGMLIS3MDL::OMZ1);
registers[4] = 0;
return prepareRegisterWrite();
@ -46,7 +105,7 @@ ReturnValue_t MGMHandlerLIS3MDL::setupMGM() {
ReturnValue_t MGMHandlerLIS3MDL::buildNormalDeviceCommand(
DeviceCommandId_t *id) {
//defines CommandID of MGM in normal operation and build command from command
*id = READALL_MGM;
*id = MGMLIS3MDL::READALL_MGM;
return buildCommandFromCommand(*id, NULL, 0);
}
@ -55,27 +114,25 @@ ReturnValue_t MGMHandlerLIS3MDL::buildCommandFromCommand(
size_t commandDataLen) {
lastSentCommand = deviceCommand;
switch(deviceCommand) {
case(READALL_MGM): {
case(MGMLIS3MDL::READALL_MGM): {
if (commandDataLen == 0) {
for (size_t i = 0; i < sizeof(commandBuffer); i++) {
commandBuffer[i] = 0;
}
std::memset(commandBuffer, 0, sizeof(commandBuffer));
commandBuffer[0] = readCommand(0, true);
rawPacket = commandBuffer;
rawPacketLen = sizeof(commandBuffer);
return RETURN_OK;
}
case(IDENTIFY_DEVICE): {
case(MGMLIS3MDL::IDENTIFY_DEVICE): {
return identifyDevice();
}
case(TEMP_SENSOR_ENABLE): {
case(MGMLIS3MDL::TEMP_SENSOR_ENABLE): {
return enableTemperatureSensor(commandData, commandDataLen);
}
case(SETUP_MGM): {
case(MGMLIS3MDL::SETUP_MGM): {
return setupMGM();
}
case(ACCURACY_OP_MODE_SET): {
case(MGMLIS3MDL::ACCURACY_OP_MODE_SET): {
return setOperatingMode(commandData, commandDataLen);
}
default:
@ -86,42 +143,31 @@ ReturnValue_t MGMHandlerLIS3MDL::buildCommandFromCommand(
return HasReturnvaluesIF::RETURN_FAILED;
}
ReturnValue_t MGMHandlerLIS3MDL::buildTransitionDeviceCommand(
DeviceCommandId_t *id) {
switch (internalState) {
case STATE_FIRST_CONTACT:
*id = IDENTIFY_DEVICE;
break;
ReturnValue_t MGMHandlerLIS3MDL::identifyDevice() {
uint32_t size = 2;
commandBuffer[0] = readCommand(MGMLIS3MDL::IDENTIFY_DEVICE_REG_ADDR);
commandBuffer[1] = 0x00;
case STATE_SETUP:
*id = SETUP_MGM;
break;
case STATE_CHECK_REGISTERS:
*id = READALL_MGM;
break;
default:
break;
}
return buildCommandFromCommand(*id, NULL, 0);
rawPacket = commandBuffer;
rawPacketLen = size;
return RETURN_OK;
}
ReturnValue_t MGMHandlerLIS3MDL::scanForReply(const uint8_t *start,
size_t len, DeviceCommandId_t *foundId, size_t *foundLen) {
*foundLen = len;
if (len == TOTAL_NR_OF_ADRESSES + 1) {
if (len == MGMLIS3MDL::TOTAL_NR_OF_ADRESSES + 1) {
*foundLen = len;
*foundId = READALL_MGM;
*foundId = MGMLIS3MDL::READALL_MGM;
//WHO AM I test
if (*(start + 16) != DEVICEID) {
if (*(start + 16) != MGMLIS3MDL::DEVICE_ID) {
return DeviceHandlerIF::INVALID_DATA;
}
} else if (len == SETUP_REPLY) {
} else if (len == MGMLIS3MDL::SETUP_REPLY) {
*foundLen = len;
*foundId = SETUP_MGM;
*foundId = MGMLIS3MDL::SETUP_MGM;
} else if (len == SINGLE_COMMAND_ANSWER_LEN) {
*foundLen = len;
*foundId = lastSentCommand;
@ -130,9 +176,11 @@ ReturnValue_t MGMHandlerLIS3MDL::scanForReply(const uint8_t *start,
return DeviceHandlerIF::INVALID_DATA;
}
if (start[0] == 0b11111111) { //Data with SPI Interface has always this answer
// Data with SPI Interface has always this answer
if (start[0] == 0b11111111) {
return RETURN_OK;
} else {
}
else {
return DeviceHandlerIF::INVALID_DATA;
}
@ -141,14 +189,14 @@ ReturnValue_t MGMHandlerLIS3MDL::interpretDeviceReply(DeviceCommandId_t id,
const uint8_t *packet) {
switch (id) {
case IDENTIFY_DEVICE: {
case MGMLIS3MDL::IDENTIFY_DEVICE: {
break;
}
case SETUP_MGM: {
case MGMLIS3MDL::SETUP_MGM: {
break;
}
case READALL_MGM: {
case MGMLIS3MDL::READALL_MGM: {
// TODO: Store configuration and sensor values in new local datasets.
registers[0] = *(packet + 33);
registers[1] = *(packet + 34);
registers[2] = *(packet + 35);
@ -157,7 +205,7 @@ ReturnValue_t MGMHandlerLIS3MDL::interpretDeviceReply(DeviceCommandId_t id,
uint8_t reg2_value = *(packet + 34);
uint8_t scale = getFullScale(&reg2_value);
float sensitivity = getSensitivity(scale);
float sensitivityFactor = getSensitivityFactor(scale);
int16_t x_value_raw;
int16_t y_value_raw;
@ -165,7 +213,7 @@ ReturnValue_t MGMHandlerLIS3MDL::interpretDeviceReply(DeviceCommandId_t id,
int16_t temp_value_raw;
//size_t size = 2;
uint8_t *accessBuffer;
accessBuffer = (uint8_t*) (packet + 41);
accessBuffer = const_cast<uint8_t*>(packet + 41);
x_value_raw = *(accessBuffer + 1) << 8 | *(accessBuffer);
accessBuffer += 2;
@ -176,10 +224,10 @@ ReturnValue_t MGMHandlerLIS3MDL::interpretDeviceReply(DeviceCommandId_t id,
temp_value_raw = *(accessBuffer + 1) << 8 | *(accessBuffer);
float x_value = (float) x_value_raw * sensitivity;
float y_value = (float) y_value_raw * sensitivity;
float z_value = (float) z_value_raw * sensitivity;
float temp_value = 25.0 + (((float) temp_value_raw) / 8.0);
float x_value = static_cast<float>(x_value_raw) * sensitivityFactor;
float y_value = static_cast<float>(y_value_raw) * sensitivityFactor;
float z_value = static_cast<float>(z_value_raw) * sensitivityFactor;
float temp_value = 25.0 + ((static_cast<float>(temp_value_raw)) / 8.0);
break;
}
@ -207,39 +255,27 @@ uint8_t MGMHandlerLIS3MDL::getFullScale(uint8_t *reg2) {
return 8;
else
return 4;
}
float MGMHandlerLIS3MDL::getSensitivity(uint8_t scale) {
float MGMHandlerLIS3MDL::getSensitivityFactor(uint8_t scale) {
return (float) scale / (INT16_MAX);
}
ReturnValue_t MGMHandlerLIS3MDL::identifyDevice() {
uint32_t size = 2;
commandBuffer[0] = readCommand(IDENTIFYDEVICE);
commandBuffer[1] = 0x00;
rawPacket = commandBuffer;
rawPacketLen = size;
return RETURN_OK;
}
ReturnValue_t MGMHandlerLIS3MDL::enableTemperatureSensor(
const uint8_t *commandData, size_t commandDataLen) {
triggerEvent(CHANGE_OF_SETUP_PARAMETER);
uint32_t size = 2;
commandBuffer[0] = writeCommand(CTRL_REG1);
commandBuffer[0] = writeCommand(MGMLIS3MDL::CTRL_REG1);
if (commandDataLen > 1) {
return INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS;
}
switch (*commandData) {
case (ON):
case (MGMLIS3MDL::ON):
commandBuffer[1] = registers[0] | (1 << 7);
break;
case (OFF):
case (MGMLIS3MDL::OFF):
commandBuffer[1] = registers[0] & ~(1 << 7);
break;
@ -255,42 +291,6 @@ ReturnValue_t MGMHandlerLIS3MDL::enableTemperatureSensor(
return RETURN_OK;
}
void MGMHandlerLIS3MDL::doStartUp() {
switch (internalState) {
case STATE_NONE:
internalState = STATE_FIRST_CONTACT;
break;
case STATE_FIRST_CONTACT:
internalState = STATE_SETUP;
break;
case STATE_SETUP:
internalState = STATE_CHECK_REGISTERS;
break;
case STATE_CHECK_REGISTERS:
if (setupMGM() == RETURN_OK) {
for (size_t i = 1; i <= NR_OF_CTRL_REGISTERS; i++) {
if (registers[i - 1] != commandBuffer[i]) {
break;
}
}
setMode(_MODE_TO_ON);
}
break;
default:
break;
}
}
void MGMHandlerLIS3MDL::doShutDown() {
setMode(_MODE_POWER_DOWN);
}
ReturnValue_t MGMHandlerLIS3MDL::setOperatingMode(const uint8_t *commandData,
size_t commandDataLen) {
triggerEvent(CHANGE_OF_SETUP_PARAMETER);
@ -299,23 +299,23 @@ ReturnValue_t MGMHandlerLIS3MDL::setOperatingMode(const uint8_t *commandData,
}
switch (commandData[0]) {
case LOW:
registers[0] = (registers[0] & (~(1 << OM1))) & (~(1 << OM0));
registers[3] = (registers[3] & (~(1 << OMZ1))) & (~(1 << OMZ0));
case MGMLIS3MDL::LOW:
registers[0] = (registers[0] & (~(1 << MGMLIS3MDL::OM1))) & (~(1 << MGMLIS3MDL::OM0));
registers[3] = (registers[3] & (~(1 << MGMLIS3MDL::OMZ1))) & (~(1 << MGMLIS3MDL::OMZ0));
break;
case MEDIUM:
registers[0] = (registers[0] & (~(1 << OM1))) | (1 << OM0);
registers[3] = (registers[3] & (~(1 << OMZ1))) | (1 << OMZ0);
case MGMLIS3MDL::MEDIUM:
registers[0] = (registers[0] & (~(1 << MGMLIS3MDL::OM1))) | (1 << MGMLIS3MDL::OM0);
registers[3] = (registers[3] & (~(1 << MGMLIS3MDL::OMZ1))) | (1 << MGMLIS3MDL::OMZ0);
break;
case HIGH:
registers[0] = (registers[0] | (1 << OM1)) & (~(1 << OM0));
registers[3] = (registers[3] | (1 << OM1)) & (~(1 << OM0));
case MGMLIS3MDL::HIGH:
registers[0] = (registers[0] | (1 << MGMLIS3MDL::OM1)) & (~(1 << MGMLIS3MDL::OM0));
registers[3] = (registers[3] | (1 << MGMLIS3MDL::OMZ1)) & (~(1 << MGMLIS3MDL::OMZ0));
break;
case ULTRA:
registers[0] = (registers[0] | (1 << OM1)) | (1 << OM0);
registers[3] = (registers[3] | (1 << OM1)) | (1 << OM0);
case MGMLIS3MDL::ULTRA:
registers[0] = (registers[0] | (1 << MGMLIS3MDL::OM1)) | (1 << MGMLIS3MDL::OM0);
registers[3] = (registers[3] | (1 << MGMLIS3MDL::OMZ1)) | (1 << MGMLIS3MDL::OMZ0);
break;
default:
break;
@ -335,22 +335,22 @@ void MGMHandlerLIS3MDL::fillCommandAndReplyMap() {
* We dont read single registers, we just expect special
* reply from he Readall_MGM
*/
insertInCommandAndReplyMap(READALL_MGM, 1);
insertInCommandAndReplyMap(SETUP_MGM, 1);
insertInCommandAndReplyMap(IDENTIFY_DEVICE, 1);
insertInCommandAndReplyMap(TEMP_SENSOR_ENABLE, 1);
insertInCommandAndReplyMap(ACCURACY_OP_MODE_SET, 1);
insertInCommandAndReplyMap(MGMLIS3MDL::READALL_MGM, 1);
insertInCommandAndReplyMap(MGMLIS3MDL::SETUP_MGM, 1);
insertInCommandAndReplyMap(MGMLIS3MDL::IDENTIFY_DEVICE, 1);
insertInCommandAndReplyMap(MGMLIS3MDL::TEMP_SENSOR_ENABLE, 1);
insertInCommandAndReplyMap(MGMLIS3MDL::ACCURACY_OP_MODE_SET, 1);
}
ReturnValue_t MGMHandlerLIS3MDL::prepareRegisterWrite() {
commandBuffer[0] = writeCommand(CTRL_REG1, true);
commandBuffer[0] = writeCommand(MGMLIS3MDL::CTRL_REG1, true);
for (size_t i = 1; i <= NR_OF_CTRL_REGISTERS; i++) {
for (size_t i = 1; i <= MGMLIS3MDL::NR_OF_CTRL_REGISTERS; i++) {
commandBuffer[i] = registers[i];
}
rawPacket = commandBuffer;
rawPacketLen = NR_OF_CTRL_REGISTERS;
rawPacketLen = MGMLIS3MDL::NR_OF_CTRL_REGISTERS;
// We dont have to check if this is working because we just did it
return RETURN_OK;

123
mission/devices/MGMHandlerLIS3MDL.h
View File

@ -2,6 +2,7 @@
#define MISSION_DEVICES_MGMLIS3MDLHANDLER_H_
#include <fsfw/devicehandlers/DeviceHandlerBase.h>
#include "devicedefinitions/MGMHandlerLIS3Definitions.h"
#include <subsystemIdRanges.h>
/**
@ -13,22 +14,7 @@
*/
class MGMHandlerLIS3MDL: public DeviceHandlerBase {
public:
enum set {
ON, OFF
};
enum opMode {
LOW, MEDIUM, HIGH, ULTRA
};
static const uint8_t INTERFACE_ID = CLASS_ID::MGM_LIS3MDL;
static const DeviceCommandId_t SETUP_MGM = 0x00;
static const DeviceCommandId_t READALL_MGM = 0x01;
static const DeviceCommandId_t IDENTIFY_DEVICE = 0x02;
static const DeviceCommandId_t TEMP_SENSOR_ENABLE = 0x03;
static const DeviceCommandId_t ACCURACY_OP_MODE_SET = 0x04;
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MGM_LIS3MDL;
//Notifies a command to change the setup parameters
static const Event CHANGE_OF_SETUP_PARAMETER = MAKE_EVENT(0, SEVERITY::LOW);
@ -79,19 +65,21 @@ private:
/**
* This Method gets the full scale for the measurement range
* e.g.: +- 4 gauss
*
* e.g.: +- 4 gauss. See p.25 datasheet.
* @return The ReturnValue does not contain the sign of the value
*/
uint8_t getFullScale(uint8_t *reg2);
/**
* after detecting the fullScale the 16bit Value for the data is
* devided with the fullScale to the sensitivity of the scale
* The 16 bit value needs to be divided by the full range of a 16bit value
* and then multiplied with the current scale of the MGM.
* This factor returns the factor required to achieve this with
* one multiplication.
*
* @param scale is the return value of the getFulscale Method
* @return Multiplication factor to get the sensor value from raw data.
*/
float getSensitivity(uint8_t scale);
float getSensitivityFactor(uint8_t scale);
/**
* This Command detects the device ID
@ -119,110 +107,21 @@ private:
virtual ReturnValue_t setOperatingMode(const uint8_t *commandData,
size_t commandDataLen);
//Number of all control registers
static const uint8_t NR_OF_CTRL_REGISTERS = 5;
//Number of registers in the MGM
static const uint8_t NR_OF_REGISTERS = 19;
//Total number of adresses for all registers
static const uint8_t TOTAL_NR_OF_ADRESSES = 52;
static const uint8_t SETUP_REPLY = 6;
//Length a sindgle command SPI answer
static const uint8_t SINGLE_COMMAND_ANSWER_LEN = 2;
/*------------------------------------------------------------------------*/
/* Register adresses */
/*------------------------------------------------------------------------*/
// Register adress returns identifier of device with default 0b00111101
static const uint8_t IDENTIFYDEVICE = 0b00001111;
static const uint8_t DEVICEID = 0b00111101; // Identifier for Device
//Register adress to access register 1
static const uint8_t CTRL_REG1 = 0b00100000;
//Register adress to access register 2
static const uint8_t CTRL_REG2 = 0b00100001;
//Register adress to access register 3
static const uint8_t CTRL_REG3 = 0b00100010;
//Register adress to access register 4
static const uint8_t CTRL_REG4 = 0b00100011;
//Register adress to access register 5
static const uint8_t CTRL_REG5 = 0b00100100;
//Register adress to access status register
static const uint8_t STATUS_REG = 0b00100111;
//Register adress to access low byte of x-axis
static const uint8_t X_LOWBYTE = 0b00101000;
//Register adress to access high byte of x-axis
static const uint8_t X_HIGHBYTE = 0b00101001;
//Register adress to access low byte of y-axis
static const uint8_t Y_LOWBYTE = 0b00101010;
//Register adress to access high byte of y-axis
static const uint8_t Y_HIGHBYTE = 0b00101011;
//Register adress to access low byte of z-axis
static const uint8_t Z_LOWBYTE = 0b00101100;
//Register adress to access high byte of z-axis
static const uint8_t Z_HIGHBYTE = 0b00101101;
//Register adress to access low byte of temperature sensor
static const uint8_t TEMP_LOWBYTE = 0b00101110;
//Register adress to access high byte of temperature sensor
static const uint8_t TEMP_HIGHBYTE = 0b00101111;
/*------------------------------------------------------------------------*/
/* Initialize Setup Register set bits
/*------------------------------------------------------------------------*/
/* General transfer bits */
// Read=1 / Write=0 Bit
static const uint8_t RW_BIT = 7;
// Continous Read/Write Bit, increment adress
static const uint8_t MS_BIT = 6;
/* CTRL_REG1 bits */
static const uint8_t ST = 0; // Self test enable bit, enabled = 1
// Enable rates higher than 80 Hz enabled = 1
static const uint8_t FAST_ODR = 1;
static const uint8_t DO0 = 2; // Output data rate bit 2
static const uint8_t DO1 = 3; // Output data rate bit 3
static const uint8_t DO2 = 4; // Output data rate bit 4
static const uint8_t OM0 = 5; // XY operating mode bit 5
static const uint8_t OM1 = 6; // XY operating mode bit 6
static const uint8_t TEMP_EN = 7; // Temperature sensor enable enabled = 1
/* CTRL_REG2 bits */
//reset configuration registers and user registers
static const uint8_t SOFT_RST = 2;
static const uint8_t REBOOT = 3; //reboot memory content
static const uint8_t FSO = 5; //full-scale selection bit 5
static const uint8_t FS1 = 6; //full-scale selection bit 6
/* CTRL_REG3 bits */
static const uint8_t MD0 = 0; //Operating mode bit 0
static const uint8_t MD1 = 1; //Operating mode bit 1
//SPI serial interface mode selection enabled = 3-wire-mode
static const uint8_t SIM = 2;
static const uint8_t LP = 5; //low-power mode
/* CTRL_REG4 bits */
//big/little endian data selection enabled = MSb at lower adress
static const uint8_t BLE = 1;
static const uint8_t OMZ0 = 2; //Z operating mode bit 2
static const uint8_t OMZ1 = 3; //Z operating mode bit 3
/* CTRL_REG5 bits */
static const uint8_t BDU = 6; //Block data update
static const uint8_t FAST_READ = 7; //Fast read enabled = 1
//Single SPIcommand has 2 bytes, first for adress, second for content
size_t singleComandSize = 2;
//has the size for all adresses of the lis3mdl + the continous write bit
uint8_t commandBuffer[TOTAL_NR_OF_ADRESSES + 1];
uint8_t commandBuffer[MGMLIS3MDL::TOTAL_NR_OF_ADRESSES + 1];
/**
* We want to save the registers we set, so we dont have to read the
* registers when we want to change something.
* --> everytime we change set a register we have to save it
*/
uint8_t registers[NR_OF_CTRL_REGISTERS];
uint8_t registers[MGMLIS3MDL::NR_OF_CTRL_REGISTERS];
/**
* As this is a SPI Device, we get the Answer of the last sent command in

1
mission/devices/MGMHandlerRM3100.h
View File

@ -1,6 +1,7 @@
#ifndef MISSION_DEVICES_MGMRM3100HANDLER_H_
#define MISSION_DEVICES_MGMRM3100HANDLER_H_
#include "devicedefinitions/MGMHandlerRM3100Definitions.h"
#include <fsfw/devicehandlers/DeviceHandlerBase.h>
class MGMHandlerRM3100: public DeviceHandlerBase {

115
mission/devices/devicedefinitions/MGMHandlerLIS3Definitions.h Normal file
View File

@ -0,0 +1,115 @@
#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_MGMHANDLERLIS3DEFINITIONS_H_
#define MISSION_DEVICES_DEVICEDEFINITIONS_MGMHANDLERLIS3DEFINITIONS_H_
#include <cstdint>
namespace MGMLIS3MDL {
enum set {
ON, OFF
};
enum opMode {
LOW, MEDIUM, HIGH, ULTRA
};
static const DeviceCommandId_t SETUP_MGM = 0x00;
static const DeviceCommandId_t READALL_MGM = 0x01;
static const DeviceCommandId_t IDENTIFY_DEVICE = 0x02;
static const DeviceCommandId_t TEMP_SENSOR_ENABLE = 0x03;
static const DeviceCommandId_t ACCURACY_OP_MODE_SET = 0x04;
//Number of all control registers
static const uint8_t NR_OF_CTRL_REGISTERS = 5;
//Number of registers in the MGM
static const uint8_t NR_OF_REGISTERS = 19;
//Total number of adresses for all registers
static const uint8_t TOTAL_NR_OF_ADRESSES = 52;
static const uint8_t SETUP_REPLY = 6;
/*------------------------------------------------------------------------*/
/* Register adresses */
/*------------------------------------------------------------------------*/
// Register adress returns identifier of device with default 0b00111101
static const uint8_t IDENTIFY_DEVICE_REG_ADDR = 0b00001111;
static const uint8_t DEVICE_ID = 0b00111101; // Identifier for Device
//Register adress to access register 1
static const uint8_t CTRL_REG1 = 0b00100000;
//Register adress to access register 2
static const uint8_t CTRL_REG2 = 0b00100001;
//Register adress to access register 3
static const uint8_t CTRL_REG3 = 0b00100010;
//Register adress to access register 4
static const uint8_t CTRL_REG4 = 0b00100011;
//Register adress to access register 5
static const uint8_t CTRL_REG5 = 0b00100100;
//Register adress to access status register
static const uint8_t STATUS_REG = 0b00100111;
//Register adress to access low byte of x-axis
static const uint8_t X_LOWBYTE = 0b00101000;
//Register adress to access high byte of x-axis
static const uint8_t X_HIGHBYTE = 0b00101001;
//Register adress to access low byte of y-axis
static const uint8_t Y_LOWBYTE = 0b00101010;
//Register adress to access high byte of y-axis
static const uint8_t Y_HIGHBYTE = 0b00101011;
//Register adress to access low byte of z-axis
static const uint8_t Z_LOWBYTE = 0b00101100;
//Register adress to access high byte of z-axis
static const uint8_t Z_HIGHBYTE = 0b00101101;
//Register adress to access low byte of temperature sensor
static const uint8_t TEMP_LOWBYTE = 0b00101110;
//Register adress to access high byte of temperature sensor
static const uint8_t TEMP_HIGHBYTE = 0b00101111;
/*------------------------------------------------------------------------*/
/* Initialize Setup Register set bits
/*------------------------------------------------------------------------*/
/* General transfer bits */
// Read=1 / Write=0 Bit
static const uint8_t RW_BIT = 7;
// Continous Read/Write Bit, increment adress
static const uint8_t MS_BIT = 6;
/* CTRL_REG1 bits */
static const uint8_t ST = 0; // Self test enable bit, enabled = 1
// Enable rates higher than 80 Hz enabled = 1
static const uint8_t FAST_ODR = 1;
static const uint8_t DO0 = 2; // Output data rate bit 2
static const uint8_t DO1 = 3; // Output data rate bit 3
static const uint8_t DO2 = 4; // Output data rate bit 4
static const uint8_t OM0 = 5; // XY operating mode bit 5
static const uint8_t OM1 = 6; // XY operating mode bit 6
static const uint8_t TEMP_EN = 7; // Temperature sensor enable enabled = 1
/* CTRL_REG2 bits */
//reset configuration registers and user registers
static const uint8_t SOFT_RST = 2;
static const uint8_t REBOOT = 3; //reboot memory content
static const uint8_t FSO = 5; //full-scale selection bit 5
static const uint8_t FS1 = 6; //full-scale selection bit 6
/* CTRL_REG3 bits */
static const uint8_t MD0 = 0; //Operating mode bit 0
static const uint8_t MD1 = 1; //Operating mode bit 1
//SPI serial interface mode selection enabled = 3-wire-mode
static const uint8_t SIM = 2;
static const uint8_t LP = 5; //low-power mode
/* CTRL_REG4 bits */
//big/little endian data selection enabled = MSb at lower adress
static const uint8_t BLE = 1;
static const uint8_t OMZ0 = 2; //Z operating mode bit 2
static const uint8_t OMZ1 = 3; //Z operating mode bit 3
/* CTRL_REG5 bits */
static const uint8_t BDU = 6; //Block data update
static const uint8_t FAST_READ = 7; //Fast read enabled = 1
}
#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_MGMHANDLERLIS3DEFINITIONS_H_ */

10
mission/devices/devicedefinitions/MGMHandlerRM3100Definitions.h Normal file
View File

@ -0,0 +1,10 @@
#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_MGMHANDLERRM3100DEFINITIONS_H_
#define MISSION_DEVICES_DEVICEDEFINITIONS_MGMHANDLERRM3100DEFINITIONS_H_
namespace RM3100 {
}
#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_MGMHANDLERRM3100DEFINITIONS_H_ */