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

improved chip select decoding
All checks were successful
EIVE/eive-obsw/pipeline/head This commit looks good
Details

Browse Source
This commit is contained in:
Markus Koller 2021-10-19 14:45:22 +02:00
parent b7cd192185
commit 65b0376f69
8 changed files with 720 additions and 538 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
bsp_q7s/callbacks/rwSpiCallback.cpp
View File

@ -23,6 +23,16 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sen
uint8_t writeBuffer[2]; uint8_t writeBuffer[2];
uint8_t writeSize = 0; uint8_t writeSize = 0;
gpioId_t gpioId = cookie->getChipSelectPin();
GpioIF* gpioIF = comIf->getGpioInterface();
MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
uint32_t timeoutMs = 0;
MutexIF* mutex = comIf->getMutex(&timeoutType, &timeoutMs);
if(mutex == nullptr or gpioIF == nullptr) {
sif::debug << "rwSpiCallback::spiCallback: Mutex or GPIO interface invalid" << std::endl;
return HasReturnvaluesIF::RETURN_FAILED;
}
int fileDescriptor = 0; int fileDescriptor = 0;
std::string device = cookie->getSpiDevice(); std::string device = cookie->getSpiDevice();
UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "rwSpiCallback::spiCallback"); UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "rwSpiCallback::spiCallback");
@ -30,20 +40,10 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sen
sif::error << "rwSpiCallback::spiCallback: Failed to open device file" << std::endl; sif::error << "rwSpiCallback::spiCallback: Failed to open device file" << std::endl;
return SpiComIF::OPENING_FILE_FAILED; return SpiComIF::OPENING_FILE_FAILED;
} }
spi::SpiModes spiMode = spi::SpiModes::MODE_0; // spi::SpiModes spiMode = spi::SpiModes::MODE_0;
uint32_t spiSpeed = 0; // uint32_t spiSpeed = 0;
cookie->getSpiParameters(spiMode, spiSpeed, nullptr); // cookie->getSpiParameters(spiMode, spiSpeed, nullptr);
comIf->setSpiSpeedAndMode(fileDescriptor, spiMode, spiSpeed); // comIf->setSpiSpeedAndMode(fileDescriptor, spiMode, spiSpeed);
gpioId_t gpioId = cookie->getChipSelectPin();
GpioIF* gpioIF = comIf->getGpioInterface();
MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
uint32_t timeoutMs = 0;
MutexIF* mutex = comIf->getMutex(&timeoutType, &timeoutMs);
if(mutex == nullptr or gpioIF == nullptr) {
sif::debug << "rwSpiCallback::spiCallback: Mutex or GPIO interface invalid" << std::endl;
return HasReturnvaluesIF::RETURN_FAILED;
}
result = mutex->lockMutex(timeoutType, timeoutMs); result = mutex->lockMutex(timeoutType, timeoutMs);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
@ -119,7 +119,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sen
size_t replyBufferSize = cookie->getMaxBufferSize(); size_t replyBufferSize = cookie->getMaxBufferSize();
/** There must be a delay of 20 ms after sending the command */ /** There must be a delay of at least 20 ms after sending the command */
usleep(RwDefinitions::SPI_REPLY_DELAY); usleep(RwDefinitions::SPI_REPLY_DELAY);
/** /**

149
bsp_q7s/core/ObjectFactory.cpp
View File

@ -268,7 +268,8 @@ void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
SpiCookie* spiCookieRadSensor = new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, SpiCookie* spiCookieRadSensor = new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR,
std::string(q7s::SPI_DEFAULT_DEV), RAD_SENSOR::READ_SIZE, spi::DEFAULT_MAX_1227_MODE, std::string(q7s::SPI_DEFAULT_DEV), RAD_SENSOR::READ_SIZE, spi::DEFAULT_MAX_1227_MODE,
spi::DEFAULT_MAX_1227_SPEED); spi::DEFAULT_MAX_1227_SPEED);
new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_COM_IF, spiCookieRadSensor); RadiationSensorHandler* radsensor = new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_COM_IF, spiCookieRadSensor);
radsensor->setStartUpImmediately();
} }
void ObjectFactory::createSunSensorComponents(LinuxLibgpioIF *gpioComIF, SpiComIF* spiComIF) { void ObjectFactory::createSunSensorComponents(LinuxLibgpioIF *gpioComIF, SpiComIF* spiComIF) {
@ -641,139 +642,149 @@ void ObjectFactory::createSyrlinksComponents() {
void ObjectFactory::createRtdComponents(LinuxLibgpioIF *gpioComIF) { void ObjectFactory::createRtdComponents(LinuxLibgpioIF *gpioComIF) {
GpioCookie* rtdGpioCookie = new GpioCookie; GpioCookie* rtdGpioCookie = new GpioCookie;
GpioCallback* gpioRtdIc0 = new GpioCallback("Chip select RTD IC0", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_3, gpioRtdIc0);
GpioCallback* gpioRtdIc1 = new GpioCallback("Chip select RTD IC1", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_4, gpioRtdIc1);
GpioCallback* gpioRtdIc2 = new GpioCallback("Chip select RTD IC2", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_5, gpioRtdIc2);
GpioCallback* gpioRtdIc3 = new GpioCallback("Chip select RTD IC3", gpio::OUT, gpio::HIGH, GpioCallback* gpioRtdIc3 = new GpioCallback("Chip select RTD IC3", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF); &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_6, gpioRtdIc3); rtdGpioCookie->addGpio(gpioIds::RTD_IC_3, gpioRtdIc3);
GpioCallback* gpioRtdIc4 = new GpioCallback("Chip select RTD IC4", gpio::OUT, gpio::HIGH, GpioCallback* gpioRtdIc4 = new GpioCallback("Chip select RTD IC4", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF); &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_7, gpioRtdIc4); rtdGpioCookie->addGpio(gpioIds::RTD_IC_4, gpioRtdIc4);
GpioCallback* gpioRtdIc5 = new GpioCallback("Chip select RTD IC5", gpio::OUT, gpio::HIGH, GpioCallback* gpioRtdIc5 = new GpioCallback("Chip select RTD IC5", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF); &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_8, gpioRtdIc5); rtdGpioCookie->addGpio(gpioIds::RTD_IC_5, gpioRtdIc5);
GpioCallback* gpioRtdIc6 = new GpioCallback("Chip select RTD IC6", gpio::OUT, gpio::HIGH, GpioCallback* gpioRtdIc6 = new GpioCallback("Chip select RTD IC6", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF); &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_9, gpioRtdIc6); rtdGpioCookie->addGpio(gpioIds::RTD_IC_6, gpioRtdIc6);
GpioCallback* gpioRtdIc7 = new GpioCallback("Chip select RTD IC7", gpio::OUT, gpio::HIGH, GpioCallback* gpioRtdIc7 = new GpioCallback("Chip select RTD IC7", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF); &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_10, gpioRtdIc7); rtdGpioCookie->addGpio(gpioIds::RTD_IC_7, gpioRtdIc7);
GpioCallback* gpioRtdIc8 = new GpioCallback("Chip select RTD IC8", gpio::OUT, gpio::HIGH, GpioCallback* gpioRtdIc8 = new GpioCallback("Chip select RTD IC8", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF); &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_11, gpioRtdIc8); rtdGpioCookie->addGpio(gpioIds::RTD_IC_8, gpioRtdIc8);
GpioCallback* gpioRtdIc9 = new GpioCallback("Chip select RTD IC9", gpio::OUT, gpio::HIGH, GpioCallback* gpioRtdIc9 = new GpioCallback("Chip select RTD IC9", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF); &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_12, gpioRtdIc9); rtdGpioCookie->addGpio(gpioIds::RTD_IC_9, gpioRtdIc9);
GpioCallback* gpioRtdIc10 = new GpioCallback("Chip select RTD IC10", gpio::OUT, gpio::HIGH, GpioCallback* gpioRtdIc10 = new GpioCallback("Chip select RTD IC10", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF); &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_13, gpioRtdIc10); rtdGpioCookie->addGpio(gpioIds::RTD_IC_10, gpioRtdIc10);
GpioCallback* gpioRtdIc11 = new GpioCallback("Chip select RTD IC11", gpio::OUT, gpio::HIGH, GpioCallback* gpioRtdIc11 = new GpioCallback("Chip select RTD IC11", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF); &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_14, gpioRtdIc11); rtdGpioCookie->addGpio(gpioIds::RTD_IC_11, gpioRtdIc11);
GpioCallback* gpioRtdIc12 = new GpioCallback("Chip select RTD IC12", gpio::OUT, gpio::HIGH, GpioCallback* gpioRtdIc12 = new GpioCallback("Chip select RTD IC12", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF); &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_15, gpioRtdIc12); rtdGpioCookie->addGpio(gpioIds::RTD_IC_12, gpioRtdIc12);
GpioCallback* gpioRtdIc13 = new GpioCallback("Chip select RTD IC13", gpio::OUT, gpio::HIGH, GpioCallback* gpioRtdIc13 = new GpioCallback("Chip select RTD IC13", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF); &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_16, gpioRtdIc13); rtdGpioCookie->addGpio(gpioIds::RTD_IC_13, gpioRtdIc13);
GpioCallback* gpioRtdIc14 = new GpioCallback("Chip select RTD IC14", gpio::OUT, gpio::HIGH, GpioCallback* gpioRtdIc14 = new GpioCallback("Chip select RTD IC14", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF); &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_17, gpioRtdIc14); rtdGpioCookie->addGpio(gpioIds::RTD_IC_14, gpioRtdIc14);
GpioCallback* gpioRtdIc15 = new GpioCallback("Chip select RTD IC15", gpio::OUT, gpio::HIGH, GpioCallback* gpioRtdIc15 = new GpioCallback("Chip select RTD IC15", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF); &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_18, gpioRtdIc15); rtdGpioCookie->addGpio(gpioIds::RTD_IC_15, gpioRtdIc15);
GpioCallback* gpioRtdIc16 = new GpioCallback("Chip select RTD IC16", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_16, gpioRtdIc16);
GpioCallback* gpioRtdIc17 = new GpioCallback("Chip select RTD IC17", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_17, gpioRtdIc17);
GpioCallback* gpioRtdIc18 = new GpioCallback("Chip select RTD IC18", gpio::OUT, gpio::HIGH,
&gpioCallbacks::spiCsDecoderCallback, gpioComIF);
rtdGpioCookie->addGpio(gpioIds::RTD_IC_18, gpioRtdIc18);
gpioComIF->addGpios(rtdGpioCookie); gpioComIF->addGpios(rtdGpioCookie);
SpiCookie* spiRtdIc0 = new SpiCookie(addresses::RTD_IC_3, gpioIds::RTD_IC_3, q7s::SPI_DEFAULT_DEV, SpiCookie* spiRtdIc3 = new SpiCookie(addresses::RTD_IC_3, gpioIds::RTD_IC_3, q7s::SPI_DEFAULT_DEV,
Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, spi::RTD_SPEED); Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, spi::RTD_SPEED);
SpiCookie* spiRtdIc1 = new SpiCookie(addresses::RTD_IC_4, gpioIds::RTD_IC_4, q7s::SPI_DEFAULT_DEV, SpiCookie* spiRtdIc4 = new SpiCookie(addresses::RTD_IC_4, gpioIds::RTD_IC_4, q7s::SPI_DEFAULT_DEV,
Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, spi::RTD_SPEED); Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, spi::RTD_SPEED);
SpiCookie* spiRtdIc2 = new SpiCookie(addresses::RTD_IC_5, gpioIds::RTD_IC_5, q7s::SPI_DEFAULT_DEV, SpiCookie* spiRtdIc5 = new SpiCookie(addresses::RTD_IC_5, gpioIds::RTD_IC_5, q7s::SPI_DEFAULT_DEV,
Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, spi::RTD_SPEED); Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, spi::RTD_SPEED);
SpiCookie* spiRtdIc3 = new SpiCookie(addresses::RTD_IC_6, gpioIds::RTD_IC_6, q7s::SPI_DEFAULT_DEV, SpiCookie* spiRtdIc6 = new SpiCookie(addresses::RTD_IC_6, gpioIds::RTD_IC_6, q7s::SPI_DEFAULT_DEV,
Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, spi::RTD_SPEED); Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, spi::RTD_SPEED);
SpiCookie* spiRtdIc4 = new SpiCookie(addresses::RTD_IC_7, gpioIds::RTD_IC_7, q7s::SPI_DEFAULT_DEV, SpiCookie* spiRtdIc7 = new SpiCookie(addresses::RTD_IC_7, gpioIds::RTD_IC_7, q7s::SPI_DEFAULT_DEV,
Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, spi::RTD_SPEED); Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, spi::RTD_SPEED);
SpiCookie* spiRtdIc5 = new SpiCookie(addresses::RTD_IC_8, gpioIds::RTD_IC_8, q7s::SPI_DEFAULT_DEV, SpiCookie* spiRtdIc8 = new SpiCookie(addresses::RTD_IC_8, gpioIds::RTD_IC_8, q7s::SPI_DEFAULT_DEV,
Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, spi::RTD_SPEED); Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, spi::RTD_SPEED);
SpiCookie* spiRtdIc6 = new SpiCookie(addresses::RTD_IC_9, gpioIds::RTD_IC_9, q7s::SPI_DEFAULT_DEV, SpiCookie* spiRtdIc9 = new SpiCookie(addresses::RTD_IC_9, gpioIds::RTD_IC_9, q7s::SPI_DEFAULT_DEV,
Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, spi::RTD_SPEED); Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, spi::RTD_SPEED);
SpiCookie* spiRtdIc7 = new SpiCookie(addresses::RTD_IC_10, gpioIds::RTD_IC_10, SpiCookie* spiRtdIc10 = new SpiCookie(addresses::RTD_IC_10, gpioIds::RTD_IC_10,
q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1,
spi::RTD_SPEED); spi::RTD_SPEED);
SpiCookie* spiRtdIc8 = new SpiCookie(addresses::RTD_IC_11, gpioIds::RTD_IC_11, SpiCookie* spiRtdIc11 = new SpiCookie(addresses::RTD_IC_11, gpioIds::RTD_IC_11,
q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1,
spi::RTD_SPEED); spi::RTD_SPEED);
SpiCookie* spiRtdIc9 = new SpiCookie(addresses::RTD_IC_12, gpioIds::RTD_IC_12, SpiCookie* spiRtdIc12 = new SpiCookie(addresses::RTD_IC_12, gpioIds::RTD_IC_12,
q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1,
spi::RTD_SPEED); spi::RTD_SPEED);
SpiCookie* spiRtdIc10 = new SpiCookie(addresses::RTD_IC_13, gpioIds::RTD_IC_13, SpiCookie* spiRtdIc13 = new SpiCookie(addresses::RTD_IC_13, gpioIds::RTD_IC_13,
q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1,
spi::RTD_SPEED); spi::RTD_SPEED);
SpiCookie* spiRtdIc11 = new SpiCookie(addresses::RTD_IC_14, gpioIds::RTD_IC_14, SpiCookie* spiRtdIc14 = new SpiCookie(addresses::RTD_IC_14, gpioIds::RTD_IC_14,
q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1,
spi::RTD_SPEED); spi::RTD_SPEED);
SpiCookie* spiRtdIc12 = new SpiCookie(addresses::RTD_IC_15, gpioIds::RTD_IC_15, SpiCookie* spiRtdIc15 = new SpiCookie(addresses::RTD_IC_15, gpioIds::RTD_IC_15,
q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1,
spi::RTD_SPEED); spi::RTD_SPEED);
SpiCookie* spiRtdIc13 = new SpiCookie(addresses::RTD_IC_16, gpioIds::RTD_IC_16, SpiCookie* spiRtdIc16 = new SpiCookie(addresses::RTD_IC_16, gpioIds::RTD_IC_16,
std::string(q7s::SPI_DEFAULT_DEV), Max31865Definitions::MAX_REPLY_SIZE, std::string(q7s::SPI_DEFAULT_DEV), Max31865Definitions::MAX_REPLY_SIZE,
spi::SpiModes::MODE_1, spi::RTD_SPEED); spi::SpiModes::MODE_1, spi::RTD_SPEED);
SpiCookie* spiRtdIc14 = new SpiCookie(addresses::RTD_IC_17, gpioIds::RTD_IC_17, SpiCookie* spiRtdIc17 = new SpiCookie(addresses::RTD_IC_17, gpioIds::RTD_IC_17,
q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1,
spi::RTD_SPEED); spi::RTD_SPEED);
SpiCookie* spiRtdIc15 = new SpiCookie(addresses::RTD_IC_18, gpioIds::RTD_IC_18, SpiCookie* spiRtdIc18 = new SpiCookie(addresses::RTD_IC_18, gpioIds::RTD_IC_18,
q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1, q7s::SPI_DEFAULT_DEV, Max31865Definitions::MAX_REPLY_SIZE, spi::SpiModes::MODE_1,
spi::RTD_SPEED); spi::RTD_SPEED);
Max31865PT1000Handler* rtdIc0 = new Max31865PT1000Handler(objects::RTD_IC_6, objects::SPI_COM_IF, Max31865PT1000Handler* rtdIc3 = new Max31865PT1000Handler(objects::RTD_IC_3, objects::SPI_COM_IF,
spiRtdIc0);
Max31865PT1000Handler* rtdIc1 = new Max31865PT1000Handler(objects::RTD_IC_4, objects::SPI_COM_IF,
spiRtdIc1);
Max31865PT1000Handler* rtdIc2 = new Max31865PT1000Handler(objects::RTD_IC_5, objects::SPI_COM_IF,
spiRtdIc2);
Max31865PT1000Handler* rtdIc3 = new Max31865PT1000Handler(objects::RTD_IC_6, objects::SPI_COM_IF,
spiRtdIc3); spiRtdIc3);
Max31865PT1000Handler* rtdIc4 = new Max31865PT1000Handler(objects::RTD_IC_7, objects::SPI_COM_IF, Max31865PT1000Handler* rtdIc4 = new Max31865PT1000Handler(objects::RTD_IC_4, objects::SPI_COM_IF,
spiRtdIc4); spiRtdIc4);
Max31865PT1000Handler* rtdIc5 = new Max31865PT1000Handler(objects::RTD_IC_8, objects::SPI_COM_IF, Max31865PT1000Handler* rtdIc5 = new Max31865PT1000Handler(objects::RTD_IC_5, objects::SPI_COM_IF,
spiRtdIc5); spiRtdIc5);
Max31865PT1000Handler* rtdIc6 = new Max31865PT1000Handler(objects::RTD_IC_9, objects::SPI_COM_IF, Max31865PT1000Handler* rtdIc6 = new Max31865PT1000Handler(objects::RTD_IC_6, objects::SPI_COM_IF,
spiRtdIc6); spiRtdIc6);
Max31865PT1000Handler* rtdIc7 = new Max31865PT1000Handler(objects::RTD_IC_10, Max31865PT1000Handler* rtdIc7 = new Max31865PT1000Handler(objects::RTD_IC_7, objects::SPI_COM_IF,
objects::SPI_COM_IF, spiRtdIc7); spiRtdIc7);
Max31865PT1000Handler* rtdIc8 = new Max31865PT1000Handler(objects::RTD_IC_11, Max31865PT1000Handler* rtdIc8 = new Max31865PT1000Handler(objects::RTD_IC_8, objects::SPI_COM_IF,
objects::SPI_COM_IF, spiRtdIc8); spiRtdIc8);
Max31865PT1000Handler* rtdIc9 = new Max31865PT1000Handler(objects::RTD_IC_12, Max31865PT1000Handler* rtdIc9 = new Max31865PT1000Handler(objects::RTD_IC_9, objects::SPI_COM_IF,
objects::SPI_COM_IF, spiRtdIc9); spiRtdIc9);
Max31865PT1000Handler* rtdIc10 = new Max31865PT1000Handler(objects::RTD_IC_13, Max31865PT1000Handler* rtdIc10 = new Max31865PT1000Handler(objects::RTD_IC_10,
objects::SPI_COM_IF, spiRtdIc10); objects::SPI_COM_IF, spiRtdIc10);
Max31865PT1000Handler* rtdIc11 = new Max31865PT1000Handler(objects::RTD_IC_14, Max31865PT1000Handler* rtdIc11 = new Max31865PT1000Handler(objects::RTD_IC_11,
objects::SPI_COM_IF, spiRtdIc11); objects::SPI_COM_IF, spiRtdIc11);
Max31865PT1000Handler* rtdIc12 = new Max31865PT1000Handler(objects::RTD_IC_15, Max31865PT1000Handler* rtdIc12 = new Max31865PT1000Handler(objects::RTD_IC_12,
objects::SPI_COM_IF, spiRtdIc12); objects::SPI_COM_IF, spiRtdIc12);
Max31865PT1000Handler* rtdIc13 = new Max31865PT1000Handler(objects::RTD_IC_16, Max31865PT1000Handler* rtdIc13 = new Max31865PT1000Handler(objects::RTD_IC_13,
objects::SPI_COM_IF, spiRtdIc13); objects::SPI_COM_IF, spiRtdIc13);
Max31865PT1000Handler* rtdIc14 = new Max31865PT1000Handler(objects::RTD_IC_17, Max31865PT1000Handler* rtdIc14 = new Max31865PT1000Handler(objects::RTD_IC_14,
objects::SPI_COM_IF, spiRtdIc14); objects::SPI_COM_IF, spiRtdIc14);
Max31865PT1000Handler* rtdIc15 = new Max31865PT1000Handler(objects::RTD_IC_18, Max31865PT1000Handler* rtdIc15 = new Max31865PT1000Handler(objects::RTD_IC_15,
objects::SPI_COM_IF, spiRtdIc15); objects::SPI_COM_IF, spiRtdIc15);
Max31865PT1000Handler* rtdIc16 = new Max31865PT1000Handler(objects::RTD_IC_16,
objects::SPI_COM_IF, spiRtdIc16);
Max31865PT1000Handler* rtdIc17 = new Max31865PT1000Handler(objects::RTD_IC_17,
objects::SPI_COM_IF, spiRtdIc17);
Max31865PT1000Handler* rtdIc18 = new Max31865PT1000Handler(objects::RTD_IC_18,
objects::SPI_COM_IF, spiRtdIc18);
rtdIc0->setStartUpImmediately(); rtdIc3->setStartUpImmediately();
rtdIc1->setStartUpImmediately(); rtdIc4->setStartUpImmediately();
rtdIc2->setStartUpImmediately(); rtdIc5->setStartUpImmediately();
rtdIc6->setStartUpImmediately();
rtdIc7->setStartUpImmediately();
rtdIc8->setStartUpImmediately();
rtdIc9->setStartUpImmediately();
rtdIc10->setStartUpImmediately();
rtdIc11->setStartUpImmediately();
rtdIc12->setStartUpImmediately();
rtdIc13->setStartUpImmediately();
rtdIc14->setStartUpImmediately();
rtdIc15->setStartUpImmediately();
rtdIc16->setStartUpImmediately();
rtdIc17->setStartUpImmediately();
rtdIc18->setStartUpImmediately();
static_cast<void>(rtdIc0);
static_cast<void>(rtdIc1);
static_cast<void>(rtdIc2);
static_cast<void>(rtdIc3); static_cast<void>(rtdIc3);
static_cast<void>(rtdIc4); static_cast<void>(rtdIc4);
static_cast<void>(rtdIc5); static_cast<void>(rtdIc5);
@ -787,6 +798,9 @@ void ObjectFactory::createRtdComponents(LinuxLibgpioIF *gpioComIF) {
static_cast<void>(rtdIc13); static_cast<void>(rtdIc13);
static_cast<void>(rtdIc14); static_cast<void>(rtdIc14);
static_cast<void>(rtdIc15); static_cast<void>(rtdIc15);
static_cast<void>(rtdIc16);
static_cast<void>(rtdIc17);
static_cast<void>(rtdIc18);
} }
void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) { void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) {
@ -856,7 +870,6 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) {
rwHandler1->setStartUpImmediately(); rwHandler1->setStartUpImmediately();
#endif #endif
rw1SpiCookie->setCallbackArgs(rwHandler1); rw1SpiCookie->setCallbackArgs(rwHandler1);
rwHandler1->setStartUpImmediately();
auto rwHandler2 = new RwHandler(objects::RW2, objects::SPI_COM_IF, rw2SpiCookie, gpioComIF, auto rwHandler2 = new RwHandler(objects::RW2, objects::SPI_COM_IF, rw2SpiCookie, gpioComIF,
gpioIds::EN_RW2); gpioIds::EN_RW2);

247
bsp_q7s/gpio/gpioCallbacks.cpp
View File

@ -27,10 +27,10 @@ void initSpiCsDecoder(GpioIF* gpioComIF) {
GpiodRegularByLineName* spiMuxBit = nullptr; GpiodRegularByLineName* spiMuxBit = nullptr;
/** Setting mux bit 1 to low will disable IC21 on the interface board */ /** Setting mux bit 1 to low will disable IC21 on the interface board */
spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_1_PIN, "SPI Mux Bit 1", spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_1_PIN, "SPI Mux Bit 1",
gpio::OUT, gpio::LOW); gpio::OUT, gpio::HIGH);
spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_1, spiMuxBit); spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_1, spiMuxBit);
/** Setting mux bit 2 to low disables IC1 on the TCS board */ /** Setting mux bit 2 to low disables IC1 on the TCS board */
spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_2_PIN, "SPI Mux Bit 2", gpio::OUT, gpio::LOW); spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_2_PIN, "SPI Mux Bit 2", gpio::OUT, gpio::HIGH);
spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_2, spiMuxBit); spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_2, spiMuxBit);
/** Setting mux bit 3 to low disables IC2 on the TCS board and IC22 on the interface board */ /** Setting mux bit 3 to low disables IC2 on the TCS board and IC22 on the interface board */
spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_3_PIN, "SPI Mux Bit 3", gpio::OUT, gpio::LOW); spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_3_PIN, "SPI Mux Bit 3", gpio::OUT, gpio::LOW);
@ -68,173 +68,308 @@ void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Lev
} }
if (value == gpio::HIGH) { if (value == gpio::HIGH) {
disableAllDecoder(); switch (gpioId) {
case(gpioIds::RTD_IC_3): {
disableDecoderTcsIc1();
break;
}
case(gpioIds::RTD_IC_4): {
disableDecoderTcsIc1();
break;
}
case(gpioIds::RTD_IC_5): {
disableDecoderTcsIc1();
break;
}
case(gpioIds::RTD_IC_6): {
disableDecoderTcsIc1();
break;
}
case(gpioIds::RTD_IC_7): {
disableDecoderTcsIc1();
break;
}
case(gpioIds::RTD_IC_8): {
disableDecoderTcsIc1();
break;
}
case(gpioIds::RTD_IC_9): {
disableDecoderTcsIc1();
break;
}
case(gpioIds::RTD_IC_10): {
disableDecoderTcsIc1();
break;
}
case(gpioIds::RTD_IC_11): {
disableDecoderTcsIc2();
break;
}
case(gpioIds::RTD_IC_12): {
disableDecoderTcsIc2();
break;
}
case(gpioIds::RTD_IC_13): {
disableDecoderTcsIc2();
break;
}
case(gpioIds::RTD_IC_14): {
disableDecoderTcsIc2();
break;
}
case(gpioIds::RTD_IC_15): {
disableDecoderTcsIc2();
break;
}
case(gpioIds::RTD_IC_16): {
disableDecoderTcsIc2();
break;
}
case(gpioIds::RTD_IC_17): {
disableDecoderTcsIc2();
break;
}
case(gpioIds::RTD_IC_18): {
disableDecoderTcsIc2();
break;
}
case(gpioIds::CS_SUS_1): {
disableDecoderInterfaceBoardIc1();
break;
}
case(gpioIds::CS_SUS_2): {
disableDecoderInterfaceBoardIc1();
break;
}
case(gpioIds::CS_SUS_3): {
disableDecoderInterfaceBoardIc2();
break;
}
case(gpioIds::CS_SUS_4): {
disableDecoderInterfaceBoardIc2();
break;
}
case(gpioIds::CS_SUS_5): {
disableDecoderInterfaceBoardIc2();
break;
}
case(gpioIds::CS_SUS_6): {
disableDecoderInterfaceBoardIc1();
break;
}
case(gpioIds::CS_SUS_7): {
disableDecoderInterfaceBoardIc1();
break;
}
case(gpioIds::CS_SUS_8): {
disableDecoderInterfaceBoardIc2();
break;
}
case(gpioIds::CS_SUS_9): {
disableDecoderInterfaceBoardIc1();
break;
}
case(gpioIds::CS_SUS_10): {
disableDecoderInterfaceBoardIc1();
break;
}
case(gpioIds::CS_SUS_11): {
disableDecoderInterfaceBoardIc2();
break;
}
case(gpioIds::CS_SUS_12): {
disableDecoderInterfaceBoardIc2();
break;
}
case(gpioIds::CS_SUS_13): {
disableDecoderInterfaceBoardIc1();
break;
}
case(gpioIds::CS_RW1): {
disableRwDecoder();
break;
}
case(gpioIds::CS_RW2): {
disableRwDecoder();
break;
}
case(gpioIds::CS_RW3): {
disableRwDecoder();
break;
}
case(gpioIds::CS_RW4): {
disableRwDecoder();
break;
}
default:
sif::debug << "spiCsDecoderCallback: Invalid gpio id " << gpioId << std::endl;
}
} }
else if (value == gpio::LOW) { else if (value == gpio::LOW) {
switch (gpioId) { switch (gpioId) {
case(gpioIds::RTD_IC_3): { case(gpioIds::RTD_IC_3): {
selectY7();
enableDecoderTcsIc1(); enableDecoderTcsIc1();
selectY7();
break; break;
} }
case(gpioIds::RTD_IC_4): { case(gpioIds::RTD_IC_4): {
selectY6();
enableDecoderTcsIc1(); enableDecoderTcsIc1();
selectY6();
break; break;
} }
case(gpioIds::RTD_IC_5): { case(gpioIds::RTD_IC_5): {
selectY5();
enableDecoderTcsIc1(); enableDecoderTcsIc1();
selectY5();
break; break;
} }
case(gpioIds::RTD_IC_6): { case(gpioIds::RTD_IC_6): {
selectY4();
enableDecoderTcsIc1(); enableDecoderTcsIc1();
selectY4();
break; break;
} }
case(gpioIds::RTD_IC_7): { case(gpioIds::RTD_IC_7): {
selectY3();
enableDecoderTcsIc1(); enableDecoderTcsIc1();
selectY3();
break; break;
} }
case(gpioIds::RTD_IC_8): { case(gpioIds::RTD_IC_8): {
selectY2();
enableDecoderTcsIc1(); enableDecoderTcsIc1();
selectY2();
break; break;
} }
case(gpioIds::RTD_IC_9): { case(gpioIds::RTD_IC_9): {
selectY1();
enableDecoderTcsIc1(); enableDecoderTcsIc1();
selectY1();
break; break;
} }
case(gpioIds::RTD_IC_10): { case(gpioIds::RTD_IC_10): {
selectY0();
enableDecoderTcsIc1(); enableDecoderTcsIc1();
selectY0();
break; break;
} }
case(gpioIds::RTD_IC_11): { case(gpioIds::RTD_IC_11): {
selectY7();
enableDecoderTcsIc2(); enableDecoderTcsIc2();
selectY7();
break; break;
} }
case(gpioIds::RTD_IC_12): { case(gpioIds::RTD_IC_12): {
selectY6();
enableDecoderTcsIc2(); enableDecoderTcsIc2();
selectY6();
break; break;
} }
case(gpioIds::RTD_IC_13): { case(gpioIds::RTD_IC_13): {
selectY5();
enableDecoderTcsIc2(); enableDecoderTcsIc2();
selectY5();
break; break;
} }
case(gpioIds::RTD_IC_14): { case(gpioIds::RTD_IC_14): {
selectY4();
enableDecoderTcsIc2(); enableDecoderTcsIc2();
selectY4();
break; break;
} }
case(gpioIds::RTD_IC_15): { case(gpioIds::RTD_IC_15): {
selectY3();
enableDecoderTcsIc2(); enableDecoderTcsIc2();
selectY3();
break; break;
} }
case(gpioIds::RTD_IC_16): { case(gpioIds::RTD_IC_16): {
selectY2();
enableDecoderTcsIc2(); enableDecoderTcsIc2();
selectY2();
break; break;
} }
case(gpioIds::RTD_IC_17): { case(gpioIds::RTD_IC_17): {
selectY1();
enableDecoderTcsIc2(); enableDecoderTcsIc2();
selectY1();
break; break;
} }
case(gpioIds::RTD_IC_18): { case(gpioIds::RTD_IC_18): {
selectY0();
enableDecoderTcsIc2(); enableDecoderTcsIc2();
selectY0();
break; break;
} }
case(gpioIds::CS_SUS_1): { case(gpioIds::CS_SUS_1): {
selectY0();
enableDecoderInterfaceBoardIc1(); enableDecoderInterfaceBoardIc1();
selectY0();
break; break;
} }
case(gpioIds::CS_SUS_2): { case(gpioIds::CS_SUS_2): {
selectY1();
enableDecoderInterfaceBoardIc1(); enableDecoderInterfaceBoardIc1();
selectY1();
break; break;
} }
case(gpioIds::CS_SUS_3): { case(gpioIds::CS_SUS_3): {
selectY0();
enableDecoderInterfaceBoardIc2(); enableDecoderInterfaceBoardIc2();
selectY0();
break; break;
} }
case(gpioIds::CS_SUS_4): { case(gpioIds::CS_SUS_4): {
selectY1();
enableDecoderInterfaceBoardIc2(); enableDecoderInterfaceBoardIc2();
selectY1();
break; break;
} }
case(gpioIds::CS_SUS_5): { case(gpioIds::CS_SUS_5): {
selectY2();
enableDecoderInterfaceBoardIc2(); enableDecoderInterfaceBoardIc2();
selectY2();
break; break;
} }
case(gpioIds::CS_SUS_6): { case(gpioIds::CS_SUS_6): {
selectY2();
enableDecoderInterfaceBoardIc1(); enableDecoderInterfaceBoardIc1();
selectY2();
break; break;
} }
case(gpioIds::CS_SUS_7): { case(gpioIds::CS_SUS_7): {
selectY3();
enableDecoderInterfaceBoardIc1(); enableDecoderInterfaceBoardIc1();
selectY3();
break; break;
} }
case(gpioIds::CS_SUS_8): { case(gpioIds::CS_SUS_8): {
selectY3();
enableDecoderInterfaceBoardIc2(); enableDecoderInterfaceBoardIc2();
selectY3();
break; break;
} }
case(gpioIds::CS_SUS_9): { case(gpioIds::CS_SUS_9): {
selectY4();
enableDecoderInterfaceBoardIc1(); enableDecoderInterfaceBoardIc1();
selectY4();
break; break;
} }
case(gpioIds::CS_SUS_10): { case(gpioIds::CS_SUS_10): {
selectY5();
enableDecoderInterfaceBoardIc1(); enableDecoderInterfaceBoardIc1();
selectY5();
break; break;
} }
case(gpioIds::CS_SUS_11): { case(gpioIds::CS_SUS_11): {
selectY4();
enableDecoderInterfaceBoardIc2(); enableDecoderInterfaceBoardIc2();
selectY4();
break; break;
} }
case(gpioIds::CS_SUS_12): { case(gpioIds::CS_SUS_12): {
selectY5();
enableDecoderInterfaceBoardIc2(); enableDecoderInterfaceBoardIc2();
selectY5();
break; break;
} }
case(gpioIds::CS_SUS_13): { case(gpioIds::CS_SUS_13): {
selectY6();
enableDecoderInterfaceBoardIc1(); enableDecoderInterfaceBoardIc1();
selectY6();
break; break;
} }
case(gpioIds::CS_RW1): { case(gpioIds::CS_RW1): {
selectY0();
enableRwDecoder(); enableRwDecoder();
selectY0();
break; break;
} }
case(gpioIds::CS_RW2): { case(gpioIds::CS_RW2): {
selectY1();
enableRwDecoder(); enableRwDecoder();
selectY1();
break; break;
} }
case(gpioIds::CS_RW3): { case(gpioIds::CS_RW3): {
selectY2();
enableRwDecoder(); enableRwDecoder();
selectY2();
break; break;
} }
case(gpioIds::CS_RW4): { case(gpioIds::CS_RW4): {
selectY3();
enableRwDecoder(); enableRwDecoder();
selectY3();
break; break;
} }
default: default:
@ -253,9 +388,9 @@ void enableDecoderTcsIc1() {
} }
void enableDecoderTcsIc2() { void enableDecoderTcsIc2() {
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1); gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2); gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
} }
void enableDecoderInterfaceBoardIc1() { void enableDecoderInterfaceBoardIc1() {
@ -266,15 +401,41 @@ void enableDecoderInterfaceBoardIc1() {
void enableDecoderInterfaceBoardIc2() { void enableDecoderInterfaceBoardIc2() {
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1); gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2); gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3); gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
}
void disableDecoderTcsIc1() {
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
}
void disableDecoderTcsIc2() {
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
}
void disableDecoderInterfaceBoardIc1() {
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
}
void disableDecoderInterfaceBoardIc2() {
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
} }
void enableRwDecoder() { void enableRwDecoder() {
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1); gpioComInterface->pullHigh(gpioIds::EN_RW_CS);
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2); }
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
gpioComInterface->pullHigh(gpioIds::EN_RW_CS); void disableRwDecoder() {
gpioComInterface->pullLow(gpioIds::EN_RW_CS);
} }
void selectY0() { void selectY0() {
@ -326,9 +487,9 @@ void selectY7() {
} }
void disableAllDecoder() { void disableAllDecoder() {
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1); gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2); gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
gpioComInterface->pullLow(gpioIds::EN_RW_CS); gpioComInterface->pullLow(gpioIds::EN_RW_CS);
} }

6
bsp_q7s/gpio/gpioCallbacks.h
View File

@ -44,10 +44,16 @@ namespace gpioCallbacks {
*/ */
void enableDecoderInterfaceBoardIc2(); void enableDecoderInterfaceBoardIc2();
void disableDecoderTcsIc1();
void disableDecoderTcsIc2();
void disableDecoderInterfaceBoardIc1();
void disableDecoderInterfaceBoardIc2();
/** /**
* @brief Enables the reaction wheel chip select decoder (IC3). * @brief Enables the reaction wheel chip select decoder (IC3).
*/ */
void enableRwDecoder(); void enableRwDecoder();
void disableRwDecoder();
/** /**
* @brief This function disables all decoder. * @brief This function disables all decoder.

30
linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp
View File

@ -36,9 +36,6 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
DeviceHandlerIF::PERFORM_OPERATION); DeviceHandlerIF::PERFORM_OPERATION);
#endif #endif
#if OBSW_ADD_RTD_DEVICES == 1 #if OBSW_ADD_RTD_DEVICES == 1
thisSequence->addSlot(objects::RTD_IC_0, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(objects::RTD_IC_1, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(objects::RTD_IC_2, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(objects::RTD_IC_3, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::RTD_IC_3, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(objects::RTD_IC_4, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::RTD_IC_4, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(objects::RTD_IC_5, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::RTD_IC_5, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
@ -52,6 +49,9 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
thisSequence->addSlot(objects::RTD_IC_13, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::RTD_IC_13, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(objects::RTD_IC_14, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::RTD_IC_14, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(objects::RTD_IC_15, length * 0, DeviceHandlerIF::PERFORM_OPERATION); thisSequence->addSlot(objects::RTD_IC_15, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(objects::RTD_IC_16, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(objects::RTD_IC_17, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
thisSequence->addSlot(objects::RTD_IC_18, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
#endif /* OBSW_ADD_RTD_DEVICES */ #endif /* OBSW_ADD_RTD_DEVICES */
#if OBSW_ADD_TMP_DEVICES == 1 #if OBSW_ADD_TMP_DEVICES == 1
@ -59,9 +59,6 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::SEND_WRITE);
#endif #endif
#if OBSW_ADD_RTD_DEVICES == 1 #if OBSW_ADD_RTD_DEVICES == 1
thisSequence->addSlot(objects::RTD_IC_0, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::RTD_IC_1, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::RTD_IC_2, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::RTD_IC_3, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::RTD_IC_3, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::RTD_IC_4, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::RTD_IC_4, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::RTD_IC_5, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::RTD_IC_5, length * 0.2, DeviceHandlerIF::SEND_WRITE);
@ -75,6 +72,9 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
thisSequence->addSlot(objects::RTD_IC_13, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::RTD_IC_13, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::RTD_IC_14, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::RTD_IC_14, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::RTD_IC_15, length * 0.2, DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::RTD_IC_15, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::RTD_IC_16, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::RTD_IC_17, length * 0.2, DeviceHandlerIF::SEND_WRITE);
thisSequence->addSlot(objects::RTD_IC_18, length * 0.2, DeviceHandlerIF::SEND_WRITE);
#endif /* OBSW_ADD_RTD_DEVICES */ #endif /* OBSW_ADD_RTD_DEVICES */
#if OBSW_ADD_TMP_DEVICES == 1 #if OBSW_ADD_TMP_DEVICES == 1
@ -82,9 +82,6 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.4, DeviceHandlerIF::GET_WRITE);
#endif #endif
#if OBSW_ADD_RTD_DEVICES == 1 #if OBSW_ADD_RTD_DEVICES == 1
thisSequence->addSlot(objects::RTD_IC_0, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::RTD_IC_1, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::RTD_IC_2, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::RTD_IC_3, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::RTD_IC_3, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::RTD_IC_4, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::RTD_IC_4, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::RTD_IC_5, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::RTD_IC_5, length * 0.4, DeviceHandlerIF::GET_WRITE);
@ -98,6 +95,9 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
thisSequence->addSlot(objects::RTD_IC_13, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::RTD_IC_13, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::RTD_IC_14, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::RTD_IC_14, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::RTD_IC_15, length * 0.4, DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::RTD_IC_15, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::RTD_IC_16, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::RTD_IC_17, length * 0.4, DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::RTD_IC_18, length * 0.4, DeviceHandlerIF::GET_WRITE);
#endif /* OBSW_ADD_RTD_DEVICES */ #endif /* OBSW_ADD_RTD_DEVICES */
#if OBSW_ADD_TMP_DEVICES == 1 #if OBSW_ADD_TMP_DEVICES == 1
@ -105,9 +105,6 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.6, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.6, DeviceHandlerIF::SEND_READ);
#endif #endif
#if OBSW_ADD_RTD_DEVICES == 1 #if OBSW_ADD_RTD_DEVICES == 1
thisSequence->addSlot(objects::RTD_IC_0, length * 0.6, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::RTD_IC_1, length * 0.6, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::RTD_IC_2, length * 0.6, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::RTD_IC_3, length * 0.6, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::RTD_IC_3, length * 0.6, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::RTD_IC_4, length * 0.6, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::RTD_IC_4, length * 0.6, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::RTD_IC_5, length * 0.6, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::RTD_IC_5, length * 0.6, DeviceHandlerIF::SEND_READ);
@ -121,6 +118,9 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
thisSequence->addSlot(objects::RTD_IC_13, length * 0.6, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::RTD_IC_13, length * 0.6, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::RTD_IC_14, length * 0.6, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::RTD_IC_14, length * 0.6, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::RTD_IC_15, length * 0.6, DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::RTD_IC_15, length * 0.6, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::RTD_IC_16, length * 0.6, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::RTD_IC_17, length * 0.6, DeviceHandlerIF::SEND_READ);
thisSequence->addSlot(objects::RTD_IC_18, length * 0.6, DeviceHandlerIF::SEND_READ);
#endif /* OBSW_ADD_RTD_DEVICES */ #endif /* OBSW_ADD_RTD_DEVICES */
#if OBSW_ADD_TMP_DEVICES == 1 #if OBSW_ADD_TMP_DEVICES == 1
@ -128,9 +128,6 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.8, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.8, DeviceHandlerIF::GET_READ);
#endif #endif
#if OBSW_ADD_RTD_DEVICES == 1 #if OBSW_ADD_RTD_DEVICES == 1
thisSequence->addSlot(objects::RTD_IC_0, length * 0.8, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::RTD_IC_1, length * 0.8, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::RTD_IC_2, length * 0.8, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::RTD_IC_3, length * 0.8, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::RTD_IC_3, length * 0.8, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::RTD_IC_4, length * 0.8, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::RTD_IC_4, length * 0.8, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::RTD_IC_5, length * 0.8, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::RTD_IC_5, length * 0.8, DeviceHandlerIF::GET_READ);
@ -144,6 +141,9 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
thisSequence->addSlot(objects::RTD_IC_13, length * 0.8, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::RTD_IC_13, length * 0.8, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::RTD_IC_14, length * 0.8, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::RTD_IC_14, length * 0.8, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::RTD_IC_15, length * 0.8, DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::RTD_IC_15, length * 0.8, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::RTD_IC_16, length * 0.8, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::RTD_IC_17, length * 0.8, DeviceHandlerIF::GET_READ);
thisSequence->addSlot(objects::RTD_IC_18, length * 0.8, DeviceHandlerIF::GET_READ);
#endif /* OBSW_ADD_RTD_DEVICES */ #endif /* OBSW_ADD_RTD_DEVICES */
#if OBSW_ADD_RAD_SENSORS == 1 #if OBSW_ADD_RAD_SENSORS == 1

793
mission/devices/Max31865PT1000Handler.cpp
View File

@ -6,11 +6,11 @@
#include <cmath> #include <cmath>
Max31865PT1000Handler::Max31865PT1000Handler(object_id_t objectId, object_id_t comIF, Max31865PT1000Handler::Max31865PT1000Handler(object_id_t objectId, object_id_t comIF,
CookieIF *comCookie): CookieIF *comCookie) :
DeviceHandlerBase(objectId, comIF, comCookie), sensorDataset(this), DeviceHandlerBase(objectId, comIF, comCookie), sensorDataset(this), sensorDatasetSid(
sensorDatasetSid(sensorDataset.getSid()) { sensorDataset.getSid()) {
#if OBSW_VERBOSE_LEVEL >= 1 #if OBSW_VERBOSE_LEVEL >= 1
debugDivider = new PeriodicOperationDivider(0); debugDivider = new PeriodicOperationDivider(0);
#endif #endif
} }
@ -18,476 +18,477 @@ Max31865PT1000Handler::~Max31865PT1000Handler() {
} }
void Max31865PT1000Handler::doStartUp() { void Max31865PT1000Handler::doStartUp() {
if(internalState == InternalState::NONE) { // if (internalState == InternalState::NONE) {
internalState = InternalState::WARMUP; // internalState = InternalState::WARMUP;
Clock::getUptime(&startTime); // Clock::getUptime(&startTime);
} // }
//
if(internalState == InternalState::WARMUP) { // if (internalState == InternalState::WARMUP) {
dur_millis_t timeNow = 0; // dur_millis_t timeNow = 0;
Clock::getUptime(&timeNow); // Clock::getUptime(&timeNow);
if(timeNow - startTime >= 100) { // if (timeNow - startTime >= 100) {
internalState = InternalState::CONFIGURE; // internalState = InternalState::CONFIGURE;
} // }
} // }
//
if(internalState == InternalState::CONFIGURE) { // if (internalState == InternalState::CONFIGURE) {
if(commandExecuted) { // if (commandExecuted) {
commandExecuted = false; // commandExecuted = false;
internalState = InternalState::REQUEST_CONFIG; // internalState = InternalState::REQUEST_CONFIG;
} // }
} // }
//
if(internalState == InternalState::REQUEST_CONFIG) { // if (internalState == InternalState::REQUEST_CONFIG) {
if (commandExecuted) { // if (commandExecuted) {
commandExecuted = false; // commandExecuted = false;
internalState = InternalState::CONFIG_HIGH_THRESHOLD; // internalState = InternalState::CONFIG_HIGH_THRESHOLD;
} // }
} // }
//
if(internalState == InternalState::CONFIG_HIGH_THRESHOLD) { // if (internalState == InternalState::CONFIG_HIGH_THRESHOLD) {
if(commandExecuted) { // if (commandExecuted) {
internalState = InternalState::REQUEST_HIGH_THRESHOLD; // internalState = InternalState::REQUEST_HIGH_THRESHOLD;
commandExecuted = false; // commandExecuted = false;
} // }
} // }
//
if(internalState == InternalState::REQUEST_HIGH_THRESHOLD) { // if (internalState == InternalState::REQUEST_HIGH_THRESHOLD) {
if(commandExecuted) { // if (commandExecuted) {
internalState = InternalState::CONFIG_LOW_THRESHOLD; // internalState = InternalState::CONFIG_LOW_THRESHOLD;
commandExecuted = false; // commandExecuted = false;
} // }
} // }
//
if(internalState == InternalState::CONFIG_LOW_THRESHOLD) { // if (internalState == InternalState::CONFIG_LOW_THRESHOLD) {
if(commandExecuted) { // if (commandExecuted) {
internalState = InternalState::REQUEST_LOW_THRESHOLD; // internalState = InternalState::REQUEST_LOW_THRESHOLD;
commandExecuted = false; // commandExecuted = false;
} // }
} // }
//
if(internalState == InternalState::REQUEST_LOW_THRESHOLD) { // if (internalState == InternalState::REQUEST_LOW_THRESHOLD) {
if(commandExecuted) { // if (commandExecuted) {
setMode(MODE_ON); // setMode(MODE_ON);
setMode(MODE_NORMAL); // setMode(MODE_NORMAL);
internalState = InternalState::RUNNING; // internalState = InternalState::RUNNING;
commandExecuted = false; // commandExecuted = false;
} // }
} // }
setMode(MODE_NORMAL);
} }
void Max31865PT1000Handler::doShutDown() { void Max31865PT1000Handler::doShutDown() {
commandExecuted = false; commandExecuted = false;
setMode(_MODE_POWER_DOWN); setMode(_MODE_POWER_DOWN);
} }
ReturnValue_t Max31865PT1000Handler::buildNormalDeviceCommand( ReturnValue_t Max31865PT1000Handler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
DeviceCommandId_t *id) { // if (internalState == InternalState::RUNNING) {
if(internalState == InternalState::RUNNING) { // *id = Max31865Definitions::REQUEST_RTD;
*id = Max31865Definitions::REQUEST_RTD; // return buildCommandFromCommand(*id, nullptr, 0);
return buildCommandFromCommand(*id, nullptr, 0); // } else if (internalState == InternalState::REQUEST_FAULT_BYTE) {
} // *id = Max31865Definitions::REQUEST_FAULT_BYTE;
else if(internalState == InternalState::REQUEST_FAULT_BYTE) { // return buildCommandFromCommand(*id, nullptr, 0);
*id = Max31865Definitions::REQUEST_FAULT_BYTE; // } else {
return buildCommandFromCommand(*id, nullptr, 0); // return DeviceHandlerBase::NOTHING_TO_SEND;
} // }
else {
return DeviceHandlerBase::NOTHING_TO_SEND; if (internalState == InternalState::CONFIGURE) {
} *id = Max31865Definitions::CONFIG_CMD;
uint8_t config[1] = { DEFAULT_CONFIG };
return buildCommandFromCommand(*id, config, 1);
} else if (internalState == InternalState::REQUEST_CONFIG) {
*id = Max31865Definitions::REQUEST_CONFIG;
//internalState = InternalState::NONE;
return buildCommandFromCommand(*id, nullptr, 0);
} else {
return DeviceHandlerBase::NOTHING_TO_SEND;
}
} }
ReturnValue_t Max31865PT1000Handler::buildTransitionDeviceCommand( ReturnValue_t Max31865PT1000Handler::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
DeviceCommandId_t *id) { switch (internalState) {
switch(internalState) { case (InternalState::NONE):
case(InternalState::NONE): case (InternalState::WARMUP):
case(InternalState::WARMUP): case (InternalState::RUNNING):
case(InternalState::RUNNING): return DeviceHandlerBase::NOTHING_TO_SEND;
return DeviceHandlerBase::NOTHING_TO_SEND; case (InternalState::CONFIGURE): {
case(InternalState::CONFIGURE): { *id = Max31865Definitions::CONFIG_CMD;
*id = Max31865Definitions::CONFIG_CMD; uint8_t config[1] = { DEFAULT_CONFIG };
uint8_t config[1] = {DEFAULT_CONFIG}; return buildCommandFromCommand(*id, config, 1);
return buildCommandFromCommand(*id, config, 1); }
} case (InternalState::REQUEST_CONFIG): {
case(InternalState::REQUEST_CONFIG): { *id = Max31865Definitions::REQUEST_CONFIG;
*id = Max31865Definitions::REQUEST_CONFIG; return buildCommandFromCommand(*id, nullptr, 0);
return buildCommandFromCommand(*id, nullptr, 0); }
} case (InternalState::CONFIG_HIGH_THRESHOLD): {
case(InternalState::CONFIG_HIGH_THRESHOLD): { *id = Max31865Definitions::WRITE_HIGH_THRESHOLD;
*id = Max31865Definitions::WRITE_HIGH_THRESHOLD; return buildCommandFromCommand(*id, nullptr, 0);
return buildCommandFromCommand(*id, nullptr, 0); }
} case (InternalState::REQUEST_HIGH_THRESHOLD): {
case(InternalState::REQUEST_HIGH_THRESHOLD): { *id = Max31865Definitions::REQUEST_HIGH_THRESHOLD;
*id = Max31865Definitions::REQUEST_HIGH_THRESHOLD; return buildCommandFromCommand(*id, nullptr, 0);
return buildCommandFromCommand(*id, nullptr, 0); }
} case (InternalState::CONFIG_LOW_THRESHOLD): {
case(InternalState::CONFIG_LOW_THRESHOLD): { *id = Max31865Definitions::WRITE_LOW_THRESHOLD;
*id = Max31865Definitions::WRITE_LOW_THRESHOLD; return buildCommandFromCommand(*id, nullptr, 0);
return buildCommandFromCommand(*id, nullptr, 0); }
} case (InternalState::REQUEST_LOW_THRESHOLD): {
case(InternalState::REQUEST_LOW_THRESHOLD): { *id = Max31865Definitions::REQUEST_LOW_THRESHOLD;
*id = Max31865Definitions::REQUEST_LOW_THRESHOLD; return buildCommandFromCommand(*id, nullptr, 0);
return buildCommandFromCommand(*id, nullptr, 0); }
}
default: default:
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "Max31865PT1000Handler: Invalid internal state" << std::endl; sif::error << "Max31865PT1000Handler: Invalid internal state" << std::endl;
#else #else
sif::printError("Max31865PT1000Handler: Invalid internal state\n"); sif::printError("Max31865PT1000Handler: Invalid internal state\n");
#endif #endif
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
} }
ReturnValue_t Max31865PT1000Handler::buildCommandFromCommand( ReturnValue_t Max31865PT1000Handler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
DeviceCommandId_t deviceCommand, const uint8_t *commandData, const uint8_t *commandData, size_t commandDataLen) {
size_t commandDataLen) { switch (deviceCommand) {
switch(deviceCommand) { case (Max31865Definitions::CONFIG_CMD): {
case(Max31865Definitions::CONFIG_CMD) : { commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::CONFIG_CMD);
commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::CONFIG_CMD); if (commandDataLen == 1) {
if(commandDataLen == 1) { commandBuffer[1] = commandData[0];
commandBuffer[1] = commandData[0]; DeviceHandlerBase::rawPacketLen = 2;
DeviceHandlerBase::rawPacketLen = 2; DeviceHandlerBase::rawPacket = commandBuffer.data();
DeviceHandlerBase::rawPacket = commandBuffer.data(); return HasReturnvaluesIF::RETURN_OK;
return HasReturnvaluesIF::RETURN_OK; } else {
} return DeviceHandlerIF::NO_COMMAND_DATA;
else { }
return DeviceHandlerIF::NO_COMMAND_DATA; }
} case (Max31865Definitions::REQUEST_CONFIG): {
} commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::REQUEST_CONFIG);
case(Max31865Definitions::REQUEST_CONFIG): { commandBuffer[1] = 0x00; // dummy byte
commandBuffer[0] = static_cast<uint8_t>( DeviceHandlerBase::rawPacketLen = 2;
Max31865Definitions::REQUEST_CONFIG); DeviceHandlerBase::rawPacket = commandBuffer.data();
commandBuffer[1] = 0x00; // dummy byte return HasReturnvaluesIF::RETURN_OK;
DeviceHandlerBase::rawPacketLen = 2; }
DeviceHandlerBase::rawPacket = commandBuffer.data(); case (Max31865Definitions::WRITE_HIGH_THRESHOLD): {
return HasReturnvaluesIF::RETURN_OK; commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::WRITE_HIGH_THRESHOLD);
} commandBuffer[1] = static_cast<uint8_t>(HIGH_THRESHOLD >> 8);
case(Max31865Definitions::WRITE_HIGH_THRESHOLD): { commandBuffer[2] = static_cast<uint8_t>(HIGH_THRESHOLD & 0xFF);
commandBuffer[0] = static_cast<uint8_t>( DeviceHandlerBase::rawPacketLen = 3;
Max31865Definitions::WRITE_HIGH_THRESHOLD); DeviceHandlerBase::rawPacket = commandBuffer.data();
commandBuffer[1] = static_cast<uint8_t>(HIGH_THRESHOLD >> 8); return HasReturnvaluesIF::RETURN_OK;
commandBuffer[2] = static_cast<uint8_t>(HIGH_THRESHOLD & 0xFF); }
DeviceHandlerBase::rawPacketLen = 3; case (Max31865Definitions::REQUEST_HIGH_THRESHOLD): {
DeviceHandlerBase::rawPacket = commandBuffer.data(); commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::REQUEST_HIGH_THRESHOLD);
return HasReturnvaluesIF::RETURN_OK; commandBuffer[1] = 0x00; //dummy byte
} commandBuffer[2] = 0x00; //dummy byte
case(Max31865Definitions::REQUEST_HIGH_THRESHOLD): { DeviceHandlerBase::rawPacketLen = 3;
commandBuffer[0] = static_cast<uint8_t>( DeviceHandlerBase::rawPacket = commandBuffer.data();
Max31865Definitions::REQUEST_HIGH_THRESHOLD); return HasReturnvaluesIF::RETURN_OK;
commandBuffer[1] = 0x00; //dummy byte }
commandBuffer[2] = 0x00; //dummy byte case (Max31865Definitions::WRITE_LOW_THRESHOLD): {
DeviceHandlerBase::rawPacketLen = 3; commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::WRITE_LOW_THRESHOLD);
DeviceHandlerBase::rawPacket = commandBuffer.data(); commandBuffer[1] = static_cast<uint8_t>(LOW_THRESHOLD >> 8);
return HasReturnvaluesIF::RETURN_OK; commandBuffer[2] = static_cast<uint8_t>(LOW_THRESHOLD & 0xFF);
} DeviceHandlerBase::rawPacketLen = 3;
case(Max31865Definitions::WRITE_LOW_THRESHOLD): { DeviceHandlerBase::rawPacket = commandBuffer.data();
commandBuffer[0] = static_cast<uint8_t>( return HasReturnvaluesIF::RETURN_OK;
Max31865Definitions::WRITE_LOW_THRESHOLD); }
commandBuffer[1] = static_cast<uint8_t>(LOW_THRESHOLD >> 8); case (Max31865Definitions::REQUEST_LOW_THRESHOLD): {
commandBuffer[2] = static_cast<uint8_t>(LOW_THRESHOLD & 0xFF); commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::REQUEST_LOW_THRESHOLD);
DeviceHandlerBase::rawPacketLen = 3; commandBuffer[1] = 0x00; //dummy byte
DeviceHandlerBase::rawPacket = commandBuffer.data(); commandBuffer[2] = 0x00; //dummy byte
return HasReturnvaluesIF::RETURN_OK; DeviceHandlerBase::rawPacketLen = 3;
} DeviceHandlerBase::rawPacket = commandBuffer.data();
case(Max31865Definitions::REQUEST_LOW_THRESHOLD): { return HasReturnvaluesIF::RETURN_OK;
commandBuffer[0] = static_cast<uint8_t>( }
Max31865Definitions::REQUEST_LOW_THRESHOLD); case (Max31865Definitions::REQUEST_RTD): {
commandBuffer[1] = 0x00; //dummy byte commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::REQUEST_RTD);
commandBuffer[2] = 0x00; //dummy byte // two dummy bytes
DeviceHandlerBase::rawPacketLen = 3; commandBuffer[1] = 0x00;
DeviceHandlerBase::rawPacket = commandBuffer.data(); commandBuffer[2] = 0x00;
return HasReturnvaluesIF::RETURN_OK; DeviceHandlerBase::rawPacketLen = 3;
} DeviceHandlerBase::rawPacket = commandBuffer.data();
case(Max31865Definitions::REQUEST_RTD): { return HasReturnvaluesIF::RETURN_OK;
commandBuffer[0] = static_cast<uint8_t>( }
Max31865Definitions::REQUEST_RTD); case (Max31865Definitions::REQUEST_FAULT_BYTE): {
// two dummy bytes commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::REQUEST_FAULT_BYTE);
commandBuffer[1] = 0x00; commandBuffer[1] = 0x00;
commandBuffer[2] = 0x00; DeviceHandlerBase::rawPacketLen = 2;
DeviceHandlerBase::rawPacketLen = 3; DeviceHandlerBase::rawPacket = commandBuffer.data();
DeviceHandlerBase::rawPacket = commandBuffer.data(); return HasReturnvaluesIF::RETURN_OK;
return HasReturnvaluesIF::RETURN_OK; }
} default:
case(Max31865Definitions::REQUEST_FAULT_BYTE): { //Unknown DeviceCommand
commandBuffer[0] = static_cast<uint8_t>( return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
Max31865Definitions::REQUEST_FAULT_BYTE); }
commandBuffer[1] = 0x00;
DeviceHandlerBase::rawPacketLen = 2;
DeviceHandlerBase::rawPacket = commandBuffer.data();
return HasReturnvaluesIF::RETURN_OK;
}
default:
//Unknown DeviceCommand
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
}
} }
void Max31865PT1000Handler::fillCommandAndReplyMap() { void Max31865PT1000Handler::fillCommandAndReplyMap() {
insertInCommandAndReplyMap(Max31865Definitions::CONFIG_CMD, 3); insertInCommandAndReplyMap(Max31865Definitions::CONFIG_CMD, 3);
insertInCommandAndReplyMap(Max31865Definitions::REQUEST_CONFIG, 3); insertInCommandAndReplyMap(Max31865Definitions::REQUEST_CONFIG, 3);
insertInCommandAndReplyMap(Max31865Definitions::WRITE_LOW_THRESHOLD, 3); insertInCommandAndReplyMap(Max31865Definitions::WRITE_LOW_THRESHOLD, 3);
insertInCommandAndReplyMap(Max31865Definitions::REQUEST_LOW_THRESHOLD, 3); insertInCommandAndReplyMap(Max31865Definitions::REQUEST_LOW_THRESHOLD, 3);
insertInCommandAndReplyMap(Max31865Definitions::WRITE_HIGH_THRESHOLD, 3); insertInCommandAndReplyMap(Max31865Definitions::WRITE_HIGH_THRESHOLD, 3);
insertInCommandAndReplyMap(Max31865Definitions::REQUEST_HIGH_THRESHOLD, 3); insertInCommandAndReplyMap(Max31865Definitions::REQUEST_HIGH_THRESHOLD, 3);
insertInCommandAndReplyMap(Max31865Definitions::REQUEST_RTD, 3, insertInCommandAndReplyMap(Max31865Definitions::REQUEST_RTD, 3, &sensorDataset);
&sensorDataset); insertInCommandAndReplyMap(Max31865Definitions::REQUEST_FAULT_BYTE, 3);
insertInCommandAndReplyMap(Max31865Definitions::REQUEST_FAULT_BYTE, 3);
} }
ReturnValue_t Max31865PT1000Handler::scanForReply(const uint8_t *start, ReturnValue_t Max31865PT1000Handler::scanForReply(const uint8_t *start, size_t remainingSize,
size_t remainingSize, DeviceCommandId_t *foundId, size_t *foundLen) { DeviceCommandId_t *foundId, size_t *foundLen) {
size_t rtdReplySize = 3; size_t rtdReplySize = 3;
size_t configReplySize = 2; size_t configReplySize = 2;
if(remainingSize == rtdReplySize and if (remainingSize == rtdReplySize and internalState == InternalState::RUNNING) {
internalState == InternalState::RUNNING) { *foundId = Max31865Definitions::REQUEST_RTD;
*foundId = Max31865Definitions::REQUEST_RTD; *foundLen = rtdReplySize;
*foundLen = rtdReplySize; return RETURN_OK;
return RETURN_OK; }
}
if(remainingSize == 3) { if (remainingSize == 3) {
switch(internalState) { switch (internalState) {
case(InternalState::CONFIG_HIGH_THRESHOLD): { case (InternalState::CONFIG_HIGH_THRESHOLD): {
*foundLen = 3; *foundLen = 3;
*foundId = Max31865Definitions::WRITE_HIGH_THRESHOLD; *foundId = Max31865Definitions::WRITE_HIGH_THRESHOLD;
commandExecuted = true; commandExecuted = true;
return RETURN_OK; return RETURN_OK;
} }
case(InternalState::REQUEST_HIGH_THRESHOLD): { case (InternalState::REQUEST_HIGH_THRESHOLD): {
*foundLen = 3; *foundLen = 3;
*foundId = Max31865Definitions::REQUEST_HIGH_THRESHOLD; *foundId = Max31865Definitions::REQUEST_HIGH_THRESHOLD;
return RETURN_OK; return RETURN_OK;
} }
case(InternalState::CONFIG_LOW_THRESHOLD): { case (InternalState::CONFIG_LOW_THRESHOLD): {
*foundLen = 3; *foundLen = 3;
*foundId = Max31865Definitions::WRITE_LOW_THRESHOLD; *foundId = Max31865Definitions::WRITE_LOW_THRESHOLD;
commandExecuted = true; commandExecuted = true;
return RETURN_OK; return RETURN_OK;
} }
case(InternalState::REQUEST_LOW_THRESHOLD): { case (InternalState::REQUEST_LOW_THRESHOLD): {
*foundLen = 3; *foundLen = 3;
*foundId = Max31865Definitions::REQUEST_LOW_THRESHOLD; *foundId = Max31865Definitions::REQUEST_LOW_THRESHOLD;
return RETURN_OK; return RETURN_OK;
} }
default: { default: {
sif::debug << "Max31865PT1000Handler::scanForReply: Unknown internal state" sif::debug << "Max31865PT1000Handler::scanForReply: Unknown internal state"
<< std::endl; << std::endl;
return RETURN_OK; return RETURN_OK;
} }
} }
} }
if(remainingSize == configReplySize) { if (remainingSize == configReplySize) {
if(internalState == InternalState::CONFIGURE) { if (internalState == InternalState::CONFIGURE) {
commandExecuted = true; commandExecuted = true;
*foundLen = configReplySize; *foundLen = configReplySize;
*foundId = Max31865Definitions::CONFIG_CMD; *foundId = Max31865Definitions::CONFIG_CMD;
} internalState = InternalState::REQUEST_CONFIG;
else if(internalState == InternalState::REQUEST_FAULT_BYTE) { } else if (internalState == InternalState::REQUEST_FAULT_BYTE) {
*foundId = Max31865Definitions::REQUEST_FAULT_BYTE; *foundId = Max31865Definitions::REQUEST_FAULT_BYTE;
*foundLen = 2; *foundLen = 2;
internalState = InternalState::RUNNING; // internalState = InternalState::RUNNING;
} } else {
else { *foundId = Max31865Definitions::REQUEST_CONFIG;
*foundId = Max31865Definitions::REQUEST_CONFIG; *foundLen = configReplySize;
*foundLen = configReplySize; internalState = InternalState::CONFIGURE;
} }
} }
return RETURN_OK; return RETURN_OK;
} }
ReturnValue_t Max31865PT1000Handler::interpretDeviceReply( ReturnValue_t Max31865PT1000Handler::interpretDeviceReply(DeviceCommandId_t id,
DeviceCommandId_t id, const uint8_t *packet) { const uint8_t *packet) {
switch(id) { switch (id) {
case(Max31865Definitions::REQUEST_CONFIG): { case (Max31865Definitions::REQUEST_CONFIG): {
if(packet[1] != DEFAULT_CONFIG) { if (packet[1] != DEFAULT_CONFIG) {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
// it propably would be better if we at least try one restart.. // it propably would be better if we at least try one restart..
sif::error << "Max31865PT1000Handler: Invalid configuration reply!" << std::endl; sif::error << "Max31865PT1000Handler: Object ID: " << std::hex << this->getObjectId()
<< ": Invalid configuration reply!" << std::endl;
#else #else
sif::printError("Max31865PT1000Handler: Invalid configuration reply!\n"); sif::printError("Max31865PT1000Handler: Invalid configuration reply!\n");
#endif #endif
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
// set to true for invalid configs too for now. else {
if(internalState == InternalState::REQUEST_CONFIG) { sif::debug << "Max31865PT1000Handler: Object ID: " << std::hex << this->getObjectId()
commandExecuted = true; << ": Config readback successful!" << std::endl;
} }
else if(internalState == InternalState::RUNNING) { // set to true for invalid configs too for now.
// we should propably generate a telemetry with the config byte if (internalState == InternalState::REQUEST_CONFIG) {
// as payload here. commandExecuted = true;
} } else if (internalState == InternalState::RUNNING) {
break; // we should propably generate a telemetry with the config byte
} // as payload here.
case(Max31865Definitions::REQUEST_LOW_THRESHOLD): { }
uint16_t readLowThreshold = packet[1] << 8 | packet[2]; break;
if(readLowThreshold != LOW_THRESHOLD) { }
case (Max31865Definitions::REQUEST_LOW_THRESHOLD): {
uint16_t readLowThreshold = packet[1] << 8 | packet[2];
if (readLowThreshold != LOW_THRESHOLD) {
#if FSFW_VERBOSE_LEVEL >= 1 #if FSFW_VERBOSE_LEVEL >= 1
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "Max31865PT1000Handler::interpretDeviceReply: Missmatch between " << sif::warning << "Max31865PT1000Handler::interpretDeviceReply: Missmatch between "
"written and readback value of low threshold register" << std::endl; << "written and readback value of low threshold register" << std::endl;
#else #else
sif::printWarning("Max31865PT1000Handler::interpretDeviceReply: Missmatch between " sif::printWarning("Max31865PT1000Handler::interpretDeviceReply: Missmatch between "
"written and readback value of low threshold register\n"); "written and readback value of low threshold register\n");
#endif #endif
#endif #endif
} }
commandExecuted = true; commandExecuted = true;
break; break;
} }
case(Max31865Definitions::REQUEST_HIGH_THRESHOLD): { case (Max31865Definitions::REQUEST_HIGH_THRESHOLD): {
uint16_t readHighThreshold = packet[1] << 8 | packet[2]; uint16_t readHighThreshold = packet[1] << 8 | packet[2];
if(readHighThreshold != HIGH_THRESHOLD) { if (readHighThreshold != HIGH_THRESHOLD) {
#if FSFW_VERBOSE_LEVEL >= 1 #if FSFW_VERBOSE_LEVEL >= 1
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "Max31865PT1000Handler::interpretDeviceReply: Missmatch between " << sif::warning << "Max31865PT1000Handler::interpretDeviceReply: Missmatch between "
"written and readback value of high threshold register" << std::endl; << "written and readback value of high threshold register" << std::endl;
#else #else
sif::printWarning("Max31865PT1000Handler::interpretDeviceReply: Missmatch between " sif::printWarning("Max31865PT1000Handler::interpretDeviceReply: Missmatch between "
"written and readback value of high threshold register\n"); "written and readback value of high threshold register\n");
#endif #endif
#endif #endif
} }
commandExecuted = true; commandExecuted = true;
break; break;
} }
case(Max31865Definitions::REQUEST_RTD): { case (Max31865Definitions::REQUEST_RTD): {
// first bit of LSB reply byte is the fault bit // first bit of LSB reply byte is the fault bit
uint8_t faultBit = packet[2] & 0b0000'0001; uint8_t faultBit = packet[2] & 0b0000'0001;
if(faultBit == 1) { if (faultBit == 1) {
// Maybe we should attempt to restart it? // Maybe we should attempt to restart it?
internalState = InternalState::REQUEST_FAULT_BYTE; internalState = InternalState::REQUEST_FAULT_BYTE;
} }
// RTD value consists of last seven bits of the LSB reply byte and // RTD value consists of last seven bits of the LSB reply byte and
// the MSB reply byte // the MSB reply byte
uint16_t adcCode = ((packet[1] << 8) | packet[2]) >> 1; uint16_t adcCode = ((packet[1] << 8) | packet[2]) >> 1;
// do something with rtd value, will propably be stored in // do something with rtd value, will propably be stored in
// dataset. // dataset.
float rtdValue = adcCode * RTD_RREF_PT1000 / INT16_MAX; float rtdValue = adcCode * RTD_RREF_PT1000 / INT16_MAX;
// calculate approximation // calculate approximation
float approxTemp = adcCode / 32.0 - 256.0; float approxTemp = adcCode / 32.0 - 256.0;
#if OBSW_DEBUG_RTD == 1 #if OBSW_DEBUG_RTD == 1
#if OBSW_VERBOSE_LEVEL >= 1 #if OBSW_VERBOSE_LEVEL >= 1
if(debugDivider->checkAndIncrement()) { if (debugDivider->checkAndIncrement()) {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::info << "Max31865: Measured resistance is " << rtdValue << " Ohms." << std::endl; sif::info << "Max31865: Object ID: " << std::hex << this->getObjectId()
sif::info << "Approximated temperature is " << approxTemp << " C" << std::endl; << "Measured resistance is " << rtdValue << " Ohms." << std::endl;
sif::info << "Approximated temperature is " << approxTemp << " C" << std::endl;
#else #else
sif::printInfo("Max31685: Measured resistance is %f Ohms\n", rtdValue); sif::printInfo("Max31685: Measured resistance is %f Ohms\n", rtdValue);
sif::printInfo("Approximated temperature is %f C\n", approxTemp); sif::printInfo("Approximated temperature is %f C\n", approxTemp);
#endif #endif
} }
#endif #endif
#endif #endif
PoolReadGuard pg(&sensorDataset); PoolReadGuard pg(&sensorDataset);
if(pg.getReadResult() != HasReturnvaluesIF::RETURN_OK) { if (pg.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
// Configuration error // Configuration error
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "Max31865PT1000Handler::interpretDeviceReply: Error reading dataset!" sif::warning << "Max31865PT1000Handler::interpretDeviceReply: Error reading dataset!"
<< std::endl; << std::endl;
#else #else
sif::printWarning("Max31865PT1000Handler::interpretDeviceReply: " sif::printWarning("Max31865PT1000Handler::interpretDeviceReply: "
"Error reading dataset!\n"); "Error reading dataset!\n");
#endif #endif
return pg.getReadResult(); return pg.getReadResult();
} }
if(not sensorDataset.isValid()) { if (not sensorDataset.isValid()) {
sensorDataset.setValidity(true, false); sensorDataset.setValidity(true, false);
sensorDataset.rtdValue.setValid(true); sensorDataset.rtdValue.setValid(true);
sensorDataset.temperatureCelcius.setValid(true); sensorDataset.temperatureCelcius.setValid(true);
} }
sensorDataset.rtdValue = rtdValue; sensorDataset.rtdValue = rtdValue;
sensorDataset.temperatureCelcius = approxTemp; sensorDataset.temperatureCelcius = approxTemp;
break; break;
} }
case(Max31865Definitions::REQUEST_FAULT_BYTE): { case (Max31865Definitions::REQUEST_FAULT_BYTE): {
faultByte = packet[1]; faultByte = packet[1];
#if OBSW_VERBOSE_LEVEL >= 1 #if OBSW_VERBOSE_LEVEL >= 1
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "Max31865PT1000Handler::interpretDeviceReply: Fault byte" sif::warning << "Max31865PT1000Handler::interpretDeviceReply: Fault byte"
" is: 0b" << std::bitset<8>(faultByte) << std::endl; " is: 0b" << std::bitset < 8 > (faultByte) << std::endl;
#else #else
sif::printWarning("Max31865PT1000Handler::interpretDeviceReply: Fault byte" sif::printWarning("Max31865PT1000Handler::interpretDeviceReply: Fault byte"
" is: 0b" BYTE_TO_BINARY_PATTERN "\n", BYTE_TO_BINARY(faultByte)); " is: 0b" BYTE_TO_BINARY_PATTERN "\n", BYTE_TO_BINARY(faultByte));
#endif #endif
#endif #endif
ReturnValue_t result = sensorDataset.read(); ReturnValue_t result = sensorDataset.read();
if(result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
// Configuration error // Configuration error
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::debug << "Max31865PT1000Handler::interpretDeviceReply: " sif::debug << "Max31865PT1000Handler::interpretDeviceReply: "
"Error reading dataset!" << std::endl; "Error reading dataset!" << std::endl;
#else #else
sif::printDebug("Max31865PT1000Handler::interpretDeviceReply: " sif::printDebug("Max31865PT1000Handler::interpretDeviceReply: "
"Error reading dataset!\n"); "Error reading dataset!\n");
#endif #endif
return result; return result;
} }
sensorDataset.errorByte.setValid(true); sensorDataset.errorByte.setValid(true);
sensorDataset.errorByte = faultByte; sensorDataset.errorByte = faultByte;
if(faultByte != 0) { if (faultByte != 0) {
sensorDataset.temperatureCelcius.setValid(false); sensorDataset.temperatureCelcius.setValid(false);
} }
result = sensorDataset.commit(); result = sensorDataset.commit();
if(result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
// Configuration error // Configuration error
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::debug << "Max31865PT1000Handler::interpretDeviceReply: " sif::debug << "Max31865PT1000Handler::interpretDeviceReply: "
"Error commiting dataset!" << std::endl; "Error commiting dataset!" << std::endl;
#else #else
sif::printDebug("Max31865PT1000Handler::interpretDeviceReply: " sif::printDebug("Max31865PT1000Handler::interpretDeviceReply: "
"Error commiting dataset!\n"); "Error commiting dataset!\n");
#endif #endif
return result; return result;
} }
break; break;
} }
default: default:
break; break;
} }
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
void Max31865PT1000Handler::debugInterface(uint8_t positionTracker, void Max31865PT1000Handler::debugInterface(uint8_t positionTracker, object_id_t objectId,
object_id_t objectId, uint32_t parameter) { uint32_t parameter) {
} }
uint32_t Max31865PT1000Handler::getTransitionDelayMs( uint32_t Max31865PT1000Handler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
Mode_t modeFrom, Mode_t modeTo) { return 25000;
return 25000;
} }
ReturnValue_t Max31865PT1000Handler::getSwitches( ReturnValue_t Max31865PT1000Handler::getSwitches(const uint8_t **switches,
const uint8_t **switches, uint8_t *numberOfSwitches) { uint8_t *numberOfSwitches) {
return DeviceHandlerBase::NO_SWITCH; return DeviceHandlerBase::NO_SWITCH;
} }
void Max31865PT1000Handler::doTransition(Mode_t modeFrom, void Max31865PT1000Handler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
Submode_t subModeFrom) { DeviceHandlerBase::doTransition(modeFrom, subModeFrom);
DeviceHandlerBase::doTransition(modeFrom, subModeFrom);
} }
ReturnValue_t Max31865PT1000Handler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap, ReturnValue_t Max31865PT1000Handler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
LocalDataPoolManager& poolManager) { LocalDataPoolManager& poolManager) {
localDataPoolMap.emplace(Max31865Definitions::PoolIds::RTD_VALUE, new PoolEntry<float>({0})); localDataPoolMap.emplace(Max31865Definitions::PoolIds::RTD_VALUE, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(Max31865Definitions::PoolIds::TEMPERATURE_C, localDataPoolMap.emplace(Max31865Definitions::PoolIds::TEMPERATURE_C,
new PoolEntry<float>({0}, 1, true)); new PoolEntry<float>( { 0 }, 1, true));
localDataPoolMap.emplace(Max31865Definitions::PoolIds::FAULT_BYTE, localDataPoolMap.emplace(Max31865Definitions::PoolIds::FAULT_BYTE,
new PoolEntry<uint8_t>({0})); new PoolEntry<uint8_t>( { 0 }));
// poolManager.subscribeForPeriodicPacket(sensorDatasetSid, // poolManager.subscribeForPeriodicPacket(sensorDatasetSid,
// false, 4.0, false); // false, 4.0, false);
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
void Max31865PT1000Handler::modeChanged() { void Max31865PT1000Handler::modeChanged() {
internalState = InternalState::NONE; // internalState = InternalState::NONE;
} }

2
mission/devices/Max31865PT1000Handler.h
View File

@ -99,7 +99,7 @@ private:
REQUEST_FAULT_BYTE REQUEST_FAULT_BYTE
}; };
InternalState internalState = InternalState::NONE; InternalState internalState = InternalState::CONFIGURE;
bool commandExecuted = false; bool commandExecuted = false;
dur_millis_t startTime = 0; dur_millis_t startTime = 0;

1
mission/devices/RwHandler.cpp
View File

@ -185,6 +185,7 @@ ReturnValue_t RwHandler::scanForReply(const uint8_t *start, size_t remainingSize
sif::warning << "RwHandler::scanForReply: Reply contains invalid command code" << sif::warning << "RwHandler::scanForReply: Reply contains invalid command code" <<
std::endl; std::endl;
*foundLen = remainingSize; *foundLen = remainingSize;
// *foundLen = 1;
return RETURN_FAILED; return RETURN_FAILED;
} }
} }