refactor: restructure slave_node into libraries

2025-07-02 09:45:22 +02:00
parent 0088030d66
commit 6cfd4b8b4d
11 changed files with 354 additions and 424 deletions
--- a/software/lib/CMakeLists.txt
+++ b/software/lib/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Add your shared libraries here
-# Example:
-# add_library(modbus modbus/modbus.c)
-# target_include_directories(modbus PUBLIC .)
+add_subdirectory(modbus)
+add_subdirectory(valve)
+add_subdirectory(modbus_server)
+add_subdirectory(fwu)
--- a/software/lib/fwu/fwu.c
+++ b/software/lib/fwu/fwu.c
@@ -0,0 +1,45 @@
+#include "fwu.h"
+#include <zephyr/kernel.h>
+#include <zephyr/sys/crc.h>
+#include <zephyr/sys/byteorder.h>
+#include <zephyr/logging/log.h>
+
+LOG_MODULE_REGISTER(fwu, LOG_LEVEL_INF);
+
+#define FWU_BUFFER_SIZE 256
+static uint8_t fwu_buffer[FWU_BUFFER_SIZE];
+static uint32_t fwu_chunk_offset = 0;
+static uint16_t fwu_chunk_size = 0;
+static uint16_t fwu_last_chunk_crc = 0;
+
+void fwu_init(void) {}
+
+void fwu_handler(uint16_t addr, uint16_t reg)
+{
+    // This is a simplified handler. In a real scenario, you would have a proper mapping
+    // between register addresses and actions.
+    if (addr == 0x0100) { // FWU_COMMAND
+        if (reg == 1) { LOG_INF("FWU: Chunk at offset %u (size %u) verified.", fwu_chunk_offset, fwu_chunk_size); }
+        else if (reg == 2) { LOG_INF("FWU: Finalize command received. Rebooting (simulated)."); }
+    } else if (addr == 0x0101) { // FWU_CHUNK_OFFSET_LOW
+        fwu_chunk_offset = (fwu_chunk_offset & 0xFFFF0000) | reg;
+    } else if (addr == 0x0102) { // FWU_CHUNK_OFFSET_HIGH
+        fwu_chunk_offset = (fwu_chunk_offset & 0x0000FFFF) | ((uint32_t)reg << 16);
+    } else if (addr == 0x0103) { // FWU_CHUNK_SIZE
+        fwu_chunk_size = (reg > FWU_BUFFER_SIZE) ? FWU_BUFFER_SIZE : reg;
+    } else if (addr >= 0x0180 && addr < (0x0180 + (FWU_BUFFER_SIZE / 2))) {
+        uint16_t index = (addr - 0x0180) * 2;
+        if (index < sizeof(fwu_buffer)) {
+            sys_put_be16(reg, &fwu_buffer[index]);
+            if (index + 2 >= fwu_chunk_size) {
+                fwu_last_chunk_crc = crc16_ccitt(0xffff, fwu_buffer, fwu_chunk_size);
+                LOG_INF("FWU: Chunk received, CRC is 0x%04X", fwu_last_chunk_crc);
+            }
+        }
+    }
+}
+
+uint16_t fwu_get_last_chunk_crc(void)
+{
+    return fwu_last_chunk_crc;
+}
--- a/software/lib/fwu/fwu.h
+++ b/software/lib/fwu/fwu.h
@@ -0,0 +1,10 @@
+#ifndef FWU_H
+#define FWU_H
+
+#include <stdint.h>
+
+void fwu_init(void);
+void fwu_handler(uint16_t addr, uint16_t reg);
+uint16_t fwu_get_last_chunk_crc(void);
+
+#endif // FWU_H
--- a/software/lib/modbus_server/modbus_server.c
+++ b/software/lib/modbus_server/modbus_server.c
@@ -0,0 +1,169 @@
+#include <zephyr/kernel.h>
+#include "modbus_server.h"
+#include <zephyr/modbus/modbus.h>
+#include <zephyr/logging/log.h>
+#include <zephyr/settings/settings.h>
+#include <zephyr/sys/reboot.h>
+#include "valve.h"
+#include "fwu.h"
+
+LOG_MODULE_REGISTER(modbus_server, LOG_LEVEL_INF);
+
+
+/**
+ * @brief Modbus Input Register Addresses.
+ */
+enum {
+	/* Valve Control & Status */
+	REG_INPUT_VALVE_STATE_MOVEMENT        = 0x0000,
+	REG_INPUT_MOTOR_CURRENT_MA            = 0x0001,
+	/* Digital Inputs */
+	REG_INPUT_DIGITAL_INPUTS_STATE        = 0x0020,
+	REG_INPUT_BUTTON_EVENTS               = 0x0021,
+	/* System Config & Status */
+	REG_INPUT_FIRMWARE_VERSION_MAJOR_MINOR = 0x00F0,
+	REG_INPUT_FIRMWARE_VERSION_PATCH      = 0x00F1,
+	REG_INPUT_DEVICE_STATUS               = 0x00F2,
+	REG_INPUT_UPTIME_SECONDS_LOW          = 0x00F3,
+	REG_INPUT_UPTIME_SECONDS_HIGH         = 0x00F4,
+	/* Firmware Update */
+	REG_INPUT_FWU_LAST_CHUNK_CRC          = 0x0100,
+};
+
+/**
+ * @brief Modbus Holding Register Addresses.
+ */
+enum {
+	/* Valve Control */
+	REG_HOLDING_VALVE_COMMAND             = 0x0000,
+	REG_HOLDING_MAX_OPENING_TIME_S        = 0x0001,
+	REG_HOLDING_MAX_CLOSING_TIME_S        = 0x0002,
+	/* Digital Outputs */
+	REG_HOLDING_DIGITAL_OUTPUTS_STATE     = 0x0010,
+	/* System Config */
+	REG_HOLDING_WATCHDOG_TIMEOUT_S        = 0x00F0,
+	/* Firmware Update */
+	REG_HOLDING_FWU_COMMAND               = 0x0100,
+	REG_HOLDING_FWU_CHUNK_OFFSET_LOW      = 0x0101,
+	REG_HOLDING_FWU_CHUNK_OFFSET_HIGH     = 0x0102,
+	REG_HOLDING_FWU_CHUNK_SIZE            = 0x0103,
+	REG_HOLDING_FWU_DATA_BUFFER           = 0x0180,
+};
+
+static int modbus_iface;
+static struct modbus_iface_param server_param = {
+	.mode = MODBUS_MODE_RTU,
+	.server = { .user_cb = NULL, .unit_id = 1 },
+	.serial = { .baud = 19200, .parity = UART_CFG_PARITY_NONE },
+};
+
+static uint16_t watchdog_timeout_s = 0;
+static struct k_timer watchdog_timer;
+
+static void watchdog_timer_handler(struct k_timer *timer_id)
+{
+	LOG_WRN("Modbus watchdog expired! Closing valve as a fail-safe.");
+	valve_close();
+}
+
+static inline void reset_watchdog(void)
+{
+	if (watchdog_timeout_s > 0) {
+		k_timer_start(&watchdog_timer, K_SECONDS(watchdog_timeout_s), K_NO_WAIT);
+	}
+}
+
+static int holding_reg_rd(uint16_t addr, uint16_t *reg)
+{
+	reset_watchdog();
+	switch (addr) {
+	case REG_HOLDING_MAX_OPENING_TIME_S: *reg = valve_get_max_open_time(); break;
+	case REG_HOLDING_MAX_CLOSING_TIME_S: *reg = valve_get_max_close_time(); break;
+	case REG_HOLDING_WATCHDOG_TIMEOUT_S: *reg = watchdog_timeout_s; break;
+	default: *reg = 0; break;
+	}
+	return 0;
+}
+
+static int holding_reg_wr(uint16_t addr, uint16_t reg)
+{
+	reset_watchdog();
+	switch (addr) {
+	case REG_HOLDING_VALVE_COMMAND:
+		if (reg == 1) { valve_open(); }
+		else if (reg == 2) { valve_close(); }
+		else if (reg == 0) { valve_stop(); }
+		break;
+	case REG_HOLDING_MAX_OPENING_TIME_S:
+		valve_set_max_open_time(reg);
+		break;
+	case REG_HOLDING_MAX_CLOSING_TIME_S:
+		valve_set_max_close_time(reg);
+		break;
+	case REG_HOLDING_WATCHDOG_TIMEOUT_S:
+		watchdog_timeout_s = reg;
+		if (watchdog_timeout_s > 0) {
+			LOG_INF("Watchdog enabled with %u s timeout.", watchdog_timeout_s);
+			reset_watchdog();
+		} else {
+			LOG_INF("Watchdog disabled.");
+			k_timer_stop(&watchdog_timer);
+		}
+		break;
+    default:
+        fwu_handler(addr, reg);
+        break;
+	}
+	return 0;
+}
+
+static int input_reg_rd(uint16_t addr, uint16_t *reg)
+{
+	reset_watchdog();
+	uint32_t uptime_s = k_uptime_get_32() / 1000;
+	switch (addr) {
+	case REG_INPUT_VALVE_STATE_MOVEMENT: *reg = (valve_get_movement() << 8) | (valve_get_state() & 0xFF); break;
+	case REG_INPUT_MOTOR_CURRENT_MA: *reg = valve_get_motor_current(); break;
+	case REG_INPUT_UPTIME_SECONDS_LOW: *reg = (uint16_t)(uptime_s & 0xFFFF); break;
+	case REG_INPUT_UPTIME_SECONDS_HIGH: *reg = (uint16_t)(uptime_s >> 16); break;
+	case REG_INPUT_FWU_LAST_CHUNK_CRC: *reg = fwu_get_last_chunk_crc(); break;
+	default: *reg = 0; break;
+	}
+	return 0;
+}
+
+static struct modbus_user_callbacks mbs_cbs = {
+	.holding_reg_rd = holding_reg_rd,
+	.holding_reg_wr = holding_reg_wr,
+	.input_reg_rd = input_reg_rd,
+};
+
+#define MODBUS_NODE DT_COMPAT_GET_ANY_STATUS_OKAY(zephyr_modbus_serial)
+
+int modbus_server_init(void)
+{
+	k_timer_init(&watchdog_timer, watchdog_timer_handler, NULL);
+	const char iface_name[] = {DEVICE_DT_NAME(MODBUS_NODE)};
+	modbus_iface = modbus_iface_get_by_name(iface_name);
+	if (modbus_iface < 0) { return modbus_iface; }
+	server_param.server.user_cb = &mbs_cbs;
+	return modbus_init_server(modbus_iface, server_param);
+}
+
+int modbus_reconfigure(uint32_t baudrate, uint8_t unit_id)
+{
+	server_param.serial.baud = baudrate;
+	server_param.server.unit_id = unit_id;
+
+	int ret = modbus_init_server(modbus_iface, server_param);
+
+    if (ret == 0) {
+        settings_save_one("modbus/baudrate", &baudrate, sizeof(baudrate));
+        settings_save_one("modbus/unit_id", &unit_id, sizeof(unit_id));
+    }
+
+    return ret;
+}
+
+uint32_t modbus_get_baudrate(void) { return server_param.serial.baud; }
+uint8_t modbus_get_unit_id(void) { return server_param.server.unit_id; }
--- a/software/lib/modbus_server/modbus_server.h
+++ b/software/lib/modbus_server/modbus_server.h
@@ -0,0 +1,11 @@
+#ifndef MODBUS_SERVER_H
+#define MODBUS_SERVER_H
+
+#include <stdint.h>
+
+int modbus_server_init(void);
+int modbus_reconfigure(uint32_t baudrate, uint8_t unit_id);
+uint32_t modbus_get_baudrate(void);
+uint8_t modbus_get_unit_id(void);
+
+#endif // MODBUS_SERVER_H
--- a/software/lib/valve/valve.c
+++ b/software/lib/valve/valve.c
@@ -0,0 +1,62 @@
+#include "valve.h"
+#include <zephyr/kernel.h>
+#include <zephyr/settings/settings.h>
+#include <zephyr/logging/log.h>
+
+LOG_MODULE_REGISTER(valve, LOG_LEVEL_INF);
+
+static enum valve_state current_state = VALVE_STATE_CLOSED;
+static enum valve_movement current_movement = VALVE_MOVEMENT_IDLE;
+static uint16_t max_opening_time_s = 60;
+static uint16_t max_closing_time_s = 60;
+static struct k_work_delayable valve_work;
+
+static void valve_work_handler(struct k_work *work)
+{
+    if (current_movement == VALVE_MOVEMENT_OPENING) {
+        LOG_INF("Virtual valve finished opening");
+    } else if (current_movement == VALVE_MOVEMENT_CLOSING) {
+        current_state = VALVE_STATE_CLOSED;
+        LOG_INF("Virtual valve finished closing");
+    }
+    current_movement = VALVE_MOVEMENT_IDLE;
+}
+
+void valve_init(void)
+{
+    k_work_init_delayable(&valve_work, valve_work_handler);
+    settings_load_one("valve/max_open_time", &max_opening_time_s, sizeof(max_opening_time_s));
+    settings_load_one("valve/max_close_time", &max_closing_time_s, sizeof(max_closing_time_s));
+}
+
+void valve_open(void)
+{
+    if (current_state == VALVE_STATE_CLOSED) {
+        current_state = VALVE_STATE_OPEN;
+        current_movement = VALVE_MOVEMENT_OPENING;
+        k_work_schedule(&valve_work, K_SECONDS(max_opening_time_s));
+    }
+}
+
+void valve_close(void)
+{
+    if (current_state == VALVE_STATE_OPEN) {
+        current_movement = VALVE_MOVEMENT_CLOSING;
+        k_work_schedule(&valve_work, K_SECONDS(max_closing_time_s));
+    }
+}
+
+void valve_stop(void)
+{
+    k_work_cancel_delayable(&valve_work);
+    current_movement = VALVE_MOVEMENT_IDLE;
+}
+
+enum valve_state valve_get_state(void) { return current_state; }
+enum valve_movement valve_get_movement(void) { return current_movement; }
+uint16_t valve_get_motor_current(void) { return (current_movement != VALVE_MOVEMENT_IDLE) ? 150 : 10; }
+
+void valve_set_max_open_time(uint16_t seconds) { max_opening_time_s = seconds; settings_save_one("valve/max_open_time", &max_opening_time_s, sizeof(max_opening_time_s)); }
+void valve_set_max_close_time(uint16_t seconds) { max_closing_time_s = seconds; settings_save_one("valve/max_close_time", &max_closing_time_s, sizeof(max_closing_time_s)); }
+uint16_t valve_get_max_open_time(void) { return max_opening_time_s; }
+uint16_t valve_get_max_close_time(void) { return max_closing_time_s; }
--- a/software/lib/valve/valve.h
+++ b/software/lib/valve/valve.h
@@ -0,0 +1,23 @@
+#ifndef VALVE_H
+#define VALVE_H
+
+#include <stdint.h>
+
+enum valve_state { VALVE_STATE_CLOSED, VALVE_STATE_OPEN };
+enum valve_movement { VALVE_MOVEMENT_IDLE, VALVE_MOVEMENT_OPENING, VALVE_MOVEMENT_CLOSING, VALVE_MOVEMENT_ERROR };
+
+void valve_init(void);
+void valve_open(void);
+void valve_close(void);
+void valve_stop(void);
+
+enum valve_state valve_get_state(void);
+enum valve_movement valve_get_movement(void);
+uint16_t valve_get_motor_current(void);
+
+void valve_set_max_open_time(uint16_t seconds);
+void valve_set_max_close_time(uint16_t seconds);
+uint16_t valve_get_max_open_time(void);
+uint16_t valve_get_max_close_time(void);
+
+#endif // VALVE_H