ARC firmware for the ARSENAL

1// src/main.cpp
2namespace {
3    constexpr const char* TAG = "ARC";
4    constexpr uint8_t TMP117_ADDRESS = 0x48;
5    constexpr uint8_t TEMP1_ID = 2;
6    // ...
7    constexpr uint8_t TEMP1_MUX_CHANNEL = 3;   // 0x70, channel 3
8    // ...
9}
10
11extern "C" void app_main()
12{
13    // ...
14    auto& sensorBus = *I2CARSENAL::multiplexerBus;
15    constexpr auto temperature = SensorUtils::SensorConfig::TEMPERATURE;
16    static Sensor<2> temp1(
17        "temp1", sensorBus, TMP117_ADDRESS, TEMP1_ID, false, temperature, TEMP1_MUX_CHANNEL);
18    // ...
19
20    for (auto* sensor : {&temp1, &temp2, &temp3}) {
21        const auto status = sensor->setup();
22        if (status != SensorUtils::SENSOR_OK) {
23            ESP_LOGE(TAG, "%s setup failed: %s", sensor->getName().data(),
24                     SensorUtils::sensor_status_str(status));
25            continue;
26        }
27        // ...
28    }
29
30    ESP_ERROR_CHECK(RS485ARSENAL::startRS485ARSENAL());
31    // ...
32}
33
34// lib/Sensor/ARC_Sensor.h, in the Sensor<N> constructor
35    // SET SENSOR TYPE
36    // Offsets are added and type is changed
37    if (sensorType != SensorUtils::SensorConfig::NONE) {
38        this->setSensorType(sensorType);
39    }
40
41// lib/Sensor/ARC_Sensor.h, Sensor<N> members
42bool setSensorType(SensorUtils::SensorConfig config) override {
43    // Set the type of sensor and add the relevant values needed.
44
45    this->setSensorTypeWoOffset(config);
46    SensorOffsetConfig::addOffsets(*this, config);
47    return true;
48}
49
50bool setSensorTypeWoOffset(SensorUtils::SensorConfig config) {
51    // Set the type of sensor on its own
52
53    this->_type = config;
54    if (config == SensorUtils::SensorConfig::TEMPERATURE) {
55        this->_readFunction = SensorOffsetConfig::readTemperature<N>;
56        this->_offsetMemReg = 0x07;
57    }
58    return true;
59}
60
61// lib/Sensor/SensorOffsetConfig.h
62namespace SensorOffsetConfig {
63
64    template <std::size_t N>
65    void readTemperature(Sensor<N>& sensor, LockGuard& lock) {
66        constexpr uint8_t temperatureRegister = 0x00;
67        uint8_t temperatureBytes[2]{};
68        const esp_err_t readStatus = sensor.readDeviceRegister(
69            temperatureRegister, temperatureBytes, sizeof(temperatureBytes), lock);
70
71        if (readStatus != ESP_OK) {
72            return;
73        }
74
75        const uint16_t highByte = temperatureBytes[0];
76        const uint16_t lowByte = temperatureBytes[1];
77        const uint16_t rawTemperature = (highByte << 8) | lowByte;
78        sensor.setReadings({rawTemperature, 0, 0});
79    }
80
81    template <std::size_t N>
82    void addTemperatureOffsets(Sensor<N>& sensor) {
83        constexpr uint8_t temperatureOffsetRegister = 0x07;
84        constexpr uint16_t defaultTemperatureOffset = 0;
85        constexpr uint8_t temperaturePacketSection = 0;
86        constexpr uint8_t temperatureComponent = 0;
87        constexpr auto registerLayout = SensorUtils::OffsetLayout::REG_16_BIT_HIGH_FIRST;
88
89        sensor.appendOffset(
90            "offsetTemperature", defaultTemperatureOffset, temperatureOffsetRegister,
91            temperaturePacketSection, temperatureComponent, registerLayout);
92    }
93
94    // ...
95
96    // Register preset offsets once, before starting the sensor.
97    template <std::size_t N>
98    void addOffsets(Sensor<N>& sensor, SensorUtils::SensorConfig type) {
99        // ...
100        switch (type) {
101            case SensorUtils::SensorConfig::TEMPERATURE:
102                addTemperatureOffsets(sensor);
103                break;
104            // ...
105        }
106    }
107
108}

1class LockGuard {
2public:
3    explicit LockGuard(SemaphoreHandle_t& mutex) : _mutexReference(mutex) {
4        if (_mutexReference != nullptr &&
5            xSemaphoreTake(_mutexReference, portMAX_DELAY) != pdFALSE) {
6            _isLockedByLockGuard = true;
7        }
8    }
9    // Releases only if this guard took the mutex.
10    ~LockGuard() noexcept {
11        if (_isLockedByLockGuard) xSemaphoreGive(_mutexReference);
12    }
13    LockGuard(const LockGuard&) = delete;
14    LockGuard& operator=(const LockGuard&) = delete;
15    bool isMutexLocked() { return _isLockedByLockGuard; }
16private:
17    SemaphoreHandle_t& _mutexReference;
18    bool _isLockedByLockGuard = false;
19};

1=== SERIAL STATUS ===
2_status: ESP_OK (0)
3_isFirstRead: false
4_validPacket: false
5_currentPacketState: WAITING_FOR_HEADER (0)
6_packetLength: 22 body bytes
7_timeSinceLastReceive: 0
8_timeOfSending: 164438584
9_packet [full buffer] (128 bytes, hex):
10  000: 80 00 16 00 00 00 00 09 CD 22 38 10 00 00 00 00
11  016: 00 00 00 00 00 00 00 00 00 DE AD BE EF 00 00 00
12  032: 40 DE AD BE EF 00 00 00 00 00 00 00 00 00 00 00
13  ... (rows 048-112: all 00)
14_sensorIDS (slot order): 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
15=====================
16UART received: 37