fix pressure conversions

caila-marashaj · caila-marashaj · commit 2ef8a57fad80 · 2025-11-13T15:04:07.000-05:00
diff --git a/stm32-modules/include/flex-stacker/firmware/i2c_hardware.h b/stm32-modules/include/flex-stacker/firmware/i2c_hardware.h
@@ -10,6 +10,7 @@ extern "C" {
 #endif  // __cplusplus
 
 typedef enum I2C_BUS {
+    I2C_BUS_1,
     I2C_BUS_2,
     I2C_BUS_3,
     NO_BUS,
@@ -18,6 +19,7 @@ typedef enum I2C_BUS {
 typedef void *HAL_I2C_HANDLE;
 
 typedef struct HandlerStruct {
+    HAL_I2C_HANDLE i2c1;
     HAL_I2C_HANDLE i2c2;
     HAL_I2C_HANDLE i2c3;
 } I2CHandlerStruct;
diff --git a/stm32-modules/include/vacuum-module/vacuum-module/MPRLL0025PA00001A.hpp b/stm32-modules/include/vacuum-module/vacuum-module/MPRLL0025PA00001A.hpp
@@ -7,31 +7,30 @@
 #include "firmware/vacuum_pressure_sensor_policy.hpp"
 
 namespace vacuum_pressure_sensor {
+using hardware::VacuumPressureSensorPolicy;
+using i2c::hardware::RxTxReturn;
 
 template <typename P>
 concept MPRPolicy = requires(P p, uint16_t dev_addr, uint16_t reg,
                              uint16_t size, uint8_t* data) {
-    {
-        p.i2c_read(dev_addr, reg, data, size)
-        } -> std::same_as<i2c::hardware::RxTxReturn>;
-    {
-        p.i2c_write(dev_addr, reg, data, size)
-        } -> std::same_as<i2c::hardware::RxTxReturn>;
+    { p.i2c_read(dev_addr, reg, data, size) } -> std::same_as<RxTxReturn>;
+    { p.i2c_write(dev_addr, reg, data, size) } -> std::same_as<RxTxReturn>;
 };
 
 constexpr uint8_t DEV_ADDRESS = 0x18 << 1;
 constexpr uint8_t MEASURE_PRESSURE_COMMAND = 0xAA;
 constexpr uint8_t STATUS_BUSY_FLAG = 0x20;
+// max sensor output in counts
 constexpr uint32_t OUTPUT_MAX = 15099494;
+// min sensor output in counts
 constexpr uint32_t OUTPUT_MIN = 1677722;
 constexpr uint32_t OUTPUT_RANGE_COUNTS = OUTPUT_MAX - OUTPUT_MIN;
 // range for this particular model is 0-25 PSI
 constexpr uint16_t PRESSURE_RANGE_PSI = 25;
-
+// 1 PSI = 68.9476 mbar
+constexpr uint32_t MBAR_CONVERSION_FACTOR = 68.9476;
 constexpr uint8_t PRESSURE_FRAME_LEN = 10;
-std::array<uint8_t, PRESSURE_FRAME_LEN> READ_BUFF = {0};
-std::array<uint8_t, PRESSURE_FRAME_LEN> WRITE = {MEASURE_PRESSURE_COMMAND};
-constexpr int retries = 3;
+constexpr int DEFAULT_RETRIES = 3;
 
 struct StatusByte {
     uint8_t power_indication;
@@ -42,20 +41,21 @@ struct StatusByte {
 
 class MPRLL0025PA00001 {
   public:
-    auto initialize(hardware::VacuumPressureSensorPolicy* policy) -> void {
+    auto initialize(VacuumPressureSensorPolicy* policy) -> void {
         if (_policy == nullptr) {
             _policy = policy;
         }
     }
 
-    auto read_pressure() -> uint16_t {
-        bool sensor_busy = true;
-
+    // TODO: separate sending the write pressure command,
+    // and read the pressure from a callback for an eoc pin irq
+    auto read_pressure() -> std::optional<double> {
         _policy->i2c_master_write(DEVICE_ADDRESS, MEASURE_PRESSURE_COMMAND,
                                   WRITE_BUFF, 1);
 
-        for (int i = 0; i < (retries + 1); i++) {
+        for (int i = 0; i < (DEFAULT_RETRIES + 1); i++) {
             _policy->i2c_master_read(DEV_ADDRESS, READ_BUFF, 4);
+            _policy->sleep_ms(3);
             auto status_byte = READ_BUFF[0];
             sensor_busy = static_cast<bool>(status_byte & STATUS_BUSY_FLAG);
 
@@ -64,18 +64,29 @@ class MPRLL0025PA00001 {
             }
         }
 
-        auto pressure_psi = convert_pressure(READ_BUFF);
+        pressure_psi = convert_pressure(READ_BUFF);
+        pressure_mbar = pressure_psi * MBAR_CONVERSION_FACTOR;
         return pressure_psi;
     }
 
-  private:
-    hardware::VacuumPressureSensorPolicy* _policy{nullptr};
+    std::array<uint8_t, PRESSURE_FRAME_LEN> READ_BUFF = {0};
+    std::array<uint8_t, PRESSURE_FRAME_LEN> WRITE = {MEASURE_PRESSURE_COMMAND};
+    double pressure_psi;
+    double pressure_mbar;
+    bool sensor_busy = true;
 
-    auto convert_pressure(uint8_t* sensor_output) -> uint16_t {
-        auto pressure_read_counts =
-            sensor_output[1] << 16 | sensor_output[2] << 8 | sensor_output[3];
-        auto pressure_psi =
-            (pressure_read_counts * PRESSURE_RANGE_PSI) / OUTPUT_RANGE_COUNTS;
+  private:
+    VacuumPressureSensorPolicy* _policy{nullptr};
+
+    auto convert_pressure(uint8_t* sensor_output) -> double {
+        // auto pressure_read_counts =
+        //     sensor_output[1] << 16 | sensor_output[2] << 8 |
+        //     sensor_output[3];
+        uint32_t pressure_read_counts = sensor_output[1] << 24 |
+                                        sensor_output[2] << 16 |
+                                        sensor_output[3] << 8;
+        double pressure_psi = static_cast<double>(
+            (pressure_read_counts * PRESSURE_RANGE_PSI) / OUTPUT_RANGE_COUNTS);
         return pressure_psi;
     }
 };
diff --git a/stm32-modules/include/vacuum-module/vacuum-module/lps22df.hpp b/stm32-modules/include/vacuum-module/vacuum-module/lps22df.hpp
@@ -7,6 +7,8 @@
 #include "firmware/atmosphere_pressure_sensor_policy.hpp"
 
 namespace lps22df {
+using atmosphere_pressure_sensor::hardware::AtmospherePressureSensorPolicy;
+using i2c::hardware::RxTxReturn;
 
 template <typename P>
 concept LPS22DFPolicy = requires(P p, uint16_t dev_addr, uint16_t reg,
@@ -21,7 +23,7 @@ constexpr uint8_t DEVICE_ADDRESS = 0x5C << 1;
 constexpr uint8_t CTRL_REG2 = 0x11;
 // pressure reading is 4 bytes, starting with status at 0x27
 constexpr uint8_t PRESSURE_OUTPUT_REGISTER = 0x27;
-// write bit 1 to CTRL REG 2 to read pressure once
+// write bit 0 to CTRL REG 2 to read pressure once
 constexpr uint8_t ONE_SHOT_PRESSURE_READ[1] = {0x01};
 // pressure in hectoPascals is the 3 byte output value divided by the
 // sensitivity
@@ -30,28 +32,25 @@ constexpr uint16_t SENSOR_SENSITIVITY = 4096;
 constexpr uint8_t PRESSURE_READY_FLAG = 0x01;
 
 constexpr uint8_t PRESSURE_FRAME_LEN = 10;
-std::array<uint8_t, PRESSURE_FRAME_LEN> READ_BUFF = {0};
-std::array<uint8_t, PRESSURE_FRAME_LEN> WRITE_BUFF = {0};
-constexpr int retries = 3;
+constexpr int DEFAULT_RETRIES = 3;
 
 class LPS222DF {
   public:
-    auto initialize(
-        atmosphere_pressure_sensor::hardware::AtmospherePressureSensorPolicy*
-            policy) -> void {
+    auto initialize(AtmospherePressureSensorPolicy* policy) -> void {
         if (_policy == nullptr) {
             _policy = policy;
         }
     }
 
-    auto read_pressure() -> uint16_t {
-        bool pressure_reading_ready = false;
-
+    // TODO: separate sending the write pressure command from the read so
+    // the task doesn't need to wait for the conversion
+    auto read_pressure() -> std::optional<double> {
         _policy->i2c_write(DEVICE_ADDRESS, CTRL_REG2, ONE_SHOT_PRESSURE_READ,
                            1);
-        for (int i = 0; i < (retries + 1); i++) {
+        for (int i = 0; i < (DEFAULT_RETRIES + 1); i++) {
             _policy->i2c_read(DEVICE_ADDRESS, PRESSURE_OUTPUT_REGISTER,
                               READ_BUFF, 4);
+            _policy->sleep_ms(3);
             auto status_byte = READ_BUFF[0];
             pressure_reading_ready =
                 static_cast<bool>(status_byte & PRESSURE_READY_FLAG);
@@ -60,25 +59,30 @@ class LPS222DF {
                 break;
             }
         }
-        if (!pressure_reading_ready) {
-            // raise an error here
-        }
 
         auto pressure_hPa = convert_pressure(READ_BUFF);
-        return pressure_hPa
+        pressure_mbar = pressure_hPa;
+        return pressure_hPa;
     }
 
+    std::array<uint8_t, PRESSURE_FRAME_LEN> READ_BUFF = {0};
+    std::array<uint8_t, PRESSURE_FRAME_LEN> WRITE_BUFF = {0};
+    // 1 hectoPascal = mbar
+    double pressure_mbar;
+    bool pressure_reading_ready = false;
+
   private:
-    atmosphere_pressure_sensor::hardware::AtmospherePressureSensorPolicy*
-        _policy{nullptr};
+    AtmospherePressureSensorPolicy* _policy{nullptr};
 
-    auto convert_pressure(uint8_t* sensor_output) -> uint16_t {
+    auto convert_pressure(uint8_t* sensor_output) -> double {
         auto pressure_read_bytes = {sensor_output[1], sensor_output[2],
                                     sensor_output[3]};
         // test that this is accurate
-        auto pressure_read_counts =
-            sensor_output[1] << 16 | sensor_output[2] << 8 | sensor_output[3];
-        auto pressure_hPa = pressure_read_counts / SENSOR_SENSITIVITY;
+        auto pressure_read_counts = sensor_output[1] << 24 |
+                                    sensor_output[2] << 16 |
+                                    sensor_output[3] << 8;
+        double pressure_hPa =
+            static_cast<double>(pressure_read_counts / SENSOR_SENSITIVITY);
         return pressure_hPa
     }
 };
diff --git a/stm32-modules/vacuum-module/firmware/main.cpp b/stm32-modules/vacuum-module/firmware/main.cpp
@@ -46,6 +46,8 @@ static auto system_task =
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 static auto aggregator = tasks::FirmwareTasks::QueueAggregator();
 
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+static auto i2c1_comms = i2c::hardware::I2C();
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 static auto i2c2_comms = i2c::hardware::I2C();
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
@@ -61,6 +63,7 @@ auto main() -> int {
     i2c_hardware_init(&i2c_handles);
     vacuum_pressure_sensor_hardware_init();
 
+    i2c1_comms.set_handle(i2c_handles.i2c1, I2C_BUS_1);
     i2c2_comms.set_handle(i2c_handles.i2c2, I2C_BUS_2);
     i2c3_comms.set_handle(i2c_handles.i2c3, I2C_BUS_3);
 
diff --git a/stm32-modules/vacuum-module/firmware/system/i2c_comms.cpp b/stm32-modules/vacuum-module/firmware/system/i2c_comms.cpp
@@ -27,12 +27,12 @@ auto I2C::i2c_read(uint16_t dev_addr, uint16_t reg, uint8_t *data,
 
 auto I2C::i2c_master_write(uint16_t dev_addr, uint8_t *data, uint16_t size)
     -> RxTxReturn {
-    auto ret = hal_i2c_master_write(this->bus, dev_addr, data, size);
+    auto ret = hal_i2c_master_write(bus, dev_addr, data, size);
     return RxTxReturn(ret);
 }
 
 auto I2C::i2c_master_read(uint16_t dev_addr, uint8_t *data, uint16_t size)
     -> RxTxReturn {
-    auto ret = hal_i2c_master_read(this->bus, dev_addr, data, size);
+    auto ret = hal_i2c_master_read(bus, dev_addr, data, size);
     return RxTxReturn(ret);
 }
diff --git a/stm32-modules/vacuum-module/firmware/vacuum-pressure-sensor/vacuum_pressure_sensor_policy.cpp b/stm32-modules/vacuum-module/firmware/vacuum-pressure-sensor/vacuum_pressure_sensor_policy.cpp
@@ -26,15 +26,13 @@ auto VacuumPressureSensorPolicy::i2c_read(uint16_t dev_addr, uint16_t reg,
 auto VacuumPressureSensorPolicy::i2c_master_write(uint16_t dev_addr,
                                                   uint8_t* data, uint16_t size)
     -> RxTxReturn {
-    auto ret = i2c_comms->i2c_master_write(dev_addr, data, size);
-    return ret;
+    return i2c_comms->i2c_master_write(dev_addr, data, size);
 }
 
 auto VacuumPressureSensorPolicy::i2c_master_read(uint16_t dev_addr,
                                                  uint8_t* data, uint16_t size)
     -> RxTxReturn {
-    auto ret = i2c_comms->i2c_master_write(dev_addr, data, size);
-    return ret;
+    return i2c_comms->i2c_master_write(dev_addr, data, size);
 }
 
 auto VacuumPressureSensorPolicy::conversion_ended(

Original file line number	Diff line number	Diff line change
`@@ -27,12 +27,12 @@ auto I2C::i2c_read(uint16_t dev_addr, uint16_t reg, uint8_t *data,`
`27`	`27`
`28`	`28`	`auto I2C::i2c_master_write(uint16_t dev_addr, uint8_t *data, uint16_t size)`
`29`	`29`	`-> RxTxReturn {`
`30`		`- auto ret = hal_i2c_master_write(this->bus, dev_addr, data, size);`
	`30`	`+ auto ret = hal_i2c_master_write(bus, dev_addr, data, size);`
`31`	`31`	`return RxTxReturn(ret);`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`auto I2C::i2c_master_read(uint16_t dev_addr, uint8_t *data, uint16_t size)`
`35`	`35`	`-> RxTxReturn {`
`36`		`- auto ret = hal_i2c_master_read(this->bus, dev_addr, data, size);`
	`36`	`+ auto ret = hal_i2c_master_read(bus, dev_addr, data, size);`
`37`	`37`	`return RxTxReturn(ret);`
`38`	`38`	`}`