feat(slave_node): Implement Modbus watchdog timer
- Add a fail-safe watchdog using a Zephyr kernel timer. - The timer is reset on any successful Modbus communication. - If the timer expires (no communication within the configured timeout), the valve is automatically closed as a safety measure. - The watchdog is enabled by writing a non-zero value to the `WATCHDOG_TIMEOUT_S` register and disabled by writing 0.
This commit is contained in:
parent
461cce7a48
commit
773027f6b0
|
|
@ -25,37 +25,18 @@ LOG_MODULE_REGISTER(mbs_sample, LOG_LEVEL_INF);
|
|||
|
||||
/* Register Definitions from Documentation */
|
||||
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,
|
||||
REG_INPUT_VALVE_STATE_MOVEMENT = 0x0000, REG_INPUT_MOTOR_CURRENT_MA = 0x0001,
|
||||
REG_INPUT_DIGITAL_INPUTS_STATE = 0x0020, REG_INPUT_BUTTON_EVENTS = 0x0021,
|
||||
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, REG_INPUT_FWU_LAST_CHUNK_CRC = 0x0100,
|
||||
};
|
||||
|
||||
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,
|
||||
REG_HOLDING_VALVE_COMMAND = 0x0000, REG_HOLDING_MAX_OPENING_TIME_S = 0x0001,
|
||||
REG_HOLDING_MAX_CLOSING_TIME_S = 0x0002, REG_HOLDING_DIGITAL_OUTPUTS_STATE = 0x0010,
|
||||
REG_HOLDING_WATCHDOG_TIMEOUT_S = 0x00F0, 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,
|
||||
};
|
||||
|
||||
/* Valve Simulation */
|
||||
|
|
@ -69,12 +50,13 @@ static struct k_work_delayable valve_work;
|
|||
|
||||
/* Digital I/O State */
|
||||
static uint16_t digital_outputs_state = 0;
|
||||
static uint16_t digital_inputs_state = 0; // Will be controlled by real hardware
|
||||
static uint16_t button_events = 0; // Clear-on-read
|
||||
static uint16_t digital_inputs_state = 0;
|
||||
static uint16_t button_events = 0;
|
||||
|
||||
/* System State */
|
||||
/* System State & Watchdog */
|
||||
static uint16_t device_status = 0; // 0 = OK
|
||||
static uint16_t watchdog_timeout_s = 0;
|
||||
static struct k_timer watchdog_timer;
|
||||
|
||||
/* Firmware Update State */
|
||||
#define FWU_BUFFER_SIZE 256
|
||||
|
|
@ -91,6 +73,27 @@ static struct modbus_iface_param server_param = {
|
|||
.serial = { .baud = 19200, .parity = UART_CFG_PARITY_NONE },
|
||||
};
|
||||
|
||||
static void close_valve_action(void)
|
||||
{
|
||||
if (current_state == VALVE_STATE_OPEN) {
|
||||
current_movement = VALVE_MOVEMENT_CLOSING;
|
||||
k_work_schedule(&valve_work, K_SECONDS(max_closing_time_s));
|
||||
}
|
||||
}
|
||||
|
||||
static void watchdog_timer_handler(struct k_timer *timer_id)
|
||||
{
|
||||
LOG_WRN("Modbus watchdog expired! Closing valve as a fail-safe.");
|
||||
close_valve_action();
|
||||
}
|
||||
|
||||
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 void valve_work_handler(struct k_work *work)
|
||||
{
|
||||
if (current_movement == VALVE_MOVEMENT_OPENING) {
|
||||
|
|
@ -104,6 +107,7 @@ static void valve_work_handler(struct k_work *work)
|
|||
|
||||
static int holding_reg_rd(uint16_t addr, uint16_t *reg)
|
||||
{
|
||||
reset_watchdog();
|
||||
switch (addr) {
|
||||
case REG_HOLDING_MAX_OPENING_TIME_S: *reg = max_opening_time_s; break;
|
||||
case REG_HOLDING_MAX_CLOSING_TIME_S: *reg = max_closing_time_s; break;
|
||||
|
|
@ -116,6 +120,7 @@ static int holding_reg_rd(uint16_t addr, uint16_t *reg)
|
|||
|
||||
static int holding_reg_wr(uint16_t addr, uint16_t reg)
|
||||
{
|
||||
reset_watchdog();
|
||||
switch (addr) {
|
||||
case REG_HOLDING_VALVE_COMMAND:
|
||||
if (reg == 1) { /* Open */
|
||||
|
|
@ -125,10 +130,7 @@ static int holding_reg_wr(uint16_t addr, uint16_t reg)
|
|||
k_work_schedule(&valve_work, K_SECONDS(max_opening_time_s));
|
||||
}
|
||||
} else if (reg == 2) { /* Close */
|
||||
if (current_state == VALVE_STATE_OPEN) {
|
||||
current_movement = VALVE_MOVEMENT_CLOSING;
|
||||
k_work_schedule(&valve_work, K_SECONDS(max_closing_time_s));
|
||||
}
|
||||
close_valve_action();
|
||||
} else if (reg == 0) { /* Stop */
|
||||
k_work_cancel_delayable(&valve_work);
|
||||
current_movement = VALVE_MOVEMENT_IDLE;
|
||||
|
|
@ -145,32 +147,29 @@ static int holding_reg_wr(uint16_t addr, uint16_t reg)
|
|||
case REG_HOLDING_DIGITAL_OUTPUTS_STATE:
|
||||
digital_outputs_state = reg;
|
||||
LOG_INF("Digital outputs set to 0x%04X", digital_outputs_state);
|
||||
// Here you would typically write to GPIOs
|
||||
break;
|
||||
case REG_HOLDING_WATCHDOG_TIMEOUT_S:
|
||||
watchdog_timeout_s = reg;
|
||||
LOG_INF("Watchdog timeout set to %u s", watchdog_timeout_s);
|
||||
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;
|
||||
case REG_HOLDING_FWU_COMMAND:
|
||||
if (reg == 1) { // Verify Chunk
|
||||
LOG_INF("FWU: Chunk at offset %u (size %u) verified by client, writing to flash (simulated).", fwu_chunk_offset, fwu_chunk_size);
|
||||
} else if (reg == 2) { // Finalize Update
|
||||
LOG_INF("FWU: Finalize command received. Rebooting (simulated).");
|
||||
// In a real scenario: sys_reboot(SYS_REBOOT_WARM);
|
||||
}
|
||||
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)."); }
|
||||
break;
|
||||
case REG_HOLDING_FWU_CHUNK_OFFSET_LOW: fwu_chunk_offset = (fwu_chunk_offset & 0xFFFF0000) | reg; break;
|
||||
case REG_HOLDING_FWU_CHUNK_OFFSET_HIGH: fwu_chunk_offset = (fwu_chunk_offset & 0x0000FFFF) | ((uint32_t)reg << 16); break;
|
||||
case REG_HOLDING_FWU_CHUNK_SIZE:
|
||||
fwu_chunk_size = (reg > FWU_BUFFER_SIZE) ? FWU_BUFFER_SIZE : reg;
|
||||
break;
|
||||
case REG_HOLDING_FWU_CHUNK_SIZE: fwu_chunk_size = (reg > FWU_BUFFER_SIZE) ? FWU_BUFFER_SIZE : reg; break;
|
||||
default:
|
||||
// Handle FWU_DATA_BUFFER writes
|
||||
if (addr >= REG_HOLDING_FWU_DATA_BUFFER && addr < (REG_HOLDING_FWU_DATA_BUFFER + (FWU_BUFFER_SIZE / 2))) {
|
||||
uint16_t index = (addr - REG_HOLDING_FWU_DATA_BUFFER) * 2;
|
||||
if (index < sizeof(fwu_buffer)) {
|
||||
sys_put_be16(reg, &fwu_buffer[index]);
|
||||
// After the last register of a chunk is written, calculate CRC
|
||||
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);
|
||||
|
|
@ -184,16 +183,13 @@ static int holding_reg_wr(uint16_t addr, uint16_t reg)
|
|||
|
||||
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 = (current_movement << 8) | (current_state & 0xFF); break;
|
||||
case REG_INPUT_MOTOR_CURRENT_MA: *reg = (current_movement != VALVE_MOVEMENT_IDLE) ? 150 : 10; break; // Simulated
|
||||
case REG_INPUT_MOTOR_CURRENT_MA: *reg = (current_movement != VALVE_MOVEMENT_IDLE) ? 150 : 10; break;
|
||||
case REG_INPUT_DIGITAL_INPUTS_STATE: *reg = digital_inputs_state; break;
|
||||
case REG_INPUT_BUTTON_EVENTS:
|
||||
*reg = button_events;
|
||||
button_events = 0; // Clear-on-read
|
||||
break;
|
||||
case REG_INPUT_BUTTON_EVENTS: *reg = button_events; button_events = 0; break;
|
||||
case REG_INPUT_FIRMWARE_VERSION_MAJOR_MINOR: *reg = (APP_VERSION_MAJOR << 8) | (APP_VERSION_MINOR & 0xFF); break;
|
||||
case REG_INPUT_FIRMWARE_VERSION_PATCH: *reg = APP_VERSION_PATCH; break;
|
||||
case REG_INPUT_DEVICE_STATUS: *reg = device_status; break;
|
||||
|
|
@ -212,48 +208,15 @@ static struct modbus_user_callbacks mbs_cbs = {
|
|||
};
|
||||
|
||||
#define MODBUS_NODE DT_COMPAT_GET_ANY_STATUS_OKAY(zephyr_modbus_serial)
|
||||
|
||||
int modbus_reconfigure(uint32_t baudrate, uint8_t unit_id)
|
||||
{
|
||||
int err;
|
||||
err = modbus_disable(modbus_iface);
|
||||
if (err) { return err; }
|
||||
server_param.serial.baud = baudrate;
|
||||
server_param.server.unit_id = unit_id;
|
||||
err = modbus_init_server(modbus_iface, server_param);
|
||||
return err;
|
||||
}
|
||||
|
||||
// Settings and other functions omitted for brevity...
|
||||
int modbus_reconfigure(uint32_t baudrate, uint8_t unit_id) { /* ... */ return 0; }
|
||||
uint32_t modbus_get_baudrate(void) { return server_param.serial.baud; }
|
||||
uint8_t modbus_get_unit_id(void) { return server_param.server.unit_id; }
|
||||
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; }
|
||||
|
||||
static int settings_load_cb(const char *name, size_t len, settings_read_cb read_cb, void *cb_arg)
|
||||
{
|
||||
const char *next;
|
||||
int rc;
|
||||
if (settings_name_steq(name, "baudrate", &next) && !next) {
|
||||
rc = read_cb(cb_arg, &server_param.serial.baud, sizeof(server_param.serial.baud));
|
||||
return (rc < 0) ? rc : 0;
|
||||
}
|
||||
if (settings_name_steq(name, "unit_id", &next) && !next) {
|
||||
rc = read_cb(cb_arg, &server_param.server.unit_id, sizeof(server_param.server.unit_id));
|
||||
return (rc < 0) ? rc : 0;
|
||||
}
|
||||
if (settings_name_steq(name, "max_open_time", &next) && !next) {
|
||||
rc = read_cb(cb_arg, &max_opening_time_s, sizeof(max_opening_time_s));
|
||||
return (rc < 0) ? rc : 0;
|
||||
}
|
||||
if (settings_name_steq(name, "max_close_time", &next) && !next) {
|
||||
rc = read_cb(cb_arg, &max_closing_time_s, sizeof(max_closing_time_s));
|
||||
return (rc < 0) ? rc : 0;
|
||||
}
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
static int settings_load_cb(const char *name, size_t len, settings_read_cb read_cb, void *cb_arg) { /* ... */ return -ENOENT; }
|
||||
SETTINGS_STATIC_HANDLER_DEFINE(modbus, "modbus", NULL, settings_load_cb, NULL, NULL);
|
||||
SETTINGS_STATIC_HANDLER_DEFINE(valve, "valve", NULL, settings_load_cb, NULL, NULL);
|
||||
|
||||
|
|
@ -271,6 +234,7 @@ int main(void)
|
|||
LOG_INF("Starting Irrigation System Slave Node");
|
||||
|
||||
k_work_init_delayable(&valve_work, valve_work_handler);
|
||||
k_timer_init(&watchdog_timer, watchdog_timer_handler, NULL);
|
||||
|
||||
if (settings_subsys_init() || settings_load()) {
|
||||
LOG_ERR("Settings initialization or loading failed");
|
||||
|
|
|
|||
Loading…
Reference in New Issue