eive-obsw/linux/devices/Max31865RtdPolling.h

91 lines
3.5 KiB
C
Raw Normal View History

#ifndef LINUX_DEVICES_MAX31865RTDREADER_H_
#define LINUX_DEVICES_MAX31865RTDREADER_H_
#include <fsfw/ipc/MutexIF.h>
#include <fsfw/tasks/ExecutableObjectIF.h>
2023-02-12 21:07:33 +01:00
#include <fsfw/timemanager/clockDefinitions.h>
#include <fsfw_hal/linux/spi/SpiComIF.h>
#include <fsfw_hal/linux/spi/SpiCookie.h>
2023-02-12 21:07:33 +01:00
#include "devConf.h"
#include "fsfw/devicehandlers/DeviceCommunicationIF.h"
#include "mission/devices/devicedefinitions/Max31865Definitions.h"
struct Max31865ReaderCookie : public CookieIF {
Max31865ReaderCookie(){};
Max31865ReaderCookie(object_id_t handlerId_, uint8_t idx_, const std::string& locString_,
SpiCookie* spiCookie_)
: idx(idx_), handlerId(handlerId_), locString(locString_), spiCookie(spiCookie_) {}
uint8_t idx = 0;
object_id_t handlerId = objects::NO_OBJECT;
std::string locString = "";
std::array<uint8_t, 12> exchangeBuf{};
2022-05-12 09:48:41 +02:00
Countdown cd = Countdown(MAX31865::WARMUP_MS);
2022-05-14 17:32:33 +02:00
2022-05-12 09:48:41 +02:00
bool on = false;
2022-05-12 11:27:30 +02:00
bool writeLowThreshold = false;
bool writeHighThreshold = false;
uint16_t lowThreshold = 0;
uint16_t highThreshold = 0;
SpiCookie* spiCookie = nullptr;
// Exchange data buffer struct
2022-05-12 09:48:41 +02:00
EiveMax31855::ReadOutStruct db;
};
2023-02-21 02:59:28 +01:00
class Max31865RtdPolling : public SystemObject,
public ExecutableObjectIF,
public DeviceCommunicationIF {
public:
2023-02-21 02:59:28 +01:00
Max31865RtdPolling(object_id_t objectId, SpiComIF* lowLevelComIF, GpioIF* gpioIF);
2022-05-14 17:22:57 +02:00
ReturnValue_t performOperation(uint8_t operationCode) override;
2022-05-14 11:34:25 +02:00
ReturnValue_t initialize() override;
private:
std::vector<Max31865ReaderCookie*> rtds;
2022-05-12 11:27:30 +02:00
std::array<uint8_t, 4> cmdBuf = {};
2022-05-14 09:41:28 +02:00
size_t dbLen = 0;
2023-03-02 15:38:20 +01:00
MutexIF* readerLock;
static constexpr MutexIF::TimeoutType LOCK_TYPE = MutexIF::TimeoutType::WAITING;
static constexpr uint32_t LOCK_TIMEOUT = 20;
static constexpr char LOCK_CTX[] = "Max31865RtdPolling";
2022-05-14 11:34:25 +02:00
SpiComIF* comIF;
GpioIF* gpioIF;
2023-02-12 21:07:33 +01:00
MutexIF::TimeoutType csTimeoutType = MutexIF::TimeoutType::WAITING;
uint32_t csTimeoutMs = spi::RTD_CS_TIMEOUT;
2022-05-14 11:34:25 +02:00
MutexIF* csLock = nullptr;
bool periodicInitHandling();
ReturnValue_t periodicReadReqHandling();
ReturnValue_t periodicReadHandling();
2022-05-12 09:48:41 +02:00
bool rtdIsActive(uint8_t idx);
ReturnValue_t writeCfgReg(SpiCookie* cookie, uint8_t cfg);
ReturnValue_t writeBiasSel(MAX31865::Bias bias, SpiCookie* cookie, uint8_t baseCfg);
ReturnValue_t readCfgReg(SpiCookie* cookie, uint8_t& cfg);
ReturnValue_t readRtdVal(SpiCookie* cookie, uint16_t& val, bool& faultBitSet);
2022-05-12 11:27:30 +02:00
ReturnValue_t writeLowThreshold(SpiCookie* cookie, uint16_t val);
ReturnValue_t writeHighThreshold(SpiCookie* cookie, uint16_t val);
ReturnValue_t readLowThreshold(SpiCookie* cookie, uint16_t& val);
ReturnValue_t readHighThreshold(SpiCookie* cookie, uint16_t& val);
ReturnValue_t clearFaultStatus(SpiCookie* cookie);
ReturnValue_t readNFromReg(SpiCookie* cookie, uint8_t reg, size_t n, uint8_t** reply);
ReturnValue_t writeNToReg(SpiCookie* cookie, uint8_t reg, size_t n, uint8_t* cmd,
uint8_t** reply);
ReturnValue_t initializeInterface(CookieIF* cookie) override;
ReturnValue_t sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) override;
ReturnValue_t getSendSuccess(CookieIF* cookie) override;
ReturnValue_t requestReceiveMessage(CookieIF* cookie, size_t requestLen) override;
ReturnValue_t readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) override;
2022-05-12 11:27:30 +02:00
ReturnValue_t handleSpiError(Max31865ReaderCookie* cookie, ReturnValue_t result, const char* ctx);
};
#endif /* LINUX_DEVICES_MAX31865RTDREADER_H_ */