edi/irrigation_system
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added shell functions

Browse Source
This commit is contained in:
Eduard Iten
2025-06-17 16:43:13 +02:00
parent 9d017f9f8d
commit 852c5c72be
10 changed files with 296 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
software/lib/canbus.c
View File

@@ -3,6 +3,7 @@
#include <zephyr/kernel.h>
#include <zephyr/sys/byteorder.h>
#include "config.h"
#include "modbus.h"
int canbus_node_id = 1; // Default node ID for CAN bus
@@ -11,7 +12,7 @@ const struct device *const can_dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_canbus));
struct k_thread rx_thread_data;
K_THREAD_STACK_DEFINE(rx_thread_stack, CANBUS_RX_THREAD_STACK_SIZE);
CAN_MSGQ_DEFINE(commands_msq, 2);
CAN_MSGQ_DEFINE(commands_msq, CANBUS_RX_MSGQ_SIZE);
LOG_MODULE_REGISTER(canbus, CONFIG_LOG_CAN_LEVEL);
@@ -20,14 +21,16 @@ static void rx_thread(void *arg1, void *arg2, void *arg3)
ARG_UNUSED(arg1);
ARG_UNUSED(arg2);
ARG_UNUSED(arg3);
const struct can_filter filter = {
.flags = CAN_FILTER_IDE,
.flags = 0, // No special flags,
.id = (canbus_node_id << 8) | 0x00, // Standard ID with node ID in the first byte
.mask = CAN_STD_ID_MASK & 0xFFFFFF00U // Mask for standard ID, ignoring the last byte
};
struct can_frame frame;
int filter_id;
extern struct k_msgq modbus_msgq;
filter_id = can_add_rx_filter_msgq(can_dev, &commands_msq, &filter);
LOG_DBG("RX thread started. Filter ID: %d, flags: 0x%02x, id: 0x%08x, mask: 0x%08x", filter_id, filter.flags, filter.id, filter.mask);
@@ -37,10 +40,6 @@ static void rx_thread(void *arg1, void *arg2, void *arg3)
k_msgq_get(&commands_msq, &frame, K_FOREVER);
LOG_DBG("Received CAN frame: ID=0x%08x, DLC=%u, Flags=0x%02x",
frame.id, frame.dlc, frame.flags);
if (IS_ENABLED(CONFIG_CAN_ACCEPT_RTR) && (frame.flags & CAN_FRAME_RTR) != 0U)
{
continue;
}
uint8_t target_node = (frame.id >> 8) & 0xFF; // Extract the target node from the ID
if (target_node != canbus_node_id)
@@ -50,9 +49,49 @@ static void rx_thread(void *arg1, void *arg2, void *arg3)
}
uint8_t target_register = frame.id & 0xFF; // Extract the register address from the ID
if (IS_ENABLED(CONFIG_CAN_ACCEPT_RTR) && (frame.flags & CAN_FRAME_RTR) != 0U)
{
LOG_DBG("Received RTR frame for register address: 0x%02x", target_register);
switch (target_register)
{
case CANBUS_REGISTER_WATER_LEVEL_MM:
case CANBUS_REGISTER_WATER_MINIMUM:
case CANBUS_REGISTER_WATER_MAXIMUM:
LOG_DBG("Handling water sensor request for node %d", target_node);
modbus_register_t reg_max;
reg_max.reg = target_register;
reg_max.command = CANBUS_REGISTER_COMMAND_GET; // Set command to GET
k_msgq_put(&modbus_msgq, &reg_max, K_NO_WAIT);
break;
default:
LOG_WRN("Received RTR frame for unknown register address: 0x%02x", target_register);
}
continue;
}
// Log the received frame details
LOG_DBG("Received CAN frame: ID=0x%08x, DLC=%u, Flags=0x%02x, Target Node=%d, Register Address=%d",
LOG_DBG("Received CAN frame: ID=0x%08x, DLC=%u, Flags=0x%02x, Target Node=%d, Register Address=0x%02x",
frame.id, frame.dlc, frame.flags, target_node, target_register);
switch (target_register)
{
case CANBUS_REGISTER_WATER_MINIMUM:
case CANBUS_REGISTER_WATER_MAXIMUM:
LOG_DBG("Handling water sensor data for node %d", target_node);
modbus_register_t reg;
reg.reg = target_register;
reg.command = CANBUS_REGISTER_COMMAND_SET; // Set command to SET
if (frame.dlc >= sizeof(reg.value)) // Ensure enough data length for value
{
reg.value = sys_get_be16(frame.data); // Convert received data to big-endian format
LOG_DBG("Received value: %d, 0x%04x", reg.value, reg.value);
}
else
{
LOG_ERR("Received frame with insufficient data length: %u", frame.dlc);
continue; // Skip processing if data length is invalid
}
k_msgq_put(&modbus_msgq, &reg, K_NO_WAIT);
break;
}
LOG_HEXDUMP_DBG(frame.data, sizeof(frame.data) * sizeof(frame.data[0]), "Frame data:");
}
}
@@ -112,11 +151,12 @@ int canbus_init(void)
return rc;
}
#endif
rc = can_start(can_dev);
if (rc != 0) {
printf("Error starting CAN controller [%d]", rc);
return 0;
}
rc = can_start(can_dev);
if (rc != 0)
{
printf("Error starting CAN controller [%d]", rc);
return 0;
}
LOG_DBG("CAN device %s is ready", can_dev->name);
LOG_DBG("Trying to start rx thread");
@@ -137,7 +177,7 @@ int canbus_init(void)
return 0; // Return 0 on success
}
int canbus_send_message(uint8_t destination_node, uint8_t register_address, uint8_t *data, size_t data_length)
int canbus_send_register(uint8_t destination_node, uint8_t register_address, uint8_t *data, size_t data_length)
{
struct can_frame frame;
if (data_length > sizeof(frame.data))
@@ -155,7 +195,8 @@ int canbus_send_message(uint8_t destination_node, uint8_t register_address, uint
// Send the CAN frame
int rc = can_send(can_dev, &frame, K_MSEC(100), canbus_tx_callback, NULL);
if (rc < 0) {
if (rc < 0)
{
LOG_ERR("Failed to send CAN message: %d", rc);
return rc; // Return error code
}
@@ -163,3 +204,25 @@ int canbus_send_message(uint8_t destination_node, uint8_t register_address, uint
LOG_DBG("CAN message sent: ID=0x%08x, DLC=%u", frame.id, frame.dlc);
return 0;
}
int canbus_request_register(uint8_t node_id, uint8_t register_address)
{
int rc;
struct can_frame frame;
// Prepare the CAN frame for the request
frame.id = (node_id << 8) | register_address; // Standard ID with node ID in the first byte
frame.dlc = 0; // No data for request
frame.flags = CAN_FRAME_RTR; // Set RTR flag for request
// Send the CAN frame
rc = can_send(can_dev, &frame, K_MSEC(100), canbus_tx_callback, NULL);
if (rc < 0)
{
LOG_ERR("Failed to send CAN request: %d", rc);
return rc; // Return error code
}
LOG_DBG("CAN request sent: ID=0x%08x", frame.id);
return 0;
}

9
software/lib/canbus.h
View File

@@ -3,11 +3,13 @@
#include <zephyr/drivers/can.h>
#include <zephyr/kernel.h>
#include "canbus_registers.h"
#define CANBUS_RX_THREAD_STACK_SIZE (512)
#define CANBUS_RX_THREAD_PRIORITY (-2)
#define CANBUS_RX_THREAD_PRIORITY (5)
#define CANBUS_RX_MSGQ_SIZE (5)
typedef struct {
typedef struct can_frame_t{
/** Standard (11-bit) or extended (29-bit) CAN identifier. */
uint32_t id;
/** Data Length Code (DLC) indicating data length in bytes. */
@@ -24,6 +26,7 @@ typedef struct {
} can_frame_t;
int canbus_init(void);
int canbus_send_message(uint8_t destination_node, uint8_t register_address, uint8_t *data, size_t data_length);
int canbus_send_register(uint8_t node_id, uint8_t register_address, uint8_t *data, size_t data_length);
int canbus_request_register(uint8_t node_id, uint8_t register_address);
#endif // __CANBUS_H__

18
software/lib/canbus_registers.h Normal file
View File

@@ -0,0 +1,18 @@
#ifndef __CANBUS_REGISTERS_H__
#define __CANBUS_REGISTERS_H__
typedef enum {
CANBUS_REGISTER_VALVE_COMMAND = 0x00,
CANBUS_REGISTER_VALVE_STATE = 0x01,
CANBUS_REGISTER_WATER_LEVEL_MM = 0x10,
CANBUS_REGISTER_WATER_MINIMUM = 0x11,
CANBUS_REGISTER_WATER_MAXIMUM = 0x12,
} canbus_registers_t;
typedef enum {
CANBUS_REGISTER_COMMAND_SET = 0x00,
CANBUS_REGISTER_COMMAND_GET = 0x01,
} canbus_register_command_t;
#endif // __CANBUS_REGISTERS_H__

71
software/lib/config.c
View File

@@ -6,6 +6,77 @@ LOG_MODULE_REGISTER(config, CONFIG_LOG_SETTINGS_LEVEL);
extern int canbus_node_id; // Default node ID for CAN bus
// Only compile shell commands if CONFIG_SHELL is enabled
// and CONFIG_REBOOT is enabled, as rebooting is required to apply changes
#ifdef CONFIG_SHELL
#ifndef CONFIG_REBOOT
#error You must enable CONFIG_REBOOT to use the shell commands
#endif // CONFIG_REBOOT
#include <zephyr/shell/shell.h>
#include <zephyr/sys/reboot.h>
#include <stdlib.h>
int reboot_system(const struct shell *shell, size_t argc, char **argv)
{
// Reboot the system
shell_print(shell, "Rebooting node in 1 second...");
k_sleep(K_MSEC(1000)); // Wait for 1 second before rebooting
sys_reboot(SYS_REBOOT_COLD); // Perform a cold reboot
return 0; // Return 0 on success
}
int shell_print_config(const struct shell *shell, size_t argc, char **argv)
{
// Print the current settings for the CAN bus node ID
shell_print(shell, "Current configuration settings:");
shell_print(shell, "%26s <%d>", "CANBUS node ID:", canbus_node_id);
return 0;
}
int shell_set_canbus_node_id(const struct shell *shell, size_t argc, char **argv)
{
shell_print(shell, "argument count: %zu", argc);
if (argc != 2)
{
shell_error(shell, "Usage: config set_nodeid <value>");
return -EINVAL; // Invalid argument
}
int new_node_id = atoi(argv[1]);
if (new_node_id < 1 || new_node_id > 7)
{
shell_error(shell, "Invalid CAN bus node ID: <%d>. Must be between 1 and 7.", new_node_id);
return -EINVAL; // Invalid argument
}
canbus_node_id = new_node_id;
LOG_INF("Set CAN bus node ID to <%d>", canbus_node_id);
// Save the new node ID to settings
int rc = settings_save_one("canbus/node_id", &canbus_node_id, sizeof(canbus_node_id));
if (rc < 0)
{
shell_error(shell, "Failed to save CAN bus node ID: %d", rc);
return rc; // Save error
}
shell_print(shell, "CAN bus node ID set to <%d> and saved to settings", canbus_node_id);
shell_warn(shell, "Reboot the node (command: 'reboot') to apply changes.");
return 0; // Return 0 on success
}
SHELL_STATIC_SUBCMD_SET_CREATE(
config_cmds,
SHELL_CMD_ARG(print, NULL, "Print current configuration settings", shell_print_config, 0, 0),
SHELL_CMD_ARG(set_nodeid, NULL, "Set canbus node id", shell_set_canbus_node_id, 2, 0),
SHELL_SUBCMD_SET_END
);
SHELL_CMD_REGISTER(config, &config_cmds, "Configuration commands", NULL);
SHELL_CMD_REGISTER(reboot, NULL, "Reboot the node", reboot_system);
#endif // CONFIG_SHELL
static int settings_canbus(const char *key, size_t len, settings_read_cb read_cb, void *cb_arg)
{
const char *next;

10
software/lib/modbus.h
View File

@@ -3,6 +3,10 @@
#include <zephyr/modbus/modbus.h>
#define MODBUS_THREAD_STACK_SIZE (512)
#define MODBUS_THREAD_PRIORITY (6)
#define MODBUS_MSGQ_SIZE (5)
const static struct modbus_iface_param client_param = {
.mode = MODBUS_MODE_RTU,
.rx_timeout = 50000,
@@ -12,6 +16,12 @@ const static struct modbus_iface_param client_param = {
},
};
typedef struct {
uint8_t reg;
uint8_t command; // 0 for set, 1 for get
int16_t value;
} modbus_register_t;
int mb_init_client(void);
int mb_read_holding_registers(int node, uint16_t reg_addr, uint16_t *data, size_t len);
int mb_read_water_level(double *mb_read_water_level);