Merge pull request #22 from OpenwaterHealth/integration/pdc-deploy-odometer

Integrate per-frame PDC buffer, odometers, and DFU deploy tooling

Author: boringethan

CMakeLists.txt

@@ -118,6 +118,9 @@ target_sources(${CMAKE_PROJECT_NAME} PRIVATE
     Core/Src/motion_config.c
     Core/Src/fpga_register_map.c
     Core/Src/utils.c
+    Core/Src/pdc_buffer.c
+    Core/Src/pdc_poll.c
+    Core/Src/odometer.c
 )
 
 # Add include paths
@@ -147,3 +150,22 @@ add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD
     COMMAND ${CMAKE_OBJCOPY} -O binary $<TARGET_FILE:${CMAKE_PROJECT_NAME}> ${CMAKE_PROJECT_NAME}.bin
     COMMENT "Generating .hex and .bin files"
 )
+
+# Build + DFU-flash target. Invokes scripts/deploy.py which:
+#   1. enters DFU via the omotion SDK
+#   2. waits for the STM32 ROM bootloader to enumerate
+#   3. flashes the .bin via dfu-util with :leave for auto-reset
+# Requires: dfu-util on PATH, omotion installed in the active Python env.
+find_program(PYTHON_FOR_DEPLOY NAMES python3 python)
+if(PYTHON_FOR_DEPLOY)
+    add_custom_target(flash
+        COMMAND ${PYTHON_FOR_DEPLOY} ${CMAKE_SOURCE_DIR}/scripts/deploy.py
+                --config $<CONFIG> --no-build
+        DEPENDS ${CMAKE_PROJECT_NAME}
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        USES_TERMINAL
+        COMMENT "Flashing ${CMAKE_PROJECT_NAME} via DFU"
+    )
+else()
+    message(WARNING "Python not found — `flash` target will not be available")
+endif()

CommandHandling.md

@@ -140,6 +140,7 @@ Examples include:
 | `OW_CTRL_TEC_STATUS` | Read TEC controller status and faults   |
 | `OW_CTRL_BOARDID`    | Read board identification information   |
 | `OW_CTRL_PDUMON`     | Read power distribution monitoring data |
+| `OW_CTRL_GET_PDC_BUFFER` | Drain up to N per-frame PDC samples from the SRAM ring buffer. Request payload: 1 byte = max_samples (1..64). Response: 2-byte LE drop counter + 1-byte sample count + N × 7-byte packed `{u32 frame_idx, u16 pdc_raw, u8 flags}`. `flags` bit 0 = `dark_slot`. |
 
 Each command defines its own payload format and response payload.
 

Core/Inc/common.h

@@ -110,6 +110,10 @@ typedef enum {
 	OW_CTRL_TEC_STATUS = 0x22,
 	OW_CTRL_BOARDID = 0x23,
 	OW_CTRL_PDUMON = 0x24,
+	OW_CTRL_GET_PDC_BUFFER = 0x25,
+	OW_CTRL_GET_SYSTEM_ODO = 0x26,
+	OW_CTRL_GET_LASER_ODO = 0x27,
+	OW_CTRL_RESET_ODO = 0x28,
 } MotionControllerCommands;
 
 typedef enum {

Core/Inc/memory_map.h

@@ -35,8 +35,14 @@
 #define ADDR_FLASH_SECTOR_6_BANK2     ((uint32_t)0x081C0000) /* Base @ of Sector 6, 128 Kbytes */
 #define ADDR_FLASH_SECTOR_7_BANK2     ((uint32_t)0x081E0000) /* Base @ of Sector 7, 128 Kbytes */
 
-#define ADDR_FLASH_END_ADDRESS     ((uint32_t)0x08200000) 
-#define FLASH_USER_START_ADDR ADDR_FLASH_SECTOR_7_BANK2
+#define ADDR_FLASH_END_ADDRESS     ((uint32_t)0x08200000)
+
+/* Reserved persistent-data sectors. Each persists via full-sector erase
+ * (the STM32H7 flash sector is 128 KB and that is the minimum erase
+ * granularity), so two distinct tenants need two distinct sectors. The
+ * linker script reserves both by capping FLASH at 1792 KB. */
+#define FLASH_USER_START_ADDR     ADDR_FLASH_SECTOR_7_BANK2  /* motion_config / calibration */
+#define FLASH_ODOMETER_START_ADDR ADDR_FLASH_SECTOR_6_BANK2  /* system + laser odometer */
 
 #ifdef __cplusplus
 }

Core/Inc/odometer.h

@@ -0,0 +1,80 @@
+/*
+ * odometer.h
+ *
+ *  Created on: Apr 29, 2026
+ *      Author: Claude
+ */
+
+#ifndef INC_ODOMETER_H_
+#define INC_ODOMETER_H_
+
+#include "stm32h7xx_hal.h"
+#include "memory_map.h"
+#include <stdint.h>
+#include <stdbool.h>
+
+/* Flash memory addresses for odometer storage.
+ *
+ * Lives in its own 128 KB sector (sector 6 bank 2 via FLASH_ODOMETER_START_ADDR),
+ * distinct from FLASH_USER_START_ADDR which is owned by motion_config. The
+ * STM32H7 minimum erase granularity is one 128 KB sector, so the two stores
+ * must not co-tenant — otherwise either Odometer_Persist_Both() or
+ * motion_cfg flash writes would wipe the other tenant. */
+#define ODOMETER_FLASH_BASE_ADDR    (FLASH_ODOMETER_START_ADDR)
+#define SYSTEM_ODO_FLASH_ADDR       (ODOMETER_FLASH_BASE_ADDR)
+#define LASER_ODO_FLASH_ADDR        (ODOMETER_FLASH_BASE_ADDR + 32)
+
+/* Magic number identifying a valid odometer flash block. Reading anything other
+ * than this magic + matching CRC at boot means the block is invalid (uninitialised
+ * flash, stale data from a previous firmware that used this sector for something
+ * else, partial-erase corruption) — the init path treats that as "first boot"
+ * and writes a fresh zero block. */
+#define ODOMETER_MAGIC 0x4F444F31u  /* "ODO1" */
+
+/* On-flash format. 16 bytes per odometer; written as a 32-byte zero-padded block. */
+typedef struct __attribute__((packed)) {
+    uint32_t magic;       /* ODOMETER_MAGIC */
+    uint32_t value;       /* total_minutes for system, total_pulses for laser */
+    uint32_t reserved;    /* 0 for now, future fields */
+    uint32_t crc32;       /* CRC32 of magic + value + reserved */
+} OdoFlashBlock_t;
+
+/* Update interval: how often we erase+rewrite the flash sector during normal
+ * runtime to persist the system odometer. STM32H7 flash sector endurance is
+ * ~10K cycles, so we keep this conservative — 6 hours = ~4 writes/day, giving
+ * roughly 7 years of continuous-run wear life per device. The laser odometer
+ * is only persisted on scan-finish (a natural rate-limiter), so it doesn't
+ * need its own interval. */
+#define SYSTEM_ODO_UPDATE_INTERVAL_MS  (6UL * 60UL * 60UL * 1000UL)  /* 6 hours */
+
+/* Reset targets for Odometer_Reset() / OW_CTRL_RESET_ODO. */
+typedef enum {
+    ODO_RESET_SYSTEM = 0,
+    ODO_RESET_LASER  = 1,
+    ODO_RESET_BOTH   = 2,
+} OdoResetTarget;
+
+/* In-memory state — kept opaque, accessed via Odometer_Get_*() */
+typedef struct {
+    uint32_t total_minutes;      /* Total accumulated minutes */
+    uint32_t last_update_tick;   /* Last HAL_GetTick() value when saved */
+} SystemOdometer_t;
+
+typedef struct {
+    uint32_t total_pulses;       /* Total laser sync pulses */
+    uint32_t scan_start_pulses;  /* Pulse count at scan start */
+} LaserOdometer_t;
+
+/* Function prototypes */
+HAL_StatusTypeDef Odometer_Init(void);
+HAL_StatusTypeDef Odometer_Update_System(void);
+HAL_StatusTypeDef Odometer_Scan_Start(void);
+HAL_StatusTypeDef Odometer_Scan_Finish(void);
+uint32_t Odometer_Get_System_Minutes(void);
+uint32_t Odometer_Get_Laser_Pulses(void);
+
+/* Reset one or both odometers to zero and persist the cleared state to flash.
+ * target ∈ ODO_RESET_SYSTEM / _LASER / _BOTH. Returns HAL_OK on success. */
+HAL_StatusTypeDef Odometer_Reset(OdoResetTarget target);
+
+#endif /* INC_ODOMETER_H_ */

Core/Inc/pdc_buffer.h

@@ -0,0 +1,29 @@
+/* Core/Inc/pdc_buffer.h */
+#ifndef INC_PDC_BUFFER_H_
+#define INC_PDC_BUFFER_H_
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+#define PDC_BUFFER_CAPACITY 256
+
+typedef struct __attribute__((packed)) {
+    uint32_t frame_idx;
+    uint16_t pdc_raw;
+    uint8_t  flags;   /* bit 0 = dark_slot */
+} pdc_sample_t;
+
+#define PDC_FLAG_DARK_SLOT (1u << 0)
+
+void     pdc_buffer_reset(void);
+bool     pdc_buffer_push(const pdc_sample_t *sample);  /* drop-oldest on overflow, returns true if a drop occurred */
+size_t   pdc_buffer_drain(pdc_sample_t *out, size_t max_samples);
+uint16_t pdc_buffer_dropped_since_last_drain(void);
+size_t   pdc_buffer_count(void);
+
+/* Add external drops (e.g. producer-side ISR overflow) to the pending counter
+ * so they surface through the same drained-drop-count channel. */
+void     pdc_buffer_account_drops(uint16_t n);
+
+#endif

Core/Inc/pdc_poll.h

@@ -0,0 +1,13 @@
+/* Core/Inc/pdc_poll.h */
+#ifndef INC_PDC_POLL_H_
+#define INC_PDC_POLL_H_
+
+#include <stdint.h>
+
+void pdc_poll_init(void);
+/* Call from the main loop. Performs the I2C read of the safety FPGA peak-power
+ * register and pushes a pdc_sample_t to the buffer when one is pending and the
+ * post-pulse settling time has elapsed. Non-blocking otherwise. */
+void pdc_poll_tick(void);
+
+#endif

Core/Inc/trigger.h

@@ -45,6 +45,10 @@ void FSYNC_DelayElapsedCallback(TIM_HandleTypeDef *htim);
 void LSYNC_DelayElapsedCallback(TIM_HandleTypeDef *htim);
 
 void FSYNC_PeriodElapsedCallback(TIM_HandleTypeDef *htim);
+void LSYNC_PeriodElapsedCallback(TIM_HandleTypeDef *htim);
+bool get_current_slot_is_dark(void);
+bool consume_pdc_sample_pending(bool *out_dark_slot, uint32_t *out_frame_idx);
+uint16_t consume_pdc_pending_overwrites(void);
 
 extern Trigger_Config_t trigger_config;
 

Core/Src/if_commands.c

@@ -20,6 +20,8 @@
 #include "led_driver.h"
 #include "motion_config.h"
 #include "msg_queue.h"
+#include "pdc_buffer.h"
+#include "odometer.h"
 
 #include <string.h>
 
@@ -114,6 +116,8 @@ static uint8_t i2c_list[10] = {0};
 static uint8_t i2c_data[0xff] = {0};
 static uint32_t last_fsync_count = 0;
 static uint32_t last_lsync_count = 0;
+static uint32_t last_system_odo = 0;
+static uint32_t last_laser_odo = 0;
 
 static float tecadc_last_volts[4];
 static uint16_t tecadc_last_raw[4];
@@ -497,6 +501,68 @@ static _Bool process_controller_command(UartPacket *uartResp, UartPacket *cmd)
         uartResp->data_len = (uint16_t)sizeof(pdu_frame);
         uartResp->data = pdu_frame.bytes;
         break;
+    case OW_CTRL_GET_PDC_BUFFER: {
+        uartResp->command = OW_CTRL_GET_PDC_BUFFER;
+        uartResp->addr = cmd->addr;
+        uartResp->reserved = cmd->reserved;
+
+        /* Request payload: 1 byte = max_samples (clamped to 64). */
+        uint8_t requested = (cmd->data_len >= 1) ? cmd->data[0] : 64;
+        if (requested == 0 || requested > 64) requested = 64;
+
+        /* Response layout: [dropped:u16 LE][count:u8][count * sizeof(pdc_sample_t)] */
+        static pdc_sample_t drained[64];
+        size_t n = pdc_buffer_drain(drained, requested);
+        uint16_t dropped = pdc_buffer_dropped_since_last_drain();
+
+        static uint8_t resp[3 + 64 * sizeof(pdc_sample_t)];
+        resp[0] = (uint8_t)(dropped & 0xFF);
+        resp[1] = (uint8_t)((dropped >> 8) & 0xFF);
+        resp[2] = (uint8_t)n;
+        memcpy(&resp[3], drained, n * sizeof(pdc_sample_t));
+
+        uartResp->data_len = (uint16_t)(3 + n * sizeof(pdc_sample_t));
+        uartResp->data = resp;
+    } break;
+    case OW_CTRL_GET_SYSTEM_ODO:
+        uartResp->command = OW_CTRL_GET_SYSTEM_ODO;
+        uartResp->addr = cmd->addr;
+        uartResp->reserved = cmd->reserved;
+        uartResp->data_len = 4;
+        last_system_odo = Odometer_Get_System_Minutes();
+        uartResp->data = (uint8_t *)&last_system_odo;
+        break;
+    case OW_CTRL_GET_LASER_ODO:
+        uartResp->command = OW_CTRL_GET_LASER_ODO;
+        uartResp->addr = cmd->addr;
+        uartResp->reserved = cmd->reserved;
+        uartResp->data_len = 4;
+        last_laser_odo = Odometer_Get_Laser_Pulses();
+        uartResp->data = (uint8_t *)&last_laser_odo;
+        break;
+    case OW_CTRL_RESET_ODO: {
+        uartResp->command = OW_CTRL_RESET_ODO;
+        uartResp->addr = cmd->addr;
+        uartResp->reserved = cmd->reserved;
+        /* Request payload: 1 byte = target (0=system, 1=laser, 2=both).
+         * No payload defaults to "both" for caller convenience. */
+        OdoResetTarget target = ODO_RESET_BOTH;
+        if (cmd->data_len >= 1) {
+            if (cmd->data[0] > (uint8_t)ODO_RESET_BOTH) {
+                uartResp->data_len = 0;
+                uartResp->packet_type = OW_ERROR;
+                break;
+            }
+            target = (OdoResetTarget)cmd->data[0];
+        }
+        static uint8_t reset_resp;
+        reset_resp = (Odometer_Reset(target) == HAL_OK) ? 0 : 1;
+        uartResp->data_len = 1;
+        uartResp->data = &reset_resp;
+        if (reset_resp != 0) {
+            uartResp->packet_type = OW_ERROR;
+        }
+    } break;
     default:
         uartResp->data_len = 0;
         uartResp->packet_type = OW_UNKNOWN;

Core/Src/main.c

@@ -28,6 +28,7 @@
 #include "usbd_cdc_if.h"
 #include "uart_comms.h"
 #include "trigger.h"
+#include "pdc_poll.h"
 #include "led_driver.h"
 #include "tca9548a.h"
 #include "pca9535.h"
@@ -44,6 +45,7 @@
 #include "jsmn.h"
 #include "utils.h"
 #include "msg_queue.h"
+#include "odometer.h"
 
 #include <stdio.h>
 #include <string.h>
@@ -562,13 +564,20 @@ int main(void)
   motion_cfg_get();
   motion_cfg_apply_settings();
 
+  // Initialize odometers
+  printf("Initialize odometers\r\n");
+  if(Odometer_Init() != HAL_OK){
+      printf("Failed to initialize odometers\r\n");
+  }
+
   HAL_Delay(100);
 
   // Enable USB HUB
   HAL_GPIO_WritePin(HUB_RESET_GPIO_Port, HUB_RESET_Pin, GPIO_PIN_SET);
   HAL_Delay(100);
 
   comms_init();
+  pdc_poll_init();
   /* Start TIM4 interrupt for telemetry polling (250 ms) */
   HAL_TIM_Base_Start_IT(&htim4);
 
@@ -584,6 +593,8 @@ int main(void)
     comms_process();
     telemetry_poll();
     usb_recovery_task();
+    pdc_poll_tick();
+    Odometer_Update_System();
     HAL_Delay(1);
   }
   /* USER CODE END 3 */
@@ -1742,6 +1753,9 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   if (htim->Instance == FSYNC_TIMER.Instance) {
     FSYNC_PeriodElapsedCallback(htim);
   }
+  if (htim->Instance == LASER_TIMER.Instance) {
+    LSYNC_PeriodElapsedCallback(htim);
+  }
 
   if (htim->Instance == TIM12) {
 	  CDC_Idle_Timer_Handler();