263 lines
8.9 KiB
C++
263 lines
8.9 KiB
C++
#include "fsfw-hal/devicehandlers/GyroL3GD20Handler.h"
|
|
|
|
#include "fsfw/datapool/PoolReadGuard.h"
|
|
|
|
GyroHandlerL3GD20H::GyroHandlerL3GD20H(object_id_t objectId, object_id_t deviceCommunication,
|
|
CookieIF *comCookie):
|
|
DeviceHandlerBase(objectId, deviceCommunication, comCookie),
|
|
dataset(this) {
|
|
#if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
|
|
debugDivider = new PeriodicOperationDivider(5);
|
|
#endif
|
|
}
|
|
|
|
GyroHandlerL3GD20H::~GyroHandlerL3GD20H() {}
|
|
|
|
void GyroHandlerL3GD20H::doStartUp() {
|
|
if(internalState == InternalState::NONE) {
|
|
internalState = InternalState::CONFIGURE;
|
|
}
|
|
|
|
if(internalState == InternalState::CONFIGURE) {
|
|
if(commandExecuted) {
|
|
internalState = InternalState::CHECK_REGS;
|
|
commandExecuted = false;
|
|
}
|
|
}
|
|
|
|
if(internalState == InternalState::CHECK_REGS) {
|
|
if(commandExecuted) {
|
|
internalState = InternalState::NORMAL;
|
|
if(goNormalModeImmediately) {
|
|
setMode(MODE_NORMAL);
|
|
}
|
|
else {
|
|
setMode(_MODE_TO_ON);
|
|
}
|
|
commandExecuted = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void GyroHandlerL3GD20H::doShutDown() {
|
|
setMode(_MODE_POWER_DOWN);
|
|
}
|
|
|
|
ReturnValue_t GyroHandlerL3GD20H::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
|
|
switch(internalState) {
|
|
case(InternalState::NONE):
|
|
case(InternalState::NORMAL): {
|
|
return HasReturnvaluesIF::RETURN_OK;
|
|
}
|
|
case(InternalState::CONFIGURE): {
|
|
*id = L3GD20H::CONFIGURE_CTRL_REGS;
|
|
uint8_t command [5];
|
|
command[0] = L3GD20H::CTRL_REG_1_VAL;
|
|
command[1] = L3GD20H::CTRL_REG_2_VAL;
|
|
command[2] = L3GD20H::CTRL_REG_3_VAL;
|
|
command[3] = L3GD20H::CTRL_REG_4_VAL;
|
|
command[4] = L3GD20H::CTRL_REG_5_VAL;
|
|
return buildCommandFromCommand(*id, command, 5);
|
|
}
|
|
case(InternalState::CHECK_REGS): {
|
|
*id = L3GD20H::READ_REGS;
|
|
return buildCommandFromCommand(*id, nullptr, 0);
|
|
}
|
|
default:
|
|
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
|
/* Might be a configuration error. */
|
|
sif::debug << "GyroHandler::buildTransitionDeviceCommand: Unknown internal state!" <<
|
|
std::endl;
|
|
#else
|
|
sif::printDebug("GyroHandler::buildTransitionDeviceCommand: Unknown internal state!\n");
|
|
#endif
|
|
return HasReturnvaluesIF::RETURN_OK;
|
|
}
|
|
return HasReturnvaluesIF::RETURN_OK;
|
|
}
|
|
|
|
ReturnValue_t GyroHandlerL3GD20H::buildNormalDeviceCommand(DeviceCommandId_t *id) {
|
|
*id = L3GD20H::READ_REGS;
|
|
return buildCommandFromCommand(*id, nullptr, 0);
|
|
}
|
|
|
|
ReturnValue_t GyroHandlerL3GD20H::buildCommandFromCommand(
|
|
DeviceCommandId_t deviceCommand, const uint8_t *commandData,
|
|
size_t commandDataLen) {
|
|
switch(deviceCommand) {
|
|
case(L3GD20H::READ_REGS): {
|
|
commandBuffer[0] = L3GD20H::READ_START | L3GD20H::AUTO_INCREMENT_MASK | L3GD20H::READ_MASK;
|
|
std::memset(commandBuffer + 1, 0, L3GD20H::READ_LEN);
|
|
rawPacket = commandBuffer;
|
|
rawPacketLen = L3GD20H::READ_LEN + 1;
|
|
break;
|
|
}
|
|
case(L3GD20H::CONFIGURE_CTRL_REGS): {
|
|
commandBuffer[0] = L3GD20H::CTRL_REG_1 | L3GD20H::AUTO_INCREMENT_MASK;
|
|
if(commandData == nullptr or commandDataLen != 5) {
|
|
return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
|
|
}
|
|
|
|
ctrlReg1Value = commandData[0];
|
|
ctrlReg2Value = commandData[1];
|
|
ctrlReg3Value = commandData[2];
|
|
ctrlReg4Value = commandData[3];
|
|
ctrlReg5Value = commandData[4];
|
|
|
|
bool fsH = ctrlReg4Value & L3GD20H::SET_FS_1;
|
|
bool fsL = ctrlReg4Value & L3GD20H::SET_FS_0;
|
|
|
|
if(not fsH and not fsL) {
|
|
sensitivity = L3GD20H::SENSITIVITY_00;
|
|
}
|
|
else if(not fsH and fsL) {
|
|
sensitivity = L3GD20H::SENSITIVITY_01;
|
|
}
|
|
else {
|
|
sensitivity = L3GD20H::SENSITIVITY_11;
|
|
}
|
|
|
|
commandBuffer[1] = ctrlReg1Value;
|
|
commandBuffer[2] = ctrlReg2Value;
|
|
commandBuffer[3] = ctrlReg3Value;
|
|
commandBuffer[4] = ctrlReg4Value;
|
|
commandBuffer[5] = ctrlReg5Value;
|
|
|
|
rawPacket = commandBuffer;
|
|
rawPacketLen = 6;
|
|
break;
|
|
}
|
|
case(L3GD20H::READ_CTRL_REGS): {
|
|
commandBuffer[0] = L3GD20H::READ_START | L3GD20H::AUTO_INCREMENT_MASK |
|
|
L3GD20H::READ_MASK;
|
|
|
|
std::memset(commandBuffer + 1, 0, 5);
|
|
rawPacket = commandBuffer;
|
|
rawPacketLen = 6;
|
|
break;
|
|
}
|
|
default:
|
|
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
|
|
}
|
|
return HasReturnvaluesIF::RETURN_OK;
|
|
}
|
|
|
|
ReturnValue_t GyroHandlerL3GD20H::scanForReply(const uint8_t *start, size_t len,
|
|
DeviceCommandId_t *foundId, size_t *foundLen) {
|
|
/* For SPI, the ID will always be the one of the last sent command. */
|
|
*foundId = this->getPendingCommand();
|
|
*foundLen = this->rawPacketLen;
|
|
|
|
return HasReturnvaluesIF::RETURN_OK;
|
|
}
|
|
|
|
ReturnValue_t GyroHandlerL3GD20H::interpretDeviceReply(DeviceCommandId_t id,
|
|
const uint8_t *packet) {
|
|
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
|
switch(id) {
|
|
case(L3GD20H::CONFIGURE_CTRL_REGS): {
|
|
commandExecuted = true;
|
|
break;
|
|
}
|
|
case(L3GD20H::READ_CTRL_REGS): {
|
|
if(packet[1] == ctrlReg1Value and packet[2] == ctrlReg2Value and
|
|
packet[3] == ctrlReg3Value and packet[4] == ctrlReg4Value and
|
|
packet[5] == ctrlReg5Value) {
|
|
commandExecuted = true;
|
|
}
|
|
else {
|
|
/* Attempt reconfiguration. */
|
|
internalState = InternalState::CONFIGURE;
|
|
return DeviceHandlerIF::DEVICE_REPLY_INVALID;
|
|
}
|
|
break;
|
|
}
|
|
case(L3GD20H::READ_REGS): {
|
|
if(packet[1] != ctrlReg1Value and packet[2] != ctrlReg2Value and
|
|
packet[3] != ctrlReg3Value and packet[4] != ctrlReg4Value and
|
|
packet[5] != ctrlReg5Value) {
|
|
return DeviceHandlerIF::DEVICE_REPLY_INVALID;
|
|
}
|
|
else {
|
|
if(internalState == InternalState::CHECK_REGS) {
|
|
commandExecuted = true;
|
|
}
|
|
}
|
|
|
|
statusReg = packet[L3GD20H::STATUS_IDX];
|
|
|
|
int16_t angVelocXRaw = packet[L3GD20H::OUT_X_H] << 8 | packet[L3GD20H::OUT_X_L];
|
|
int16_t angVelocYRaw = packet[L3GD20H::OUT_Y_H] << 8 | packet[L3GD20H::OUT_Y_L];
|
|
int16_t angVelocZRaw = packet[L3GD20H::OUT_Z_H] << 8 | packet[L3GD20H::OUT_Z_L];
|
|
float angVelocX = angVelocXRaw * sensitivity;
|
|
float angVelocY = angVelocYRaw * sensitivity;
|
|
float angVelocZ = angVelocZRaw * sensitivity;
|
|
|
|
int8_t temperaturOffset = (-1) * packet[L3GD20H::TEMPERATURE_IDX];
|
|
float temperature = 25.0 + temperaturOffset;
|
|
#if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
|
|
if(debugDivider->checkAndIncrement()) {
|
|
/* Set terminal to utf-8 if there is an issue with micro printout. */
|
|
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
|
sif::info << "GyroHandlerL3GD20H: Angular velocities in degrees per second:" <<
|
|
std::endl;
|
|
sif::info << "X: " << angVelocX << " \xC2\xB0" << std::endl;
|
|
sif::info << "Y: " << angVelocY << " \xC2\xB0" << std::endl;
|
|
sif::info << "Z: " << angVelocZ << " \xC2\xB0" << std::endl;
|
|
#else
|
|
sif::printInfo("GyroHandlerL3GD20H: Angular velocities in degrees per second:\n");
|
|
sif::printInfo("X: %f\n", angVelocX);
|
|
sif::printInfo("Y: %f\n", angVelocY);
|
|
sif::printInfo("Z: %f\n", angVelocZ);
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
PoolReadGuard readSet(&dataset);
|
|
if(readSet.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
|
|
dataset.angVelocX = angVelocX;
|
|
dataset.angVelocY = angVelocY;
|
|
dataset.angVelocZ = angVelocZ;
|
|
dataset.temperature = temperature;
|
|
dataset.setValidity(true, true);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
uint32_t GyroHandlerL3GD20H::getTransitionDelayMs(Mode_t from, Mode_t to) {
|
|
return 10000;
|
|
}
|
|
|
|
void GyroHandlerL3GD20H::setGoNormalModeAtStartup() {
|
|
this->goNormalModeImmediately = true;
|
|
}
|
|
|
|
ReturnValue_t GyroHandlerL3GD20H::initializeLocalDataPool(
|
|
localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
|
|
localDataPoolMap.emplace(L3GD20H::ANG_VELOC_X,
|
|
new PoolEntry<float>({0.0}));
|
|
localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Y,
|
|
new PoolEntry<float>({0.0}));
|
|
localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Z,
|
|
new PoolEntry<float>({0.0}));
|
|
localDataPoolMap.emplace(L3GD20H::TEMPERATURE,
|
|
new PoolEntry<float>({0.0}));
|
|
return HasReturnvaluesIF::RETURN_OK;
|
|
}
|
|
|
|
void GyroHandlerL3GD20H::fillCommandAndReplyMap() {
|
|
insertInCommandAndReplyMap(L3GD20H::READ_REGS, 1, &dataset);
|
|
insertInCommandAndReplyMap(L3GD20H::CONFIGURE_CTRL_REGS, 1);
|
|
insertInCommandAndReplyMap(L3GD20H::READ_CTRL_REGS, 1);
|
|
}
|
|
|
|
void GyroHandlerL3GD20H::modeChanged() {
|
|
internalState = InternalState::NONE;
|
|
}
|