improved chip select decoding
All checks were successful
EIVE/eive-obsw/pipeline/head This commit looks good
All checks were successful
EIVE/eive-obsw/pipeline/head This commit looks good
This commit is contained in:
parent
b7cd192185
commit
65b0376f69
@ -23,18 +23,6 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sen
|
||||
uint8_t writeBuffer[2];
|
||||
uint8_t writeSize = 0;
|
||||
|
||||
int fileDescriptor = 0;
|
||||
std::string device = cookie->getSpiDevice();
|
||||
UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "rwSpiCallback::spiCallback");
|
||||
if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "rwSpiCallback::spiCallback: Failed to open device file" << std::endl;
|
||||
return SpiComIF::OPENING_FILE_FAILED;
|
||||
}
|
||||
spi::SpiModes spiMode = spi::SpiModes::MODE_0;
|
||||
uint32_t spiSpeed = 0;
|
||||
cookie->getSpiParameters(spiMode, spiSpeed, nullptr);
|
||||
comIf->setSpiSpeedAndMode(fileDescriptor, spiMode, spiSpeed);
|
||||
|
||||
gpioId_t gpioId = cookie->getChipSelectPin();
|
||||
GpioIF* gpioIF = comIf->getGpioInterface();
|
||||
MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
|
||||
@ -45,6 +33,18 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sen
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
|
||||
int fileDescriptor = 0;
|
||||
std::string device = cookie->getSpiDevice();
|
||||
UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "rwSpiCallback::spiCallback");
|
||||
if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "rwSpiCallback::spiCallback: Failed to open device file" << std::endl;
|
||||
return SpiComIF::OPENING_FILE_FAILED;
|
||||
}
|
||||
// spi::SpiModes spiMode = spi::SpiModes::MODE_0;
|
||||
// uint32_t spiSpeed = 0;
|
||||
// cookie->getSpiParameters(spiMode, spiSpeed, nullptr);
|
||||
// comIf->setSpiSpeedAndMode(fileDescriptor, spiMode, spiSpeed);
|
||||
|
||||
result = mutex->lockMutex(timeoutType, timeoutMs);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::debug << "rwSpiCallback::spiCallback: Failed to lock mutex" << std::endl;
|
||||
@ -119,7 +119,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sen
|
||||
|
||||
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);
|
||||
|
||||
/**
|
||||
|
||||
@ -268,7 +268,8 @@ void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
|
||||
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,
|
||||
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) {
|
||||
@ -641,139 +642,149 @@ void ObjectFactory::createSyrlinksComponents() {
|
||||
void ObjectFactory::createRtdComponents(LinuxLibgpioIF *gpioComIF) {
|
||||
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,
|
||||
&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,
|
||||
&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,
|
||||
&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,
|
||||
&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,
|
||||
&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,
|
||||
&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,
|
||||
&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,
|
||||
&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,
|
||||
&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,
|
||||
&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,
|
||||
&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,
|
||||
&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,
|
||||
&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);
|
||||
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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,
|
||||
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,
|
||||
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,
|
||||
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,
|
||||
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,
|
||||
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,
|
||||
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,
|
||||
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,
|
||||
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,
|
||||
spi::RTD_SPEED);
|
||||
|
||||
Max31865PT1000Handler* rtdIc0 = new Max31865PT1000Handler(objects::RTD_IC_6, 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,
|
||||
Max31865PT1000Handler* rtdIc3 = new Max31865PT1000Handler(objects::RTD_IC_3, objects::SPI_COM_IF,
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
Max31865PT1000Handler* rtdIc7 = new Max31865PT1000Handler(objects::RTD_IC_10,
|
||||
objects::SPI_COM_IF, spiRtdIc7);
|
||||
Max31865PT1000Handler* rtdIc8 = new Max31865PT1000Handler(objects::RTD_IC_11,
|
||||
objects::SPI_COM_IF, spiRtdIc8);
|
||||
Max31865PT1000Handler* rtdIc9 = new Max31865PT1000Handler(objects::RTD_IC_12,
|
||||
objects::SPI_COM_IF, spiRtdIc9);
|
||||
Max31865PT1000Handler* rtdIc10 = new Max31865PT1000Handler(objects::RTD_IC_13,
|
||||
Max31865PT1000Handler* rtdIc7 = new Max31865PT1000Handler(objects::RTD_IC_7, objects::SPI_COM_IF,
|
||||
spiRtdIc7);
|
||||
Max31865PT1000Handler* rtdIc8 = new Max31865PT1000Handler(objects::RTD_IC_8, objects::SPI_COM_IF,
|
||||
spiRtdIc8);
|
||||
Max31865PT1000Handler* rtdIc9 = new Max31865PT1000Handler(objects::RTD_IC_9, objects::SPI_COM_IF,
|
||||
spiRtdIc9);
|
||||
Max31865PT1000Handler* rtdIc10 = new Max31865PT1000Handler(objects::RTD_IC_10,
|
||||
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);
|
||||
Max31865PT1000Handler* rtdIc12 = new Max31865PT1000Handler(objects::RTD_IC_15,
|
||||
Max31865PT1000Handler* rtdIc12 = new Max31865PT1000Handler(objects::RTD_IC_12,
|
||||
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);
|
||||
Max31865PT1000Handler* rtdIc14 = new Max31865PT1000Handler(objects::RTD_IC_17,
|
||||
Max31865PT1000Handler* rtdIc14 = new Max31865PT1000Handler(objects::RTD_IC_14,
|
||||
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);
|
||||
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();
|
||||
rtdIc1->setStartUpImmediately();
|
||||
rtdIc2->setStartUpImmediately();
|
||||
rtdIc3->setStartUpImmediately();
|
||||
rtdIc4->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>(rtdIc4);
|
||||
static_cast<void>(rtdIc5);
|
||||
@ -787,6 +798,9 @@ void ObjectFactory::createRtdComponents(LinuxLibgpioIF *gpioComIF) {
|
||||
static_cast<void>(rtdIc13);
|
||||
static_cast<void>(rtdIc14);
|
||||
static_cast<void>(rtdIc15);
|
||||
static_cast<void>(rtdIc16);
|
||||
static_cast<void>(rtdIc17);
|
||||
static_cast<void>(rtdIc18);
|
||||
}
|
||||
|
||||
void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) {
|
||||
@ -856,7 +870,6 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) {
|
||||
rwHandler1->setStartUpImmediately();
|
||||
#endif
|
||||
rw1SpiCookie->setCallbackArgs(rwHandler1);
|
||||
rwHandler1->setStartUpImmediately();
|
||||
|
||||
auto rwHandler2 = new RwHandler(objects::RW2, objects::SPI_COM_IF, rw2SpiCookie, gpioComIF,
|
||||
gpioIds::EN_RW2);
|
||||
|
||||
@ -27,10 +27,10 @@ void initSpiCsDecoder(GpioIF* gpioComIF) {
|
||||
GpiodRegularByLineName* spiMuxBit = nullptr;
|
||||
/** 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",
|
||||
gpio::OUT, gpio::LOW);
|
||||
gpio::OUT, gpio::HIGH);
|
||||
spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_1, spiMuxBit);
|
||||
/** 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);
|
||||
/** 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);
|
||||
@ -68,173 +68,308 @@ void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Lev
|
||||
}
|
||||
|
||||
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) {
|
||||
switch (gpioId) {
|
||||
case(gpioIds::RTD_IC_3): {
|
||||
enableDecoderTcsIc1();
|
||||
selectY7();
|
||||
enableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::RTD_IC_4): {
|
||||
enableDecoderTcsIc1();
|
||||
selectY6();
|
||||
enableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::RTD_IC_5): {
|
||||
enableDecoderTcsIc1();
|
||||
selectY5();
|
||||
enableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::RTD_IC_6): {
|
||||
enableDecoderTcsIc1();
|
||||
selectY4();
|
||||
enableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::RTD_IC_7): {
|
||||
enableDecoderTcsIc1();
|
||||
selectY3();
|
||||
enableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::RTD_IC_8): {
|
||||
enableDecoderTcsIc1();
|
||||
selectY2();
|
||||
enableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::RTD_IC_9): {
|
||||
enableDecoderTcsIc1();
|
||||
selectY1();
|
||||
enableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::RTD_IC_10): {
|
||||
enableDecoderTcsIc1();
|
||||
selectY0();
|
||||
enableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::RTD_IC_11): {
|
||||
enableDecoderTcsIc2();
|
||||
selectY7();
|
||||
enableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::RTD_IC_12): {
|
||||
enableDecoderTcsIc2();
|
||||
selectY6();
|
||||
enableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::RTD_IC_13): {
|
||||
enableDecoderTcsIc2();
|
||||
selectY5();
|
||||
enableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::RTD_IC_14): {
|
||||
enableDecoderTcsIc2();
|
||||
selectY4();
|
||||
enableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::RTD_IC_15): {
|
||||
enableDecoderTcsIc2();
|
||||
selectY3();
|
||||
enableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::RTD_IC_16): {
|
||||
enableDecoderTcsIc2();
|
||||
selectY2();
|
||||
enableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::RTD_IC_17): {
|
||||
enableDecoderTcsIc2();
|
||||
selectY1();
|
||||
enableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::RTD_IC_18): {
|
||||
enableDecoderTcsIc2();
|
||||
selectY0();
|
||||
enableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_SUS_1): {
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
selectY0();
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_SUS_2): {
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
selectY1();
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_SUS_3): {
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
selectY0();
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_SUS_4): {
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
selectY1();
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_SUS_5): {
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
selectY2();
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_SUS_6): {
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
selectY2();
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_SUS_7): {
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
selectY3();
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_SUS_8): {
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
selectY3();
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_SUS_9): {
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
selectY4();
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_SUS_10): {
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
selectY5();
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_SUS_11): {
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
selectY4();
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_SUS_12): {
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
selectY5();
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_SUS_13): {
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
selectY6();
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_RW1): {
|
||||
enableRwDecoder();
|
||||
selectY0();
|
||||
enableRwDecoder();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_RW2): {
|
||||
enableRwDecoder();
|
||||
selectY1();
|
||||
enableRwDecoder();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_RW3): {
|
||||
enableRwDecoder();
|
||||
selectY2();
|
||||
enableRwDecoder();
|
||||
break;
|
||||
}
|
||||
case(gpioIds::CS_RW4): {
|
||||
enableRwDecoder();
|
||||
selectY3();
|
||||
enableRwDecoder();
|
||||
break;
|
||||
}
|
||||
default:
|
||||
@ -253,9 +388,9 @@ void enableDecoderTcsIc1() {
|
||||
}
|
||||
|
||||
void enableDecoderTcsIc2() {
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
|
||||
}
|
||||
|
||||
void enableDecoderInterfaceBoardIc1() {
|
||||
@ -266,17 +401,43 @@ void enableDecoderInterfaceBoardIc1() {
|
||||
|
||||
void enableDecoderInterfaceBoardIc2() {
|
||||
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->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() {
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
|
||||
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() {
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
|
||||
@ -326,9 +487,9 @@ void selectY7() {
|
||||
}
|
||||
|
||||
void disableAllDecoder() {
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
|
||||
gpioComInterface->pullLow(gpioIds::EN_RW_CS);
|
||||
}
|
||||
|
||||
|
||||
@ -44,10 +44,16 @@ namespace gpioCallbacks {
|
||||
*/
|
||||
void enableDecoderInterfaceBoardIc2();
|
||||
|
||||
void disableDecoderTcsIc1();
|
||||
void disableDecoderTcsIc2();
|
||||
void disableDecoderInterfaceBoardIc1();
|
||||
void disableDecoderInterfaceBoardIc2();
|
||||
|
||||
/**
|
||||
* @brief Enables the reaction wheel chip select decoder (IC3).
|
||||
*/
|
||||
void enableRwDecoder();
|
||||
void disableRwDecoder();
|
||||
|
||||
/**
|
||||
* @brief This function disables all decoder.
|
||||
|
||||
@ -36,9 +36,6 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
|
||||
DeviceHandlerIF::PERFORM_OPERATION);
|
||||
#endif
|
||||
#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_4, 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_14, 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 */
|
||||
|
||||
#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);
|
||||
#endif
|
||||
#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_4, 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_14, 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 */
|
||||
|
||||
#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);
|
||||
#endif
|
||||
#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_4, 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_14, 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 */
|
||||
|
||||
#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);
|
||||
#endif
|
||||
#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_4, 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_14, 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 */
|
||||
|
||||
#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);
|
||||
#endif
|
||||
#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_4, 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_14, 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 */
|
||||
|
||||
#if OBSW_ADD_RAD_SENSORS == 1
|
||||
|
||||
@ -6,9 +6,9 @@
|
||||
#include <cmath>
|
||||
|
||||
Max31865PT1000Handler::Max31865PT1000Handler(object_id_t objectId, object_id_t comIF,
|
||||
CookieIF *comCookie):
|
||||
DeviceHandlerBase(objectId, comIF, comCookie), sensorDataset(this),
|
||||
sensorDatasetSid(sensorDataset.getSid()) {
|
||||
CookieIF *comCookie) :
|
||||
DeviceHandlerBase(objectId, comIF, comCookie), sensorDataset(this), sensorDatasetSid(
|
||||
sensorDataset.getSid()) {
|
||||
#if OBSW_VERBOSE_LEVEL >= 1
|
||||
debugDivider = new PeriodicOperationDivider(0);
|
||||
#endif
|
||||
@ -18,62 +18,63 @@ Max31865PT1000Handler::~Max31865PT1000Handler() {
|
||||
}
|
||||
|
||||
void Max31865PT1000Handler::doStartUp() {
|
||||
if(internalState == InternalState::NONE) {
|
||||
internalState = InternalState::WARMUP;
|
||||
Clock::getUptime(&startTime);
|
||||
}
|
||||
|
||||
if(internalState == InternalState::WARMUP) {
|
||||
dur_millis_t timeNow = 0;
|
||||
Clock::getUptime(&timeNow);
|
||||
if(timeNow - startTime >= 100) {
|
||||
internalState = InternalState::CONFIGURE;
|
||||
}
|
||||
}
|
||||
|
||||
if(internalState == InternalState::CONFIGURE) {
|
||||
if(commandExecuted) {
|
||||
commandExecuted = false;
|
||||
internalState = InternalState::REQUEST_CONFIG;
|
||||
}
|
||||
}
|
||||
|
||||
if(internalState == InternalState::REQUEST_CONFIG) {
|
||||
if (commandExecuted) {
|
||||
commandExecuted = false;
|
||||
internalState = InternalState::CONFIG_HIGH_THRESHOLD;
|
||||
}
|
||||
}
|
||||
|
||||
if(internalState == InternalState::CONFIG_HIGH_THRESHOLD) {
|
||||
if(commandExecuted) {
|
||||
internalState = InternalState::REQUEST_HIGH_THRESHOLD;
|
||||
commandExecuted = false;
|
||||
}
|
||||
}
|
||||
|
||||
if(internalState == InternalState::REQUEST_HIGH_THRESHOLD) {
|
||||
if(commandExecuted) {
|
||||
internalState = InternalState::CONFIG_LOW_THRESHOLD;
|
||||
commandExecuted = false;
|
||||
}
|
||||
}
|
||||
|
||||
if(internalState == InternalState::CONFIG_LOW_THRESHOLD) {
|
||||
if(commandExecuted) {
|
||||
internalState = InternalState::REQUEST_LOW_THRESHOLD;
|
||||
commandExecuted = false;
|
||||
}
|
||||
}
|
||||
|
||||
if(internalState == InternalState::REQUEST_LOW_THRESHOLD) {
|
||||
if(commandExecuted) {
|
||||
setMode(MODE_ON);
|
||||
// if (internalState == InternalState::NONE) {
|
||||
// internalState = InternalState::WARMUP;
|
||||
// Clock::getUptime(&startTime);
|
||||
// }
|
||||
//
|
||||
// if (internalState == InternalState::WARMUP) {
|
||||
// dur_millis_t timeNow = 0;
|
||||
// Clock::getUptime(&timeNow);
|
||||
// if (timeNow - startTime >= 100) {
|
||||
// internalState = InternalState::CONFIGURE;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// if (internalState == InternalState::CONFIGURE) {
|
||||
// if (commandExecuted) {
|
||||
// commandExecuted = false;
|
||||
// internalState = InternalState::REQUEST_CONFIG;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// if (internalState == InternalState::REQUEST_CONFIG) {
|
||||
// if (commandExecuted) {
|
||||
// commandExecuted = false;
|
||||
// internalState = InternalState::CONFIG_HIGH_THRESHOLD;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// if (internalState == InternalState::CONFIG_HIGH_THRESHOLD) {
|
||||
// if (commandExecuted) {
|
||||
// internalState = InternalState::REQUEST_HIGH_THRESHOLD;
|
||||
// commandExecuted = false;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// if (internalState == InternalState::REQUEST_HIGH_THRESHOLD) {
|
||||
// if (commandExecuted) {
|
||||
// internalState = InternalState::CONFIG_LOW_THRESHOLD;
|
||||
// commandExecuted = false;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// if (internalState == InternalState::CONFIG_LOW_THRESHOLD) {
|
||||
// if (commandExecuted) {
|
||||
// internalState = InternalState::REQUEST_LOW_THRESHOLD;
|
||||
// commandExecuted = false;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// if (internalState == InternalState::REQUEST_LOW_THRESHOLD) {
|
||||
// if (commandExecuted) {
|
||||
// setMode(MODE_ON);
|
||||
// setMode(MODE_NORMAL);
|
||||
// internalState = InternalState::RUNNING;
|
||||
// commandExecuted = false;
|
||||
// }
|
||||
// }
|
||||
setMode(MODE_NORMAL);
|
||||
internalState = InternalState::RUNNING;
|
||||
commandExecuted = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Max31865PT1000Handler::doShutDown() {
|
||||
@ -81,50 +82,58 @@ void Max31865PT1000Handler::doShutDown() {
|
||||
setMode(_MODE_POWER_DOWN);
|
||||
}
|
||||
|
||||
ReturnValue_t Max31865PT1000Handler::buildNormalDeviceCommand(
|
||||
DeviceCommandId_t *id) {
|
||||
if(internalState == InternalState::RUNNING) {
|
||||
*id = Max31865Definitions::REQUEST_RTD;
|
||||
ReturnValue_t Max31865PT1000Handler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
|
||||
// if (internalState == InternalState::RUNNING) {
|
||||
// *id = Max31865Definitions::REQUEST_RTD;
|
||||
// return buildCommandFromCommand(*id, nullptr, 0);
|
||||
// } else if (internalState == InternalState::REQUEST_FAULT_BYTE) {
|
||||
// *id = Max31865Definitions::REQUEST_FAULT_BYTE;
|
||||
// return buildCommandFromCommand(*id, nullptr, 0);
|
||||
// } 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 if(internalState == InternalState::REQUEST_FAULT_BYTE) {
|
||||
*id = Max31865Definitions::REQUEST_FAULT_BYTE;
|
||||
return buildCommandFromCommand(*id, nullptr, 0);
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
return DeviceHandlerBase::NOTHING_TO_SEND;
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t Max31865PT1000Handler::buildTransitionDeviceCommand(
|
||||
DeviceCommandId_t *id) {
|
||||
switch(internalState) {
|
||||
case(InternalState::NONE):
|
||||
case(InternalState::WARMUP):
|
||||
case(InternalState::RUNNING):
|
||||
ReturnValue_t Max31865PT1000Handler::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
|
||||
switch (internalState) {
|
||||
case (InternalState::NONE):
|
||||
case (InternalState::WARMUP):
|
||||
case (InternalState::RUNNING):
|
||||
return DeviceHandlerBase::NOTHING_TO_SEND;
|
||||
case(InternalState::CONFIGURE): {
|
||||
case (InternalState::CONFIGURE): {
|
||||
*id = Max31865Definitions::CONFIG_CMD;
|
||||
uint8_t config[1] = {DEFAULT_CONFIG};
|
||||
uint8_t config[1] = { DEFAULT_CONFIG };
|
||||
return buildCommandFromCommand(*id, config, 1);
|
||||
}
|
||||
case(InternalState::REQUEST_CONFIG): {
|
||||
case (InternalState::REQUEST_CONFIG): {
|
||||
*id = Max31865Definitions::REQUEST_CONFIG;
|
||||
return buildCommandFromCommand(*id, nullptr, 0);
|
||||
}
|
||||
case(InternalState::CONFIG_HIGH_THRESHOLD): {
|
||||
case (InternalState::CONFIG_HIGH_THRESHOLD): {
|
||||
*id = Max31865Definitions::WRITE_HIGH_THRESHOLD;
|
||||
return buildCommandFromCommand(*id, nullptr, 0);
|
||||
}
|
||||
case(InternalState::REQUEST_HIGH_THRESHOLD): {
|
||||
case (InternalState::REQUEST_HIGH_THRESHOLD): {
|
||||
*id = Max31865Definitions::REQUEST_HIGH_THRESHOLD;
|
||||
return buildCommandFromCommand(*id, nullptr, 0);
|
||||
}
|
||||
case(InternalState::CONFIG_LOW_THRESHOLD): {
|
||||
case (InternalState::CONFIG_LOW_THRESHOLD): {
|
||||
*id = Max31865Definitions::WRITE_LOW_THRESHOLD;
|
||||
return buildCommandFromCommand(*id, nullptr, 0);
|
||||
}
|
||||
case(InternalState::REQUEST_LOW_THRESHOLD): {
|
||||
case (InternalState::REQUEST_LOW_THRESHOLD): {
|
||||
*id = Max31865Definitions::REQUEST_LOW_THRESHOLD;
|
||||
return buildCommandFromCommand(*id, nullptr, 0);
|
||||
}
|
||||
@ -139,69 +148,61 @@ ReturnValue_t Max31865PT1000Handler::buildTransitionDeviceCommand(
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t Max31865PT1000Handler::buildCommandFromCommand(
|
||||
DeviceCommandId_t deviceCommand, const uint8_t *commandData,
|
||||
size_t commandDataLen) {
|
||||
switch(deviceCommand) {
|
||||
case(Max31865Definitions::CONFIG_CMD) : {
|
||||
ReturnValue_t Max31865PT1000Handler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
|
||||
const uint8_t *commandData, size_t commandDataLen) {
|
||||
switch (deviceCommand) {
|
||||
case (Max31865Definitions::CONFIG_CMD): {
|
||||
commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::CONFIG_CMD);
|
||||
if(commandDataLen == 1) {
|
||||
if (commandDataLen == 1) {
|
||||
commandBuffer[1] = commandData[0];
|
||||
DeviceHandlerBase::rawPacketLen = 2;
|
||||
DeviceHandlerBase::rawPacket = commandBuffer.data();
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
return DeviceHandlerIF::NO_COMMAND_DATA;
|
||||
}
|
||||
}
|
||||
case(Max31865Definitions::REQUEST_CONFIG): {
|
||||
commandBuffer[0] = static_cast<uint8_t>(
|
||||
Max31865Definitions::REQUEST_CONFIG);
|
||||
case (Max31865Definitions::REQUEST_CONFIG): {
|
||||
commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::REQUEST_CONFIG);
|
||||
commandBuffer[1] = 0x00; // dummy byte
|
||||
DeviceHandlerBase::rawPacketLen = 2;
|
||||
DeviceHandlerBase::rawPacket = commandBuffer.data();
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
case(Max31865Definitions::WRITE_HIGH_THRESHOLD): {
|
||||
commandBuffer[0] = static_cast<uint8_t>(
|
||||
Max31865Definitions::WRITE_HIGH_THRESHOLD);
|
||||
case (Max31865Definitions::WRITE_HIGH_THRESHOLD): {
|
||||
commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::WRITE_HIGH_THRESHOLD);
|
||||
commandBuffer[1] = static_cast<uint8_t>(HIGH_THRESHOLD >> 8);
|
||||
commandBuffer[2] = static_cast<uint8_t>(HIGH_THRESHOLD & 0xFF);
|
||||
DeviceHandlerBase::rawPacketLen = 3;
|
||||
DeviceHandlerBase::rawPacket = commandBuffer.data();
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
case(Max31865Definitions::REQUEST_HIGH_THRESHOLD): {
|
||||
commandBuffer[0] = static_cast<uint8_t>(
|
||||
Max31865Definitions::REQUEST_HIGH_THRESHOLD);
|
||||
case (Max31865Definitions::REQUEST_HIGH_THRESHOLD): {
|
||||
commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::REQUEST_HIGH_THRESHOLD);
|
||||
commandBuffer[1] = 0x00; //dummy byte
|
||||
commandBuffer[2] = 0x00; //dummy byte
|
||||
DeviceHandlerBase::rawPacketLen = 3;
|
||||
DeviceHandlerBase::rawPacket = commandBuffer.data();
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
case(Max31865Definitions::WRITE_LOW_THRESHOLD): {
|
||||
commandBuffer[0] = static_cast<uint8_t>(
|
||||
Max31865Definitions::WRITE_LOW_THRESHOLD);
|
||||
case (Max31865Definitions::WRITE_LOW_THRESHOLD): {
|
||||
commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::WRITE_LOW_THRESHOLD);
|
||||
commandBuffer[1] = static_cast<uint8_t>(LOW_THRESHOLD >> 8);
|
||||
commandBuffer[2] = static_cast<uint8_t>(LOW_THRESHOLD & 0xFF);
|
||||
DeviceHandlerBase::rawPacketLen = 3;
|
||||
DeviceHandlerBase::rawPacket = commandBuffer.data();
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
case(Max31865Definitions::REQUEST_LOW_THRESHOLD): {
|
||||
commandBuffer[0] = static_cast<uint8_t>(
|
||||
Max31865Definitions::REQUEST_LOW_THRESHOLD);
|
||||
case (Max31865Definitions::REQUEST_LOW_THRESHOLD): {
|
||||
commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::REQUEST_LOW_THRESHOLD);
|
||||
commandBuffer[1] = 0x00; //dummy byte
|
||||
commandBuffer[2] = 0x00; //dummy byte
|
||||
DeviceHandlerBase::rawPacketLen = 3;
|
||||
DeviceHandlerBase::rawPacket = commandBuffer.data();
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
case(Max31865Definitions::REQUEST_RTD): {
|
||||
commandBuffer[0] = static_cast<uint8_t>(
|
||||
Max31865Definitions::REQUEST_RTD);
|
||||
case (Max31865Definitions::REQUEST_RTD): {
|
||||
commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::REQUEST_RTD);
|
||||
// two dummy bytes
|
||||
commandBuffer[1] = 0x00;
|
||||
commandBuffer[2] = 0x00;
|
||||
@ -209,9 +210,8 @@ ReturnValue_t Max31865PT1000Handler::buildCommandFromCommand(
|
||||
DeviceHandlerBase::rawPacket = commandBuffer.data();
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
case(Max31865Definitions::REQUEST_FAULT_BYTE): {
|
||||
commandBuffer[0] = static_cast<uint8_t>(
|
||||
Max31865Definitions::REQUEST_FAULT_BYTE);
|
||||
case (Max31865Definitions::REQUEST_FAULT_BYTE): {
|
||||
commandBuffer[0] = static_cast<uint8_t>(Max31865Definitions::REQUEST_FAULT_BYTE);
|
||||
commandBuffer[1] = 0x00;
|
||||
DeviceHandlerBase::rawPacketLen = 2;
|
||||
DeviceHandlerBase::rawPacket = commandBuffer.data();
|
||||
@ -230,43 +230,41 @@ void Max31865PT1000Handler::fillCommandAndReplyMap() {
|
||||
insertInCommandAndReplyMap(Max31865Definitions::REQUEST_LOW_THRESHOLD, 3);
|
||||
insertInCommandAndReplyMap(Max31865Definitions::WRITE_HIGH_THRESHOLD, 3);
|
||||
insertInCommandAndReplyMap(Max31865Definitions::REQUEST_HIGH_THRESHOLD, 3);
|
||||
insertInCommandAndReplyMap(Max31865Definitions::REQUEST_RTD, 3,
|
||||
&sensorDataset);
|
||||
insertInCommandAndReplyMap(Max31865Definitions::REQUEST_RTD, 3, &sensorDataset);
|
||||
insertInCommandAndReplyMap(Max31865Definitions::REQUEST_FAULT_BYTE, 3);
|
||||
}
|
||||
|
||||
ReturnValue_t Max31865PT1000Handler::scanForReply(const uint8_t *start,
|
||||
size_t remainingSize, DeviceCommandId_t *foundId, size_t *foundLen) {
|
||||
ReturnValue_t Max31865PT1000Handler::scanForReply(const uint8_t *start, size_t remainingSize,
|
||||
DeviceCommandId_t *foundId, size_t *foundLen) {
|
||||
size_t rtdReplySize = 3;
|
||||
size_t configReplySize = 2;
|
||||
|
||||
if(remainingSize == rtdReplySize and
|
||||
internalState == InternalState::RUNNING) {
|
||||
if (remainingSize == rtdReplySize and internalState == InternalState::RUNNING) {
|
||||
*foundId = Max31865Definitions::REQUEST_RTD;
|
||||
*foundLen = rtdReplySize;
|
||||
return RETURN_OK;
|
||||
}
|
||||
|
||||
if(remainingSize == 3) {
|
||||
switch(internalState) {
|
||||
case(InternalState::CONFIG_HIGH_THRESHOLD): {
|
||||
if (remainingSize == 3) {
|
||||
switch (internalState) {
|
||||
case (InternalState::CONFIG_HIGH_THRESHOLD): {
|
||||
*foundLen = 3;
|
||||
*foundId = Max31865Definitions::WRITE_HIGH_THRESHOLD;
|
||||
commandExecuted = true;
|
||||
return RETURN_OK;
|
||||
}
|
||||
case(InternalState::REQUEST_HIGH_THRESHOLD): {
|
||||
case (InternalState::REQUEST_HIGH_THRESHOLD): {
|
||||
*foundLen = 3;
|
||||
*foundId = Max31865Definitions::REQUEST_HIGH_THRESHOLD;
|
||||
return RETURN_OK;
|
||||
}
|
||||
case(InternalState::CONFIG_LOW_THRESHOLD): {
|
||||
case (InternalState::CONFIG_LOW_THRESHOLD): {
|
||||
*foundLen = 3;
|
||||
*foundId = Max31865Definitions::WRITE_LOW_THRESHOLD;
|
||||
commandExecuted = true;
|
||||
return RETURN_OK;
|
||||
}
|
||||
case(InternalState::REQUEST_LOW_THRESHOLD): {
|
||||
case (InternalState::REQUEST_LOW_THRESHOLD): {
|
||||
*foundLen = 3;
|
||||
*foundId = Max31865Definitions::REQUEST_LOW_THRESHOLD;
|
||||
return RETURN_OK;
|
||||
@ -279,56 +277,60 @@ ReturnValue_t Max31865PT1000Handler::scanForReply(const uint8_t *start,
|
||||
}
|
||||
}
|
||||
|
||||
if(remainingSize == configReplySize) {
|
||||
if(internalState == InternalState::CONFIGURE) {
|
||||
if (remainingSize == configReplySize) {
|
||||
if (internalState == InternalState::CONFIGURE) {
|
||||
commandExecuted = true;
|
||||
*foundLen = configReplySize;
|
||||
*foundId = Max31865Definitions::CONFIG_CMD;
|
||||
}
|
||||
else if(internalState == InternalState::REQUEST_FAULT_BYTE) {
|
||||
internalState = InternalState::REQUEST_CONFIG;
|
||||
} else if (internalState == InternalState::REQUEST_FAULT_BYTE) {
|
||||
*foundId = Max31865Definitions::REQUEST_FAULT_BYTE;
|
||||
*foundLen = 2;
|
||||
internalState = InternalState::RUNNING;
|
||||
}
|
||||
else {
|
||||
// internalState = InternalState::RUNNING;
|
||||
} else {
|
||||
*foundId = Max31865Definitions::REQUEST_CONFIG;
|
||||
*foundLen = configReplySize;
|
||||
internalState = InternalState::CONFIGURE;
|
||||
}
|
||||
}
|
||||
|
||||
return RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t Max31865PT1000Handler::interpretDeviceReply(
|
||||
DeviceCommandId_t id, const uint8_t *packet) {
|
||||
switch(id) {
|
||||
case(Max31865Definitions::REQUEST_CONFIG): {
|
||||
if(packet[1] != DEFAULT_CONFIG) {
|
||||
ReturnValue_t Max31865PT1000Handler::interpretDeviceReply(DeviceCommandId_t id,
|
||||
const uint8_t *packet) {
|
||||
switch (id) {
|
||||
case (Max31865Definitions::REQUEST_CONFIG): {
|
||||
if (packet[1] != DEFAULT_CONFIG) {
|
||||
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
||||
// 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
|
||||
sif::printError("Max31865PT1000Handler: Invalid configuration reply!\n");
|
||||
#endif
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
// set to true for invalid configs too for now.
|
||||
if(internalState == InternalState::REQUEST_CONFIG) {
|
||||
commandExecuted = true;
|
||||
else {
|
||||
sif::debug << "Max31865PT1000Handler: Object ID: " << std::hex << this->getObjectId()
|
||||
<< ": Config readback successful!" << std::endl;
|
||||
}
|
||||
else if(internalState == InternalState::RUNNING) {
|
||||
// set to true for invalid configs too for now.
|
||||
if (internalState == InternalState::REQUEST_CONFIG) {
|
||||
commandExecuted = true;
|
||||
} else if (internalState == InternalState::RUNNING) {
|
||||
// we should propably generate a telemetry with the config byte
|
||||
// as payload here.
|
||||
}
|
||||
break;
|
||||
}
|
||||
case(Max31865Definitions::REQUEST_LOW_THRESHOLD): {
|
||||
case (Max31865Definitions::REQUEST_LOW_THRESHOLD): {
|
||||
uint16_t readLowThreshold = packet[1] << 8 | packet[2];
|
||||
if(readLowThreshold != LOW_THRESHOLD) {
|
||||
if (readLowThreshold != LOW_THRESHOLD) {
|
||||
#if FSFW_VERBOSE_LEVEL >= 1
|
||||
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
||||
sif::warning << "Max31865PT1000Handler::interpretDeviceReply: Missmatch between " <<
|
||||
"written and readback value of low threshold register" << std::endl;
|
||||
sif::warning << "Max31865PT1000Handler::interpretDeviceReply: Missmatch between "
|
||||
<< "written and readback value of low threshold register" << std::endl;
|
||||
#else
|
||||
sif::printWarning("Max31865PT1000Handler::interpretDeviceReply: Missmatch between "
|
||||
"written and readback value of low threshold register\n");
|
||||
@ -338,13 +340,13 @@ ReturnValue_t Max31865PT1000Handler::interpretDeviceReply(
|
||||
commandExecuted = true;
|
||||
break;
|
||||
}
|
||||
case(Max31865Definitions::REQUEST_HIGH_THRESHOLD): {
|
||||
case (Max31865Definitions::REQUEST_HIGH_THRESHOLD): {
|
||||
uint16_t readHighThreshold = packet[1] << 8 | packet[2];
|
||||
if(readHighThreshold != HIGH_THRESHOLD) {
|
||||
if (readHighThreshold != HIGH_THRESHOLD) {
|
||||
#if FSFW_VERBOSE_LEVEL >= 1
|
||||
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
||||
sif::warning << "Max31865PT1000Handler::interpretDeviceReply: Missmatch between " <<
|
||||
"written and readback value of high threshold register" << std::endl;
|
||||
sif::warning << "Max31865PT1000Handler::interpretDeviceReply: Missmatch between "
|
||||
<< "written and readback value of high threshold register" << std::endl;
|
||||
#else
|
||||
sif::printWarning("Max31865PT1000Handler::interpretDeviceReply: Missmatch between "
|
||||
"written and readback value of high threshold register\n");
|
||||
@ -354,10 +356,10 @@ ReturnValue_t Max31865PT1000Handler::interpretDeviceReply(
|
||||
commandExecuted = true;
|
||||
break;
|
||||
}
|
||||
case(Max31865Definitions::REQUEST_RTD): {
|
||||
case (Max31865Definitions::REQUEST_RTD): {
|
||||
// first bit of LSB reply byte is the fault bit
|
||||
uint8_t faultBit = packet[2] & 0b0000'0001;
|
||||
if(faultBit == 1) {
|
||||
if (faultBit == 1) {
|
||||
// Maybe we should attempt to restart it?
|
||||
internalState = InternalState::REQUEST_FAULT_BYTE;
|
||||
}
|
||||
@ -373,9 +375,10 @@ ReturnValue_t Max31865PT1000Handler::interpretDeviceReply(
|
||||
|
||||
#if OBSW_DEBUG_RTD == 1
|
||||
#if OBSW_VERBOSE_LEVEL >= 1
|
||||
if(debugDivider->checkAndIncrement()) {
|
||||
if (debugDivider->checkAndIncrement()) {
|
||||
#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()
|
||||
<< "Measured resistance is " << rtdValue << " Ohms." << std::endl;
|
||||
sif::info << "Approximated temperature is " << approxTemp << " C" << std::endl;
|
||||
#else
|
||||
sif::printInfo("Max31685: Measured resistance is %f Ohms\n", rtdValue);
|
||||
@ -385,7 +388,7 @@ ReturnValue_t Max31865PT1000Handler::interpretDeviceReply(
|
||||
#endif
|
||||
#endif
|
||||
PoolReadGuard pg(&sensorDataset);
|
||||
if(pg.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (pg.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
|
||||
// Configuration error
|
||||
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
||||
sif::warning << "Max31865PT1000Handler::interpretDeviceReply: Error reading dataset!"
|
||||
@ -397,7 +400,7 @@ ReturnValue_t Max31865PT1000Handler::interpretDeviceReply(
|
||||
return pg.getReadResult();
|
||||
}
|
||||
|
||||
if(not sensorDataset.isValid()) {
|
||||
if (not sensorDataset.isValid()) {
|
||||
sensorDataset.setValidity(true, false);
|
||||
sensorDataset.rtdValue.setValid(true);
|
||||
sensorDataset.temperatureCelcius.setValid(true);
|
||||
@ -407,19 +410,19 @@ ReturnValue_t Max31865PT1000Handler::interpretDeviceReply(
|
||||
sensorDataset.temperatureCelcius = approxTemp;
|
||||
break;
|
||||
}
|
||||
case(Max31865Definitions::REQUEST_FAULT_BYTE): {
|
||||
case (Max31865Definitions::REQUEST_FAULT_BYTE): {
|
||||
faultByte = packet[1];
|
||||
#if OBSW_VERBOSE_LEVEL >= 1
|
||||
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
||||
sif::warning << "Max31865PT1000Handler::interpretDeviceReply: Fault byte"
|
||||
" is: 0b" << std::bitset<8>(faultByte) << std::endl;
|
||||
" is: 0b" << std::bitset < 8 > (faultByte) << std::endl;
|
||||
#else
|
||||
sif::printWarning("Max31865PT1000Handler::interpretDeviceReply: Fault byte"
|
||||
" is: 0b" BYTE_TO_BINARY_PATTERN "\n", BYTE_TO_BINARY(faultByte));
|
||||
#endif
|
||||
#endif
|
||||
ReturnValue_t result = sensorDataset.read();
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
// Configuration error
|
||||
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
||||
sif::debug << "Max31865PT1000Handler::interpretDeviceReply: "
|
||||
@ -432,12 +435,12 @@ ReturnValue_t Max31865PT1000Handler::interpretDeviceReply(
|
||||
}
|
||||
sensorDataset.errorByte.setValid(true);
|
||||
sensorDataset.errorByte = faultByte;
|
||||
if(faultByte != 0) {
|
||||
if (faultByte != 0) {
|
||||
sensorDataset.temperatureCelcius.setValid(false);
|
||||
}
|
||||
|
||||
result = sensorDataset.commit();
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
// Configuration error
|
||||
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
||||
sif::debug << "Max31865PT1000Handler::interpretDeviceReply: "
|
||||
@ -457,37 +460,35 @@ ReturnValue_t Max31865PT1000Handler::interpretDeviceReply(
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
void Max31865PT1000Handler::debugInterface(uint8_t positionTracker,
|
||||
object_id_t objectId, uint32_t parameter) {
|
||||
void Max31865PT1000Handler::debugInterface(uint8_t positionTracker, object_id_t objectId,
|
||||
uint32_t parameter) {
|
||||
}
|
||||
|
||||
uint32_t Max31865PT1000Handler::getTransitionDelayMs(
|
||||
Mode_t modeFrom, Mode_t modeTo) {
|
||||
uint32_t Max31865PT1000Handler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
|
||||
return 25000;
|
||||
}
|
||||
|
||||
ReturnValue_t Max31865PT1000Handler::getSwitches(
|
||||
const uint8_t **switches, uint8_t *numberOfSwitches) {
|
||||
ReturnValue_t Max31865PT1000Handler::getSwitches(const uint8_t **switches,
|
||||
uint8_t *numberOfSwitches) {
|
||||
return DeviceHandlerBase::NO_SWITCH;
|
||||
}
|
||||
|
||||
void Max31865PT1000Handler::doTransition(Mode_t modeFrom,
|
||||
Submode_t subModeFrom) {
|
||||
void Max31865PT1000Handler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
|
||||
DeviceHandlerBase::doTransition(modeFrom, subModeFrom);
|
||||
}
|
||||
|
||||
ReturnValue_t Max31865PT1000Handler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
|
||||
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,
|
||||
new PoolEntry<float>({0}, 1, true));
|
||||
new PoolEntry<float>( { 0 }, 1, true));
|
||||
localDataPoolMap.emplace(Max31865Definitions::PoolIds::FAULT_BYTE,
|
||||
new PoolEntry<uint8_t>({0}));
|
||||
new PoolEntry<uint8_t>( { 0 }));
|
||||
// poolManager.subscribeForPeriodicPacket(sensorDatasetSid,
|
||||
// false, 4.0, false);
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
void Max31865PT1000Handler::modeChanged() {
|
||||
internalState = InternalState::NONE;
|
||||
// internalState = InternalState::NONE;
|
||||
}
|
||||
|
||||
@ -99,7 +99,7 @@ private:
|
||||
REQUEST_FAULT_BYTE
|
||||
};
|
||||
|
||||
InternalState internalState = InternalState::NONE;
|
||||
InternalState internalState = InternalState::CONFIGURE;
|
||||
bool commandExecuted = false;
|
||||
|
||||
dur_millis_t startTime = 0;
|
||||
|
||||
@ -185,6 +185,7 @@ ReturnValue_t RwHandler::scanForReply(const uint8_t *start, size_t remainingSize
|
||||
sif::warning << "RwHandler::scanForReply: Reply contains invalid command code" <<
|
||||
std::endl;
|
||||
*foundLen = remainingSize;
|
||||
// *foundLen = 1;
|
||||
return RETURN_FAILED;
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user