merging
This commit is contained in:
commit
0b5ad510fe
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,10 @@
|
|||
{
|
||||
"recommendations": [
|
||||
"ms-vscode.cpptools-extension-pack",
|
||||
"ms-python.python",
|
||||
"ms-vscode.vscode-embedded-tools",
|
||||
"ms-vscode.vscode-serial-monitor",
|
||||
"marus25.cortex-debug",
|
||||
"donjayamanne.python-environment-manager"
|
||||
]
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
{
|
||||
"version": "0.2.0",
|
||||
"configurations": [
|
||||
{
|
||||
"name": "Launch",
|
||||
"device": "STM32F103RB",
|
||||
"cwd": "${workspaceFolder}",
|
||||
"executable": "build/zephyr/zephyr.elf",
|
||||
"request": "launch",
|
||||
"type": "cortex-debug",
|
||||
//"runToEntryPoint": "main",
|
||||
"servertype": "jlink",
|
||||
"gdbPath": "${userHome}/zephyr-sdk-0.17.1/arm-zephyr-eabi/bin/arm-zephyr-eabi-gdb",
|
||||
"preLaunchTask": "West Build"
|
||||
},
|
||||
{
|
||||
"name": "Attach",
|
||||
"device": "nRF52840_xxAA",
|
||||
"cwd": "${workspaceFolder}",
|
||||
"executable": "build/zephyr/zephyr.elf",
|
||||
"request": "attach",
|
||||
"type": "cortex-debug",
|
||||
// "runToEntryPoint": "main",
|
||||
"servertype": "jlink",
|
||||
"gdbPath": "${userHome}/zephyr-sdk-0.17.1/arm-zephyr-eabi/bin/arm-zephyr-eabi-gdb"
|
||||
},
|
||||
]
|
||||
}
|
||||
|
|
@ -1,15 +1,12 @@
|
|||
{
|
||||
"nrf-connect.applications": [
|
||||
"${workspaceFolder}\\modbus_test"
|
||||
],
|
||||
"files.associations": {
|
||||
"log.h": "c",
|
||||
"modbus.h": "c",
|
||||
"array": "c",
|
||||
"string": "c",
|
||||
"string_view": "c",
|
||||
"canbus.h": "c",
|
||||
"kernel.h": "c",
|
||||
"settings.h": "c"
|
||||
}
|
||||
// Hush CMake
|
||||
"cmake.configureOnOpen": false,
|
||||
|
||||
// IntelliSense
|
||||
"C_Cpp.default.compilerPath": "${userHome}/zephyr-sdk-0.17.1/arm-zephyr-eabi/bin/arm-zephyr-eabi-gcc.exe",
|
||||
"C_Cpp.default.compileCommands": "${workspaceFolder}/build/compile_commands.json",
|
||||
|
||||
// File Associations
|
||||
"files.associations": {
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
{
|
||||
"version": "2.0.0",
|
||||
"tasks": [
|
||||
{
|
||||
"label": "West Build",
|
||||
"type": "shell",
|
||||
"group": {
|
||||
"kind": "build",
|
||||
"isDefault": true
|
||||
},
|
||||
"linux": {
|
||||
"command": "${userHome}/zephyrproject/.venv/bin/west"
|
||||
},
|
||||
"windows": {
|
||||
"command": "${userHome}/zephyrproject/.venv/Scripts/west.exe"
|
||||
},
|
||||
"osx": {
|
||||
"command": "${userHome}/zephyrproject/.venv/bin/west"
|
||||
},
|
||||
"args": [
|
||||
"build",
|
||||
"-p",
|
||||
"auto",
|
||||
"-b",
|
||||
"valve_node"
|
||||
],
|
||||
"problemMatcher": [
|
||||
"$gcc"
|
||||
]
|
||||
},
|
||||
{
|
||||
"label": "West Configurable Build",
|
||||
"type": "shell",
|
||||
"group": {
|
||||
"kind": "build",
|
||||
},
|
||||
"linux": {
|
||||
"command": "${userHome}/zephyrproject/.venv/bin/west"
|
||||
},
|
||||
"windows": {
|
||||
"command": "${userHome}/zephyrproject/.venv/Scripts/west.exe"
|
||||
},
|
||||
"osx": {
|
||||
"command": "${userHome}/zephyrproject/.venv/bin/west"
|
||||
},
|
||||
"args": [
|
||||
"build",
|
||||
"-p",
|
||||
"${input:pristine}",
|
||||
"-b",
|
||||
"${input:board}"
|
||||
],
|
||||
"problemMatcher": [
|
||||
"$gcc"
|
||||
]
|
||||
},
|
||||
{
|
||||
"label": "West Flash",
|
||||
"type": "shell",
|
||||
"linux": {
|
||||
"command": "${userHome}/zephyrproject/.venv/bin/west"
|
||||
},
|
||||
"windows": {
|
||||
"command": "${userHome}/zephyrproject/.venv/Scripts/west.exe"
|
||||
},
|
||||
"osx": {
|
||||
"command": "${userHome}/zephyrproject/.venv/bin/west"
|
||||
},
|
||||
"args": [
|
||||
"flash"
|
||||
],
|
||||
"problemMatcher": [
|
||||
"$gcc"
|
||||
]
|
||||
}
|
||||
],
|
||||
"inputs": [
|
||||
{
|
||||
"id": "board",
|
||||
"type": "promptString",
|
||||
"default": "valve-node",
|
||||
"description": "See https://docs.zephyrproject.org/latest/boards/index.html"
|
||||
},
|
||||
{
|
||||
"id": "pristine",
|
||||
"type": "pickString",
|
||||
"description": "Choose when to run a pristine build",
|
||||
"default": "auto",
|
||||
"options": [
|
||||
"auto",
|
||||
"always",
|
||||
"never"
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
# SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
cmake_minimum_required(VERSION 3.20.0)
|
||||
|
||||
list(APPEND BOARD_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
|
||||
|
||||
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
|
||||
project(valve_node)
|
||||
|
||||
target_sources(app PRIVATE src/main.c)
|
||||
target_sources(app PRIVATE lib/canbus.c)
|
||||
|
||||
# source files for modbus waterlevel sensor
|
||||
zephyr_library_sources_ifdef(CONFIG_HAS_MODBUS_WATERLEVEL_SENSOR
|
||||
lib/waterlevel_sensor.c
|
||||
)
|
||||
|
||||
#source files for valve
|
||||
zephyr_library_sources_ifdef(CONFIG_HAS_VALVE
|
||||
lib/valve.c
|
||||
)
|
||||
|
||||
zephyr_include_directories(
|
||||
lib
|
||||
)
|
||||
|
|
@ -1,7 +1,7 @@
|
|||
config BOARD_VALVE_NODE
|
||||
select SOC_STM32F103XB
|
||||
|
||||
mainmenu "Controller Area Network sample application"
|
||||
mainmenu "APP CAN Settings"
|
||||
config LOOPBACK_MODE
|
||||
bool "Loopback LOOPBACK_MODE"
|
||||
default n
|
||||
|
|
@ -9,6 +9,7 @@ config LOOPBACK_MODE
|
|||
Set the can controller to loopback mode.
|
||||
This allows testing without a second board.
|
||||
|
||||
mainmenu "APP Logging Settings"
|
||||
config LOG_CAN_LEVEL
|
||||
int "Log level for CAN"
|
||||
default 3
|
||||
|
|
@ -16,3 +17,42 @@ config LOG_CAN_LEVEL
|
|||
help
|
||||
Set the log level for CAN messages.
|
||||
0 = None, 1 = Error, 2 = Warning, 3 = Info, 4 = Debug, 5 = Trace, 6 = Debug2, 7 = Debug3
|
||||
|
||||
config LOG_SETTINGS_LEVEL
|
||||
int "Log level for settings"
|
||||
default 3
|
||||
range 0 7
|
||||
help
|
||||
Set the log level for CAN messages.
|
||||
0 = None, 1 = Error, 2 = Warning, 3 = Info, 4 = Debug, 5 = Trace, 6 = Debug2, 7 = Debug3
|
||||
|
||||
config LOG_WATERLEVELSENSOR_LEVEL
|
||||
int "Log level for waterlevel sensor"
|
||||
default 3
|
||||
range 0 7
|
||||
help
|
||||
Set the log level for CAN messages.
|
||||
0 = None, 1 = Error, 2 = Warning, 3 = Info, 4 = Debug, 5 = Trace, 6 = Debug2, 7 = Debug3
|
||||
|
||||
config LOG_VALVE_LEVEL
|
||||
int "Log level for valve control"
|
||||
default 3
|
||||
range 0 7
|
||||
help
|
||||
Set the log level for valve control messages.
|
||||
0 = None, 1 = Error, 2 = Warning, 3 = Info, 4 = Debug, 5 = Trace, 6 = Debug2, 7 = Debug3
|
||||
|
||||
mainmenu "Irrigation controller node configuration"
|
||||
config HAS_MODBUS_WATERLEVEL_SENSOR
|
||||
bool "Has modbus water level sensor"
|
||||
default n
|
||||
help
|
||||
Enable modbus water level sensor support.
|
||||
This allows reading the water level from a modbus device.
|
||||
|
||||
config HAS_VALVE
|
||||
bool "Has valve control"
|
||||
default n
|
||||
help
|
||||
Enable valve control support.
|
||||
This allows controlling valves via CAN messages.
|
||||
|
|
@ -8,3 +8,4 @@ board_runner_args(jlink "--device=STM32F103RB" "--speed=4000")
|
|||
include(${ZEPHYR_BASE}/boards/common/stm32cubeprogrammer.board.cmake)
|
||||
include(${ZEPHYR_BASE}/boards/common/openocd-stm32.board.cmake)
|
||||
include(${ZEPHYR_BASE}/boards/common/jlink.board.cmake)
|
||||
include(${ZEPHYR_BASE}/boards/common/blackmagicprobe.board.cmake)
|
||||
|
|
|
|||
|
|
@ -13,12 +13,18 @@
|
|||
model = "Iten engineering Valve Node";
|
||||
compatible = "iten,valve-node", "st,stm32f103rb";
|
||||
|
||||
can_loopback0: can_loopback0 {
|
||||
status = "disabled";
|
||||
compatible = "zephyr,can-loopback";
|
||||
};
|
||||
|
||||
chosen {
|
||||
zephyr,console = &usart1;
|
||||
zephyr,shell-uart = &usart1;
|
||||
zephyr,sram = &sram0;
|
||||
zephyr,flash = &flash0;
|
||||
zephyr,canbus = &can1;
|
||||
//zephyr,canbus = &can_loopback0;
|
||||
};
|
||||
|
||||
leds: leds {
|
||||
|
|
@ -73,6 +79,10 @@
|
|||
gpios = <&gpiob 13 0>;
|
||||
label = "Motor Open";
|
||||
};
|
||||
fake: fake {
|
||||
gpios = <&gpiob 11 GPIO_PULL_UP>;
|
||||
label = "CAN RX pullup";
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -174,7 +184,7 @@
|
|||
pinctrl-0 = <&can_rx_pa11 &can_tx_pa12>;
|
||||
pinctrl-names = "default";
|
||||
status= "okay";
|
||||
bus-speed = < 125000 >;
|
||||
bus-speed = <125000>;
|
||||
};
|
||||
|
||||
&exti {
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@ CONFIG_MODBUS_ROLE_CLIENT=y
|
|||
CONFIG_CAN=y
|
||||
CONFIG_CAN_INIT_PRIORITY=80
|
||||
#CONFIG_CAN_MAX_FILTER=5
|
||||
CONFIG_CAN_ACCEPT_RTR=y
|
||||
|
||||
# settings
|
||||
CONFIG_FLASH=y
|
||||
|
|
|
|||
|
|
@ -1,81 +1,152 @@
|
|||
#include "canbus.h"
|
||||
#include <zephyr/logging/log.h>
|
||||
#include <zephyr/kernel.h>
|
||||
#include "settings.h"
|
||||
#include <zephyr/sys/byteorder.h>
|
||||
#include <zephyr/drivers/can.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifdef CONFIG_HAS_MODBUS_WATERLEVEL_SENSOR
|
||||
#include "waterlevel_sensor.h"
|
||||
#endif // CONFIG_HAS_MODBUS_WATERLEVEL_SENSOR
|
||||
|
||||
#ifdef CONFIG_HAS_VALVE
|
||||
#include "valve.h"
|
||||
#endif // CONFIG_HAS_VALVE
|
||||
|
||||
const struct device *const can_dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_canbus));
|
||||
|
||||
K_THREAD_STACK_DEFINE(rx_thread_stack, RX_THREAD_STACK_SIZE);
|
||||
|
||||
static uint8_t node_id = 12; // Default node ID
|
||||
|
||||
LOG_MODULE_REGISTER(canbus, CONFIG_LOG_CAN_LEVEL);
|
||||
|
||||
static int canbus_set(const char *key, size_t len, settings_read_cb read_cb, void *cb_arg)
|
||||
K_MSGQ_DEFINE(canbus_msgq, sizeof(struct can_frame), CANBUS_RX_MSGQ_SIZE, 4);
|
||||
K_THREAD_STACK_DEFINE(canbus_rx_stack, CANBUS_RX_THREAD_STACK_SIZE);
|
||||
|
||||
uint8_t node_id = 0; // Default node ID, can be set later
|
||||
uint8_t can_msg_id = 0;
|
||||
|
||||
k_tid_t canbus_rx_thread_id;
|
||||
struct k_thread canbus_rx_thread_data;
|
||||
|
||||
int canbus_rx_filter_id = -1;
|
||||
|
||||
void canbus_rx_callback(const struct device *dev, struct can_frame *frame, void *user_data)
|
||||
{
|
||||
const char *next;
|
||||
int rc;
|
||||
ARG_UNUSED(dev);
|
||||
ARG_UNUSED(user_data);
|
||||
|
||||
// Handle setting values for CAN bus configuration
|
||||
LOG_DBG("Setting CAN bus configuration: key=%s, len=%zu", key, len);
|
||||
if (settings_name_steq(key, "node_id", &next) && next != NULL)
|
||||
if (frame->id >> 8 != node_id) // Check if the frame ID matches the node ID
|
||||
{
|
||||
if (len != sizeof(node_id))
|
||||
{
|
||||
LOG_ERR("Invalid length for node_id setting: %zu", len);
|
||||
return -EINVAL; // Invalid argument
|
||||
}
|
||||
|
||||
rc = read_cb(cb_arg, &node_id, sizeof(node_id));
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to read node_id setting: %d", rc);
|
||||
return rc; // Read error
|
||||
}
|
||||
LOG_DBG("Set CAN bus node ID to: %d", node_id);
|
||||
LOG_DBG("Received CAN frame with ID %d, but it does not match node ID %d", frame->id >> 8, node_id);
|
||||
return; // Ignore frames that do not match the node ID
|
||||
}
|
||||
|
||||
// Process the received CAN frame
|
||||
rc = k_msgq_put(&canbus_msgq, frame, K_NO_WAIT);
|
||||
if (rc != 0)
|
||||
{
|
||||
LOG_ERR("Failed to put CAN frame into message queue: %d", rc);
|
||||
}
|
||||
return 0; // Return 0 on success
|
||||
}
|
||||
|
||||
struct settings_handler canbus_settings_handler = {
|
||||
.name = "canbus",
|
||||
.h_set = canbus_set, // No settings set handler
|
||||
};
|
||||
void canbus_thread(void *arg1, void *arg2, void *arg3)
|
||||
{
|
||||
ARG_UNUSED(arg1);
|
||||
ARG_UNUSED(arg2);
|
||||
ARG_UNUSED(arg3);
|
||||
|
||||
LOG_INF("CAN bus thread started");
|
||||
|
||||
// Main loop for CAN bus operations
|
||||
while (1)
|
||||
{
|
||||
int rc;
|
||||
struct can_frame frame;
|
||||
k_msgq_get(&canbus_msgq, &frame, K_FOREVER); // Wait for a message from the queue
|
||||
LOG_DBG("Received CAN frame with ID: 0x%02x, DLC: %d, RTR: %d",
|
||||
frame.id, frame.dlc, (uint8_t)(frame.flags & CAN_FRAME_RTR));
|
||||
LOG_HEXDUMP_DBG(frame.data, frame.dlc, "CAN frame data");
|
||||
uint8_t reg = frame.id & 0xFF; // Extract register from the frame ID
|
||||
bool is_rtr = (frame.flags & CAN_FRAME_RTR) != 0; // Check if it's a remote transmission request
|
||||
switch (reg)
|
||||
{
|
||||
#ifdef CONFIG_HAS_MODBUS_WATERLEVEL_SENSOR
|
||||
case CANBUS_REG_WATERLEVEL_LEVEL:
|
||||
case CANBUS_REG_WATERLEVEL_ZERO_POINT:
|
||||
case CANBUS_REG_WATERLEVEL_MAX_POINT:
|
||||
waterlevel_command_t command;
|
||||
command.cmd = is_rtr ? WATERLEVEL_CMD_GET : WATERLEVEL_CMD_SET; // Determine command type based on RTR
|
||||
command.reg = reg; // Set the register ID
|
||||
int16_t value = 0; // Initialize value to 0
|
||||
if (!is_rtr) // If it's not a remote request, extract the value from the frame data
|
||||
{
|
||||
if (frame.dlc < sizeof(command.data))
|
||||
{ LOG_ERR("Received frame with insufficient data length: %d", frame.dlc);
|
||||
continue; // Skip processing if data length is insufficient
|
||||
}
|
||||
value = sys_be16_to_cpu(*(uint16_t *)frame.data); // Convert data from big-endian to host byte order
|
||||
command.data = value; // Set the data field
|
||||
LOG_DBG("Setting command data to: %d", value);
|
||||
}
|
||||
extern struct k_msgq waterlevel_sensor_msgq; // Declare the water level sensor message queue
|
||||
k_msgq_put(&waterlevel_sensor_msgq, &command, K_NO_WAIT);
|
||||
break;
|
||||
#endif // CONFIG_HAS_MODBUS_WATERLEVEL_SENSOR
|
||||
#ifdef CONFIG_HAS_VALVE
|
||||
case CANBUS_REG_VALVE_STATUS:
|
||||
case CANBUS_REG_VALVE_OPERATION:
|
||||
if (is_rtr)
|
||||
{
|
||||
LOG_DBG("Received remote request for valve status or operation");
|
||||
if (reg == CANBUS_REG_VALVE_STATUS)
|
||||
{
|
||||
valve_send_status(); // Send the current valve status
|
||||
}
|
||||
else if (reg == CANBUS_REG_VALVE_OPERATION)
|
||||
{
|
||||
valve_send_operation(); // Send the current valve operation state
|
||||
} else {
|
||||
LOG_ERR("Unknown valve register: 0x%02x", reg);
|
||||
continue; // Skip processing if the register is unknown
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_ERR("Received CAN frame with data for valve status or operation, but RTR is not set");
|
||||
continue; // Skip processing if RTR is not set for valve status or operation
|
||||
}
|
||||
break;
|
||||
case CANBUS_REG_VALVE_COMMAND:
|
||||
{
|
||||
if (is_rtr) {
|
||||
LOG_ERR("Received remote request for valve command, but this is not supported");
|
||||
continue; // Skip processing if RTR is set for valve command
|
||||
} else {
|
||||
// Extract the command from the frame data
|
||||
if (frame.dlc < sizeof(uint8_t)) {
|
||||
LOG_ERR("Received frame with insufficient data length for valve command: %d", frame.dlc);
|
||||
continue; // Skip processing if data length is insufficient
|
||||
}
|
||||
uint8_t command = frame.data[0]; // Get the command from the first byte of data
|
||||
LOG_DBG("Received valve command: 0x%02x", command);
|
||||
rc = valve_cmd(command); // Send the command to the valve
|
||||
if (rc < 0) {
|
||||
LOG_ERR("Failed to send valve command: %d", rc);
|
||||
continue; // Skip processing if sending the command failed
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
LOG_DBG("Received CAN frame with unknown register: 0x%02x", reg);
|
||||
break;
|
||||
}
|
||||
#endif // CONFIG_HAS_VALVE
|
||||
}
|
||||
}
|
||||
|
||||
int canbus_init(void)
|
||||
{
|
||||
int rc;
|
||||
settings_subsys_init();
|
||||
settings_register(&canbus_settings_handler);
|
||||
settings_load();
|
||||
|
||||
rc = settings_get_val_len("canbus/node_id");
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to check CAN bus settings: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
|
||||
else if (rc == 0)
|
||||
{
|
||||
LOG_WRN("No CAN bus node id found in settings, using default default (%d)", node_id);
|
||||
settings_save_one("canbus/node_id", &node_id, sizeof(node_id));
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to save default CAN bus node id: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
rc = settings_load_one("canbus/node_id", &node_id, sizeof(node_id));
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to load CAN bus node id from settings: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
LOG_DBG("Loaded CAN bus node id: %d", node_id);
|
||||
}
|
||||
int rc = 0;
|
||||
|
||||
if (!device_is_ready(can_dev))
|
||||
{
|
||||
|
|
@ -91,5 +162,125 @@ int canbus_init(void)
|
|||
return rc;
|
||||
}
|
||||
#endif
|
||||
|
||||
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);
|
||||
// Initialize the CAN RX thread
|
||||
canbus_rx_thread_id = k_thread_create(&canbus_rx_thread_data, canbus_rx_stack,
|
||||
K_THREAD_STACK_SIZEOF(canbus_rx_stack), canbus_thread,
|
||||
NULL, NULL, NULL,
|
||||
CANBUS_RX_THREAD_PRIORITY, 0, K_NO_WAIT);
|
||||
k_thread_name_set(canbus_rx_thread_id, "canbus_rx");
|
||||
|
||||
const struct can_filter filter = {
|
||||
.id = node_id << 8, // Standard ID with node ID in the first byte
|
||||
.mask = 0x700, // Mask to match the first byte of the ID
|
||||
.flags = 0, // No special flags
|
||||
};
|
||||
canbus_rx_filter_id = can_add_rx_filter(can_dev, canbus_rx_callback, NULL, &filter);
|
||||
LOG_DBG("CAN RX filter added for node ID %d", canbus_rx_filter_id);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void canbus_tx8_callback(const struct device *dev, int error, void *user_data)
|
||||
{
|
||||
ARG_UNUSED(dev);
|
||||
uint8_t frame_id = *(uint8_t *)user_data; // Retrieve the frame ID from user data
|
||||
|
||||
if (error != 0)
|
||||
{
|
||||
LOG_ERR("CAN transmission error. Error code: %d, Frame ID: %d", error, frame_id);
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_DBG("CAN message with Frame ID %d sent successfully", frame_id);
|
||||
}
|
||||
free(user_data); // Free the allocated memory for frame ID
|
||||
}
|
||||
|
||||
int canbus_send8(uint16_t reg, uint8_t value)
|
||||
{
|
||||
int rc = 0;
|
||||
struct can_frame frame = {
|
||||
.id = (node_id << 8) | reg, // Standard ID with node ID in the first byte
|
||||
.dlc = sizeof(value), // Data Length Code (DLC)
|
||||
};
|
||||
frame.data[0] = value; // Set the value in the first byte of the data
|
||||
uint8_t *frame_id = malloc(sizeof(uint8_t)); // Allocate memory for frame ID
|
||||
LOG_DBG("Preparing to send 8-bit value 0x%02x to register 0x%02x on node %d", value, reg, node_id);
|
||||
if (frame_id == NULL)
|
||||
{
|
||||
LOG_ERR("Failed to allocate memory for frame ID");
|
||||
return -ENOMEM; // Not enough memory
|
||||
}
|
||||
*frame_id = can_msg_id++; // Increment message ID for uniqueness
|
||||
LOG_DBG("Using frame ID: %d", *frame_id);
|
||||
rc = can_send(can_dev, &frame, CANBUS_TX_TIMEOUT, canbus_tx8_callback, frame_id);
|
||||
// Send the CAN frame with a timeout and callback
|
||||
if (rc != 0)
|
||||
{
|
||||
LOG_ERR("Failed to queue CAN frame: %d", rc);
|
||||
free(frame_id); // Free the allocated memory for frame ID
|
||||
return rc;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void canbus_tx16_callback(const struct device *dev, int error, void *user_data)
|
||||
{
|
||||
ARG_UNUSED(dev);
|
||||
uint8_t frame_id = *(uint8_t *)user_data; // Retrieve the frame ID from user data
|
||||
|
||||
if (error != 0)
|
||||
{
|
||||
LOG_ERR("CAN transmission error. Error code: %d, Frame ID: %d", error, frame_id);
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_DBG("CAN message with Frame ID %d sent successfully", frame_id);
|
||||
}
|
||||
free(user_data); // Free the allocated memory for frame ID
|
||||
}
|
||||
|
||||
int canbus_send16(uint16_t reg, uint16_t value)
|
||||
{
|
||||
int rc = 0;
|
||||
union data_type
|
||||
{
|
||||
int16_t value;
|
||||
uint8_t bytes[2];
|
||||
} data;
|
||||
data.value = sys_cpu_to_be16(value); // Convert value to big-endian format
|
||||
|
||||
struct can_frame frame = {
|
||||
.id = (node_id << 8) | reg, // Standard ID with node ID in the first byte
|
||||
.dlc = sizeof(data), // Data Length Code (DLC)
|
||||
};
|
||||
memcpy(frame.data, data.bytes, sizeof(data)); // Copy data into the frame
|
||||
uint8_t *frame_id = malloc(sizeof(uint8_t)); // Allocate memory for frame ID
|
||||
LOG_DBG("Preparing to send 16-bit value 0x%04x to register 0x%02x on node %d", value, reg, node_id);
|
||||
if (frame_id == NULL)
|
||||
{
|
||||
LOG_ERR("Failed to allocate memory for frame ID");
|
||||
return -ENOMEM; // Not enough memory
|
||||
}
|
||||
*frame_id = can_msg_id++; // Increment message ID for uniqueness
|
||||
LOG_DBG("Using frame ID: %d", *frame_id);
|
||||
rc = can_send(can_dev, &frame, CANBUS_TX_TIMEOUT, canbus_tx16_callback, frame_id);
|
||||
// Send the CAN frame with a timeout and callback
|
||||
if (rc != 0)
|
||||
{
|
||||
LOG_ERR("Failed to queue CAN frame: %d", rc);
|
||||
free(frame_id); // Free the allocated memory for frame ID
|
||||
return rc;
|
||||
}
|
||||
|
||||
LOG_DBG("Queued 16-bit value 0x%04x to register 0x%02x on node %d, frame ID: %d",
|
||||
value, reg, node_id, *frame_id);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,13 +1,16 @@
|
|||
#ifndef __CANBUS_H__
|
||||
#define __CANBUS_H__
|
||||
|
||||
#include <zephyr/drivers/can.h>
|
||||
#include <zephyr/kernel.h>
|
||||
#include <stdint.h>
|
||||
#include "canbus_registers.h"
|
||||
|
||||
#define RX_THREAD_STACK_SIZE 512
|
||||
#define RX_THREAD_PRIORITY 2
|
||||
#define CANBUS_RX_THREAD_STACK_SIZE (512) // Stack size for the CAN RX thread
|
||||
#define CANBUS_RX_THREAD_PRIORITY (5) // Priority for the CAN RX thread
|
||||
#define CANBUS_RX_MSGQ_SIZE (5) // Size of the message queue for CAN RX thread
|
||||
#define CANBUS_TX_TIMEOUT K_MSEC(100) // Timeout for sending CAN messages in milliseconds
|
||||
|
||||
int canbus_init(void);
|
||||
int canbus_send_message(const struct can_frame *frame);
|
||||
int canbus_send8(uint16_t reg, uint8_t value);
|
||||
int canbus_send16(uint16_t reg, uint16_t value);
|
||||
|
||||
#endif // __CANBUS_H__
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
#ifndef __CANBUS_REGISTERS_H__
|
||||
#define __CANBUS_REGISTERS_H__
|
||||
|
||||
enum canbus_registers {
|
||||
CANBUS_REG_REBOOT = 0x00,
|
||||
CANBUS_REG_STATE = 0x01,
|
||||
CANBUS_REG_ERROR = 0x02,
|
||||
|
||||
CANBUS_REG_VALVE_STATUS = 0x10,
|
||||
CANBUS_REG_VALVE_OPERATION = 0x11,
|
||||
CANBUS_REG_VALVE_COMMAND = 0x12,
|
||||
|
||||
CANBUS_REG_WATERLEVEL_STATE = 0x20,
|
||||
CANBUS_REG_WATERLEVEL_LEVEL = 0x21,
|
||||
CANBUS_REG_WATERLEVEL_ZERO_POINT = 0x22,
|
||||
CANBUS_REG_WATERLEVEL_MAX_POINT = 0x23,
|
||||
};
|
||||
|
||||
enum valve_status {
|
||||
VALVE_STATE_CLOSED = 0x00,
|
||||
VALVE_STATE_OPEN = 0x01,
|
||||
VALVE_STATE_ERROR = 0x02,
|
||||
VALVE_STATE_UNKNOWN = 0x03,
|
||||
};
|
||||
|
||||
enum valve_operation_state {
|
||||
VALVE_OPERATION_IDLE = 0x00,
|
||||
VALVE_OPERATION_OPENING = 0x01,
|
||||
VALVE_OPERATION_CLOSING = 0x02,
|
||||
};
|
||||
|
||||
enum valve_command {
|
||||
VALVE_COMMAND_STOP = 0x00,
|
||||
VALVE_COMMAND_OPEN = 0x01,
|
||||
VALVE_COMMAND_CLOSE = 0x02,
|
||||
};
|
||||
|
||||
enum waterlevel_state {
|
||||
WATERLEVEL_STATE_OK = 0x00,
|
||||
WATERLEVEL_STATE_MODBUS_ERROR = 0x02,
|
||||
};
|
||||
#endif // __CANBUS_REGISTERS_H__
|
||||
|
|
@ -1,163 +0,0 @@
|
|||
#include "modbus.h"
|
||||
#include <zephyr/kernel.h>
|
||||
#include <zephyr/sys/util.h>
|
||||
#include <zephyr/modbus/modbus.h>
|
||||
#include <zephyr/logging/log.h>
|
||||
|
||||
LOG_MODULE_REGISTER(mbc, CONFIG_LOG_DEFAULT_LEVEL);
|
||||
|
||||
#define MODBUS_NODE DT_COMPAT_GET_ANY_STATUS_OKAY(zephyr_modbus_serial)
|
||||
|
||||
static int client_iface;
|
||||
|
||||
static struct
|
||||
{
|
||||
int level; // Water level value
|
||||
int minimum; // Minimum value
|
||||
int maximum; // Maximum value
|
||||
int factor; // Factor for unit conversion
|
||||
} measurement;
|
||||
|
||||
int mb_init_client(void)
|
||||
{
|
||||
const char iface_name[] = {DEVICE_DT_NAME(MODBUS_NODE)};
|
||||
client_iface = modbus_iface_get_by_name(iface_name);
|
||||
LOG_DBG("Modbus client interface: %d", client_iface);
|
||||
if (client_iface < 0)
|
||||
{
|
||||
LOG_ERR("Failed to get Modbus interface by name: %s", iface_name);
|
||||
return client_iface;
|
||||
}
|
||||
return modbus_init_client(client_iface, client_param);
|
||||
}
|
||||
|
||||
int mb_read_holding_registers(int node, uint16_t reg_addr, uint16_t *data, size_t len)
|
||||
{
|
||||
return modbus_read_holding_regs(client_iface, node, reg_addr, data, len);
|
||||
}
|
||||
|
||||
int mb_read()
|
||||
{
|
||||
int rc;
|
||||
int16_t data[5] = {0};
|
||||
rc = mb_read_holding_registers(1, 0x0002, data, sizeof(data) / sizeof(data[0]));
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to read holding registers: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
LOG_HEXDUMP_DBG(data, sizeof(data), "Holding Registers Data");
|
||||
|
||||
int unit, decimals;
|
||||
unit = data[0];
|
||||
decimals = data[1];
|
||||
int factor;
|
||||
switch (unit)
|
||||
{
|
||||
case 1: // cm
|
||||
factor = 10;
|
||||
break;
|
||||
case 2: // mm
|
||||
factor = 1;
|
||||
break;
|
||||
default:
|
||||
LOG_ERR("Unknown unit: %d", unit);
|
||||
return -EINVAL;
|
||||
}
|
||||
switch(decimals)
|
||||
{
|
||||
case 0: // no decimals
|
||||
factor /= 1;
|
||||
break;
|
||||
case 1: // one decimal
|
||||
factor /= 10;
|
||||
break;
|
||||
case 2: // two decimals
|
||||
factor /= 100;
|
||||
break;
|
||||
default:
|
||||
LOG_ERR("Unknown decimals: %d", decimals);
|
||||
return -EINVAL;
|
||||
}
|
||||
measurement.factor = factor;
|
||||
measurement.level = data[2] * factor;
|
||||
measurement.minimum = data[3] * factor;
|
||||
measurement.maximum = data[4] * factor;
|
||||
LOG_DBG("Water level: %dmm, Minimum: %dmm, Maximum: %dmm",
|
||||
measurement.level, measurement.minimum, measurement.maximum);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mb_read_water_level(double *mb_read_water_level)
|
||||
{
|
||||
int rc = mb_read();
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to read water level: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
*mb_read_water_level = (double)measurement.level / 1000.0; // Convert to meters
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mb_read_water_level_mm(int *mb_read_water_level)
|
||||
{
|
||||
int rc = mb_read();
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to read water level: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
*mb_read_water_level = measurement.level;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mb_read_minimum_mm(int *mb_read_minimum)
|
||||
{
|
||||
int rc = mb_read();
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to read water level: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
*mb_read_minimum = measurement.minimum;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mb_read_maximum_mm(int *mb_read_maximum)
|
||||
{
|
||||
int rc = mb_read();
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to read water level: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
*mb_read_maximum = measurement.maximum;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mb_write_minimum_mm(int minimum)
|
||||
{
|
||||
int rc = mb_read();
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to read water level: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
modbus_write_holding_reg(client_iface, 1, 0x0005, minimum / measurement.factor);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mb_write_maximum_mm(int maximum)
|
||||
{
|
||||
int rc = mb_read();
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to read water level: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
modbus_write_holding_reg(client_iface, 1, 0x0006, maximum / measurement.factor);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
#ifndef __waterlevel_h
|
||||
#define __waterlevel_h
|
||||
|
||||
#include <zephyr/modbus/modbus.h>
|
||||
|
||||
const static struct modbus_iface_param client_param = {
|
||||
.mode = MODBUS_MODE_RTU,
|
||||
.rx_timeout = 50000,
|
||||
.serial = {
|
||||
.baud = 9600,
|
||||
.parity = UART_CFG_PARITY_NONE,
|
||||
},
|
||||
};
|
||||
|
||||
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);
|
||||
int mb_read_water_level_mm(int *mb_read_water_level_mm);
|
||||
int mb_read_minimum_mm(int *mb_read_minimum);
|
||||
int mb_read_maximum_mm(int *mb_read_maximum);
|
||||
int mb_write_minimum_mm(int minimum);
|
||||
int mb_write_maximum_mm(int maximum);
|
||||
|
||||
#endif
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
#ifndef __SETTINGS_H__
|
||||
#define __SETTINGS_H__
|
||||
|
||||
#include <zephyr/settings/settings.h>
|
||||
|
||||
#include <errno.h>
|
||||
#include <zephyr/sys/printk.h>
|
||||
|
||||
#if defined(CONFIG_SETTINGS_FILE)
|
||||
#include <zephyr/fs/fs.h>
|
||||
#include <zephyr/fs/littlefs.h>
|
||||
#endif
|
||||
|
||||
#define STORAGE_PARTITION storage_partition
|
||||
#define STORAGE_PARTITION_ID FIXED_PARTITION_ID(STORAGE_PARTITION)
|
||||
|
||||
#endif // __SETTINGS_H__
|
||||
|
|
@ -0,0 +1,163 @@
|
|||
#include <zephyr/kernel.h>
|
||||
#include <zephyr/logging/log.h>
|
||||
|
||||
#include "canbus.h"
|
||||
#include "canbus_registers.h"
|
||||
#include "valve.h"
|
||||
|
||||
LOG_MODULE_REGISTER(valve, CONFIG_LOG_VALVE_LEVEL);
|
||||
|
||||
K_THREAD_STACK_DEFINE(valve_thread_stack, VALVE_THREAD_STACK_SIZE);
|
||||
K_MSGQ_DEFINE(valve_msgq, sizeof(int), VALVE_MSGQ_SIZE, 4);
|
||||
|
||||
k_tid_t valve_thread_id;
|
||||
struct k_thread valve_thread_data;
|
||||
|
||||
valve_status_t valve_status_data = {
|
||||
.valve_state = VALVE_STATE_UNKNOWN,
|
||||
.valve_operation = VALVE_OPERATION_IDLE,
|
||||
};
|
||||
|
||||
int valve_start_thread(void)
|
||||
{
|
||||
int rc;
|
||||
|
||||
// Initialize the valve
|
||||
rc = valve_init();
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to initialize valve: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
|
||||
// Create the valve thread
|
||||
valve_thread_id = k_thread_create(&valve_thread_data, valve_thread_stack,
|
||||
K_THREAD_STACK_SIZEOF(valve_thread_stack),
|
||||
(k_thread_entry_t)valve_cmd, NULL, NULL, NULL,
|
||||
VALVE_THREAD_PRIORITY, 0, K_NO_WAIT);
|
||||
k_thread_name_set(valve_thread_id, "valve");
|
||||
|
||||
LOG_INF("Valve thread started successfully");
|
||||
while (1)
|
||||
{
|
||||
// Wait for commands from the message queue
|
||||
int cmd;
|
||||
rc = k_msgq_get(&valve_msgq, &cmd, VALVE_STATE_INTERVAL);
|
||||
if (rc == 0)
|
||||
{
|
||||
// Process the command
|
||||
rc = valve_cmd(cmd);
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to process valve command: %d", rc);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
valve_send_status(); // Send current valve status periodically
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int valve_init(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int valve_cmd(int cmd)
|
||||
{
|
||||
switch (cmd)
|
||||
{
|
||||
case VALVE_COMMAND_OPEN:
|
||||
if (valve_status_data.valve_state != VALVE_STATE_OPEN)
|
||||
{
|
||||
valve_status_data.valve_state = VALVE_STATE_OPEN;
|
||||
valve_status_data.valve_operation = VALVE_OPERATION_OPENING;
|
||||
valve_send_status(); // Send updated status before opening
|
||||
valve_send_operation(); // Send updated operation state before opening
|
||||
k_sleep(VALVE_OPENING_TIME); // Simulate opening time
|
||||
valve_status_data.valve_operation = VALVE_OPERATION_IDLE; // Set operation to idle after opening
|
||||
valve_send_status(); // Send updated status after opening
|
||||
valve_send_operation(); // Send updated operation state after opening
|
||||
}
|
||||
break;
|
||||
case VALVE_COMMAND_CLOSE:
|
||||
if (valve_status_data.valve_state != VALVE_STATE_CLOSED)
|
||||
{
|
||||
valve_status_data.valve_operation = VALVE_OPERATION_CLOSING;
|
||||
valve_send_operation(); // Send updated operation state before closing
|
||||
k_sleep(VALVE_CLOSING_TIME); // Simulate closing time
|
||||
valve_status_data.valve_state = VALVE_STATE_CLOSED; // Set valve state to closed after closing
|
||||
valve_status_data.valve_operation = VALVE_OPERATION_IDLE; // Set operation to idle after closing
|
||||
valve_send_status(); // Send updated status after closing
|
||||
valve_send_operation(); // Send updated operation state after closing
|
||||
}
|
||||
break;
|
||||
case VALVE_COMMAND_STOP:
|
||||
valve_status_data.valve_operation = VALVE_OPERATION_IDLE;
|
||||
break;
|
||||
default:
|
||||
LOG_ERR("Unknown valve command: %d", cmd);
|
||||
return -EINVAL; // Invalid command
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int valve_send_status(void)
|
||||
{
|
||||
int rc = canbus_send8(CANBUS_REG_VALVE_STATUS, valve_status_data.valve_state);
|
||||
if (rc != 0)
|
||||
{
|
||||
LOG_ERR("Failed to send valve status: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
char *state_str;
|
||||
switch (valve_status_data.valve_state)
|
||||
{
|
||||
case VALVE_STATE_CLOSED:
|
||||
state_str = "CLOSED";
|
||||
break;
|
||||
case VALVE_STATE_OPEN:
|
||||
state_str = "OPEN";
|
||||
break;
|
||||
case VALVE_STATE_ERROR:
|
||||
state_str = "ERROR";
|
||||
break;
|
||||
case VALVE_STATE_UNKNOWN:
|
||||
state_str = "UNKNOWN";
|
||||
break;
|
||||
default:
|
||||
state_str = "INVALID";
|
||||
break;
|
||||
}
|
||||
LOG_INF("Valve status sent: %s", state_str);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int valve_send_operation(void)
|
||||
{
|
||||
int rc = canbus_send8(CANBUS_REG_VALVE_OPERATION, valve_status_data.valve_operation);
|
||||
if (rc != 0)
|
||||
{
|
||||
LOG_ERR("Failed to send valve operation: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
char *operation_str;
|
||||
switch (valve_status_data.valve_operation)
|
||||
{
|
||||
case VALVE_OPERATION_IDLE:
|
||||
operation_str = "IDLE";
|
||||
break;
|
||||
case VALVE_OPERATION_OPENING:
|
||||
operation_str = "OPENING";
|
||||
break;
|
||||
case VALVE_OPERATION_CLOSING:
|
||||
operation_str = "CLOSING";
|
||||
break;
|
||||
default:
|
||||
operation_str = "UNKNOWN";
|
||||
break;
|
||||
}
|
||||
LOG_INF("Valve operation sent: %s", operation_str);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#ifndef __VALVE_H__
|
||||
#define __VALVE_H__
|
||||
|
||||
#define VALVE_OPENING_TIME K_MSEC(4500) // Time to open the valve
|
||||
#define VALVE_CLOSING_TIME K_MSEC(4500) // Time to close the valve
|
||||
#define VALVE_MAX_OPENING_TIME K_MSEC(5000) // Maximum time to open the valve
|
||||
#define VALVE_MAX_CLOSING_TIME K_MSEC(5000) // Maximum time to close the valve
|
||||
#define VALVE_STATE_INTERVAL K_SECONDS(5 * 60) // Interval to check the valve state
|
||||
#define VALVE_THREAD_STACK_SIZE (512) // Stack size for the valve thread
|
||||
#define VALVE_THREAD_PRIORITY (2) // Priority for the valve thread
|
||||
#define VALVE_MSGQ_SIZE (5) // Size of the message queue for valve operations
|
||||
|
||||
#include <stdint.h>
|
||||
#include "canbus_registers.h"
|
||||
|
||||
typedef struct {
|
||||
uint8_t valve_state;
|
||||
uint8_t valve_operation;
|
||||
} valve_status_t;
|
||||
|
||||
int valve_init(void);
|
||||
int valve_cmd(int cmd);
|
||||
int valve_send_status(void);
|
||||
int valve_send_operation(void);
|
||||
|
||||
|
||||
#endif // __VALVE_H__
|
||||
|
|
@ -0,0 +1,384 @@
|
|||
#include "waterlevel_sensor.h"
|
||||
#include <zephyr/kernel.h>
|
||||
#include <zephyr/logging/log.h>
|
||||
#include <zephyr/modbus/modbus.h>
|
||||
#include <stdlib.h>
|
||||
#include "canbus.h"
|
||||
|
||||
LOG_MODULE_REGISTER(wls, CONFIG_LOG_WATERLEVELSENSOR_LEVEL);
|
||||
|
||||
#define MODBUS_NODE DT_COMPAT_GET_ANY_STATUS_OKAY(zephyr_modbus_serial)
|
||||
|
||||
struct k_thread waterlevel_sensor_thread_data;
|
||||
K_THREAD_STACK_DEFINE(waterlevel_sensor_stack, WATERLEVEL_SENSOR_STACK_SIZE);
|
||||
K_MSGQ_DEFINE(waterlevel_sensor_msgq, sizeof(waterlevel_command_t), WATERLEVEL_MESSAGE_QUEUE_SIZE, 4);
|
||||
|
||||
static int modbus_client_iface;
|
||||
|
||||
volatile static struct
|
||||
{
|
||||
int level; // Water level value
|
||||
int zeropoint; // Minimum value
|
||||
int maxpoint; // Maximum value
|
||||
int factor; // Factor for unit conversion
|
||||
bool factor_set; // Flag to indicate if factor is set
|
||||
} waterlevel_measurement = {
|
||||
.factor_set = false,
|
||||
};
|
||||
|
||||
struct modbus_iface_param client_param = {
|
||||
.mode = MODBUS_MODE_RTU,
|
||||
.rx_timeout = 50000, // Timeout for receiving data in milliseconds
|
||||
.serial = {
|
||||
.baud = 9600,
|
||||
.parity = UART_CFG_PARITY_NONE,
|
||||
.stop_bits_client = UART_CFG_STOP_BITS_1, // 1 stop bit for Modbus RTU
|
||||
},
|
||||
};
|
||||
|
||||
static int waterlevel_modbus_init() {
|
||||
const char iface_name[] = {DEVICE_DT_NAME(MODBUS_NODE)};
|
||||
modbus_client_iface = modbus_iface_get_by_name(iface_name);
|
||||
if (modbus_client_iface < 0)
|
||||
{
|
||||
LOG_ERR("Failed to get Modbus interface by name: %s", iface_name);
|
||||
return modbus_client_iface;
|
||||
}
|
||||
LOG_DBG("Initializing modbus client interface: %s", iface_name);
|
||||
return modbus_init_client(modbus_client_iface, client_param);
|
||||
}
|
||||
|
||||
static int waterlevel_modbus_read(void) {
|
||||
int rc;
|
||||
union
|
||||
{
|
||||
struct
|
||||
{
|
||||
int16_t unit; // Unit of measurement (e.g., cm, mm)
|
||||
int16_t decimals; // Number of decimal places for the measurement
|
||||
int16_t level; // Water level value
|
||||
int16_t zeropoint; // Zero point for the measurement
|
||||
int16_t maxpoint; // Maximum point for the measurement
|
||||
};
|
||||
int16_t data[5]; // Data array for holding registers
|
||||
} waterlevel_modbus_data;
|
||||
rc = modbus_read_holding_regs(modbus_client_iface, WATERLEVEL_SENSOR_MODBUS_NODE_ID, 0x0002, waterlevel_modbus_data.data, sizeof(waterlevel_modbus_data.data) / sizeof(waterlevel_modbus_data.data[0]));
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to read holding registers, node <%d>, returncode: %d", WATERLEVEL_SENSOR_MODBUS_NODE_ID, rc);
|
||||
return rc;
|
||||
}
|
||||
|
||||
LOG_DBG("Got values. Unit: %d, Decimals: %d, Level: %d, Zero Point: %d, Max Point: %d",
|
||||
waterlevel_modbus_data.unit,
|
||||
waterlevel_modbus_data.decimals,
|
||||
waterlevel_modbus_data.level,
|
||||
waterlevel_modbus_data.zeropoint,
|
||||
waterlevel_modbus_data.maxpoint);
|
||||
|
||||
LOG_HEXDUMP_DBG(waterlevel_modbus_data.data, sizeof(waterlevel_modbus_data.data), "Waterlevel Sensor Holding Registers Data");
|
||||
|
||||
switch (waterlevel_modbus_data.unit)
|
||||
{
|
||||
case 1: // cm
|
||||
waterlevel_measurement.factor = 10;
|
||||
break;
|
||||
case 2: // mm
|
||||
waterlevel_measurement.factor = 1;
|
||||
break;
|
||||
default:
|
||||
LOG_ERR("Unknown unit: %d", waterlevel_modbus_data.unit);
|
||||
waterlevel_measurement.factor_set = false;
|
||||
return -EINVAL;
|
||||
}
|
||||
switch (waterlevel_modbus_data.decimals)
|
||||
{
|
||||
case 0: // no decimals
|
||||
waterlevel_measurement.factor /= 1;
|
||||
break;
|
||||
case 1: // one decimal
|
||||
waterlevel_measurement.factor /= 10;
|
||||
break;
|
||||
case 2: // two decimals
|
||||
waterlevel_measurement.factor /= 100;
|
||||
break;
|
||||
default:
|
||||
LOG_ERR("Unknown decimals: %d", waterlevel_modbus_data.decimals);
|
||||
waterlevel_measurement.factor_set = false;
|
||||
return -EINVAL;
|
||||
}
|
||||
waterlevel_measurement.factor_set = true;
|
||||
waterlevel_measurement.level = waterlevel_modbus_data.level * waterlevel_measurement.factor;
|
||||
waterlevel_measurement.zeropoint = waterlevel_modbus_data.zeropoint * waterlevel_measurement.factor;
|
||||
waterlevel_measurement.maxpoint = waterlevel_modbus_data.maxpoint * waterlevel_measurement.factor;
|
||||
|
||||
LOG_DBG("Water level: %dmm, zero point: %dmm, maximum point: %dmm",
|
||||
waterlevel_measurement.level,
|
||||
waterlevel_measurement.zeropoint,
|
||||
waterlevel_measurement.maxpoint);
|
||||
LOG_HEXDUMP_DBG(waterlevel_modbus_data.data, sizeof(waterlevel_modbus_data.data), "Waterlevel Sensor Holding Registers Data");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int waterlevel_send_level(void) {
|
||||
if (!waterlevel_measurement.factor_set) {
|
||||
LOG_ERR("Factor not set, cannot send water level");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
LOG_INF("Sending water level: %dmm", waterlevel_measurement.level);
|
||||
canbus_send16(CANBUS_REG_WATERLEVEL_LEVEL, waterlevel_measurement.level);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int waterlevel_send_zero_point(void) {
|
||||
if (!waterlevel_measurement.factor_set) {
|
||||
LOG_ERR("Factor not set, cannot send zero point");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
LOG_INF("Sending water zero point: %dmm", waterlevel_measurement.zeropoint);
|
||||
canbus_send16(CANBUS_REG_WATERLEVEL_ZERO_POINT, waterlevel_measurement.zeropoint);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int waterlevel_send_max_point(void) {
|
||||
if (!waterlevel_measurement.factor_set) {
|
||||
LOG_ERR("Factor not set, cannot send maximum point");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
LOG_INF("Sending water maximum point: %dmm", waterlevel_measurement.maxpoint);
|
||||
canbus_send16(CANBUS_REG_WATERLEVEL_MAX_POINT, waterlevel_measurement.maxpoint);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int waterlevel_set_zero_point(int zeropoint) {
|
||||
if (!waterlevel_measurement.factor_set) {
|
||||
LOG_ERR("Factor not set, cannot set zero point");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
int16_t zeropoint_modbus = zeropoint / waterlevel_measurement.factor;
|
||||
int rc = modbus_write_holding_regs(modbus_client_iface, WATERLEVEL_SENSOR_MODBUS_NODE_ID, 0x0005, &zeropoint_modbus, 1);
|
||||
if (rc < 0) {
|
||||
LOG_ERR("Failed to write zero point: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
|
||||
waterlevel_measurement.zeropoint = zeropoint; // Update the local measurement structure
|
||||
LOG_INF("Zero point set to: %dmm", waterlevel_measurement.zeropoint);
|
||||
rc = waterlevel_send_zero_point();
|
||||
if (rc < 0) {
|
||||
LOG_ERR("Failed to send zero point: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int waterlevel_set_max_point(int maxpoint) {
|
||||
if (!waterlevel_measurement.factor_set) {
|
||||
LOG_ERR("Factor not set, cannot set maximum point");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
int16_t maxpoint_modbus = maxpoint / waterlevel_measurement.factor;
|
||||
int rc = modbus_write_holding_regs(modbus_client_iface, WATERLEVEL_SENSOR_MODBUS_NODE_ID, 0x0006, &maxpoint_modbus, 1);
|
||||
if (rc < 0) {
|
||||
LOG_ERR("Failed to write maximum point: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
|
||||
waterlevel_measurement.maxpoint = maxpoint; // Update the local measurement structure
|
||||
LOG_INF("Maximum point set to: %dmm", waterlevel_measurement.maxpoint);
|
||||
rc = waterlevel_send_max_point();
|
||||
if (rc < 0) {
|
||||
LOG_ERR("Failed to send maximum point: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void waterlevel_sensor_thread(void *arg1, void *arg2, void *arg3)
|
||||
{
|
||||
ARG_UNUSED(arg1);
|
||||
ARG_UNUSED(arg2);
|
||||
ARG_UNUSED(arg3);
|
||||
|
||||
// Initialize the Modbus client
|
||||
int rc = waterlevel_modbus_init();
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to initialize Modbus client: %d", rc);
|
||||
return;
|
||||
}
|
||||
|
||||
rc = waterlevel_modbus_read();
|
||||
if (rc < 0) {
|
||||
LOG_ERR("Failed to read initial water level: %d", rc);
|
||||
return;
|
||||
}
|
||||
waterlevel_send_level();
|
||||
waterlevel_send_zero_point();
|
||||
waterlevel_send_max_point();
|
||||
|
||||
// Initialize the last transmission time and level
|
||||
// Use k_uptime_get_32() to get the current uptime in milliseconds
|
||||
// and store the initial water level measurement.
|
||||
// This will be used to determine when to send updates.
|
||||
|
||||
uint32_t last_transmission_time_ms = k_uptime_get_32();
|
||||
int32_t last_transmission_level = waterlevel_measurement.level;
|
||||
|
||||
while (1)
|
||||
{
|
||||
uint32_t current_time_ms = k_uptime_get_32();
|
||||
uint32_t delta_time = current_time_ms-last_transmission_time_ms;
|
||||
waterlevel_command_t command;
|
||||
|
||||
rc = waterlevel_modbus_read();
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to read water level: %d", rc);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (delta_time >= WATERLEVEL_SENSOR_MAX_UPDATE_INTERVAL_MS ||
|
||||
abs(waterlevel_measurement.level - last_transmission_level) >= WATERLEVEL_SENSOR_MIN_DELTA) {
|
||||
rc = waterlevel_send_level();
|
||||
if (rc < 0) {
|
||||
LOG_ERR("Failed to send water level: %d", rc);
|
||||
} else {
|
||||
last_transmission_time_ms = current_time_ms;
|
||||
last_transmission_level = waterlevel_measurement.level;
|
||||
}
|
||||
}
|
||||
|
||||
while (k_msgq_get(&waterlevel_sensor_msgq, &command, K_NO_WAIT) == 0)
|
||||
{
|
||||
switch(command.cmd)
|
||||
{
|
||||
case WATERLEVEL_CMD_SET:
|
||||
switch (command.reg)
|
||||
{
|
||||
case CANBUS_REG_WATERLEVEL_ZERO_POINT: // Set zero point
|
||||
rc = waterlevel_set_zero_point(command.data);
|
||||
if (rc < 0) {
|
||||
LOG_ERR("Failed to set zero point: %d", rc);
|
||||
}
|
||||
break;
|
||||
case CANBUS_REG_WATERLEVEL_MAX_POINT: // Set maximum point
|
||||
rc = waterlevel_set_max_point(command.data);
|
||||
if (rc < 0) {
|
||||
LOG_ERR("Failed to set maximum point: %d", rc);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
LOG_ERR("Unknown register for SET command: 0x%02X", command.reg);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case WATERLEVEL_CMD_GET:
|
||||
switch (command.reg)
|
||||
{
|
||||
case CANBUS_REG_WATERLEVEL_LEVEL: // Get water level
|
||||
waterlevel_send_level();
|
||||
break;
|
||||
case CANBUS_REG_WATERLEVEL_ZERO_POINT: // Get zero point
|
||||
waterlevel_send_zero_point();
|
||||
break;
|
||||
case CANBUS_REG_WATERLEVEL_MAX_POINT: // Get maximum point
|
||||
waterlevel_send_max_point();
|
||||
break;
|
||||
default:
|
||||
LOG_ERR("Unknown register for GET command: 0x%02X", command.reg);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
LOG_ERR("Unknown command type: %d", command.cmd);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int waterlevel_sensor_start_thread(void)
|
||||
{
|
||||
k_tid_t waterlevel_sensor_thread_id;
|
||||
|
||||
// Start the thread
|
||||
waterlevel_sensor_thread_id = k_thread_create(&waterlevel_sensor_thread_data, waterlevel_sensor_stack,
|
||||
K_THREAD_STACK_SIZEOF(waterlevel_sensor_stack), waterlevel_sensor_thread,
|
||||
NULL, NULL, NULL,
|
||||
WATERLEVEL_SENSOR_THREAD_PRIORITY, 0, K_NO_WAIT);
|
||||
|
||||
if (waterlevel_sensor_thread_id == NULL)
|
||||
{
|
||||
LOG_ERR("Failed to create water level sensor thread");
|
||||
return -ENOMEM;
|
||||
}
|
||||
k_thread_name_set(waterlevel_sensor_thread_id, "waterlevel_sensor");
|
||||
|
||||
LOG_INF("Water level sensor thread started successfully");
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_SHELL
|
||||
#include <zephyr/shell/shell.h>
|
||||
|
||||
void waterlevel_set_zero_point_shell(const struct shell *shell, size_t argc, char **argv) {
|
||||
if (argc != 2) {
|
||||
shell_error(shell, "Usage: waterlevel_sensor set_zero_point <zeropoint>");
|
||||
return;
|
||||
}
|
||||
|
||||
int zeropoint = atoi(argv[1]);
|
||||
int rc = waterlevel_set_zero_point(zeropoint);
|
||||
if (rc < 0) {
|
||||
shell_error(shell, "Failed to set zero point: %d", rc);
|
||||
} else {
|
||||
shell_print(shell, "Zero point set to: %dmm", zeropoint);
|
||||
}
|
||||
}
|
||||
|
||||
void waterlevel_set_max_point_shell(const struct shell *shell, size_t argc, char **argv) {
|
||||
if (argc != 2) {
|
||||
shell_error(shell, "Usage: waterlevel_sensor set_max_point <maxpoint>");
|
||||
return;
|
||||
}
|
||||
|
||||
int maxpoint = atoi(argv[1]);
|
||||
int rc = waterlevel_set_max_point(maxpoint);
|
||||
if (rc < 0) {
|
||||
shell_error(shell, "Failed to set maximum point: %d", rc);
|
||||
} else {
|
||||
shell_print(shell, "Maximum point set to: %dmm", maxpoint);
|
||||
}
|
||||
}
|
||||
|
||||
void waterlevel_sensor_print_shell(const struct shell *shell, size_t argc, char **argv) {
|
||||
ARG_UNUSED(argc);
|
||||
ARG_UNUSED(argv);
|
||||
|
||||
waterlevel_modbus_read();
|
||||
if (!waterlevel_measurement.factor_set) {
|
||||
shell_error(shell, "Factor not set, cannot print water level");
|
||||
return;
|
||||
}
|
||||
|
||||
shell_print(shell, "Current water level: %4dmm", waterlevel_measurement.level);
|
||||
shell_print(shell, "Zero point: %4dmm", waterlevel_measurement.zeropoint);
|
||||
shell_print(shell, "Maximum point: %4dmm", waterlevel_measurement.maxpoint);
|
||||
}
|
||||
|
||||
// Define the shell commands for the water level sensor
|
||||
SHELL_STATIC_SUBCMD_SET_CREATE(
|
||||
waterlevel_sensor_cmds,
|
||||
SHELL_CMD(print, NULL, "Print the current water level, zero point, and maximum point", waterlevel_sensor_print_shell),
|
||||
SHELL_CMD(setzero, NULL, "Set the zero point for the water level sensor", waterlevel_set_zero_point_shell),
|
||||
SHELL_CMD(setmax, NULL, "Set the maximum point for the water level sensor", waterlevel_set_max_point_shell),
|
||||
SHELL_SUBCMD_SET_END);
|
||||
|
||||
SHELL_CMD_REGISTER(wls, &waterlevel_sensor_cmds, "Water level sensor commands", NULL);
|
||||
#endif // CONFIG_SHELL
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#ifndef __WATERLEVEL_SENSOR_H__
|
||||
#define __WATERLEVEL_SENSOR_H__
|
||||
|
||||
#define WATERLEVEL_SENSOR_STACK_SIZE (512)
|
||||
#define WATERLEVEL_SENSOR_THREAD_PRIORITY (2)
|
||||
#define WATERLEVEL_MESSAGE_QUEUE_SIZE (5) // Size of the message queue for water level sensor thread
|
||||
#define WATERLEVEL_SENSOR_READ_INTERVAL_MS (5000) // Interval for reading the water level sensor in milliseconds
|
||||
#define WATERLEVEL_SENSOR_MIN_DELTA (2) // Minimum change in water level to trigger an update
|
||||
#define WATERLEVEL_SENSOR_MAX_UPDATE_INTERVAL_MS (600000) // Maximum interval for updating the water level in milliseconds
|
||||
|
||||
#define WATERLEVEL_SENSOR_MODBUS_NODE_ID (0x01) // Modbus node ID for the water level sensor
|
||||
#define WATERLEVEL_SENSOR_MODBUS_BAUD_RATE (9600) // Baud rate for Modbus communication
|
||||
|
||||
#include <inttypes.h>
|
||||
|
||||
int waterlevel_sensor_start_thread(void);
|
||||
|
||||
typedef struct {
|
||||
uint8_t reg;
|
||||
enum {
|
||||
WATERLEVEL_CMD_SET,
|
||||
WATERLEVEL_CMD_GET,
|
||||
} cmd;
|
||||
int16_t data; // Data to be set
|
||||
} waterlevel_command_t;
|
||||
|
||||
#endif // __WATERLEVEL_SENSOR_H__
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
CONFIG_HAS_MODBUS_WATERLEVEL_SENSOR=y
|
||||
CONFIG_HAS_VALVE=y
|
||||
|
||||
CONFIG_LOG=y
|
||||
CONFIG_LOG_DEFAULT_LEVEL=3
|
||||
# CONFIG_LOG_CAN_LEVEL=4
|
||||
# CONFIG_LOG_WATERLEVELSENSOR_LEVEL=4
|
||||
# CONFIG_LOG_VALVE_LEVEL=4
|
||||
CONFIG_CBPRINTF_FP_SUPPORT=y
|
||||
CONFIG_UART_CONSOLE=y # Console on USART1
|
||||
|
||||
# CAN loopback mode for testing
|
||||
#CONFIG_LOOPBACK_MODE=y
|
||||
CONFIG_SHELL=y
|
||||
CONFIG_CAN_SHELL=y
|
||||
CONFIG_GPIO_SHELL=y
|
||||
CONFIG_REBOOT=y
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include <zephyr/logging/log.h>
|
||||
#include <zephyr/kernel.h>
|
||||
#include <zephyr/sys/byteorder.h>
|
||||
#include <zephyr/shell/shell.h>
|
||||
#include "canbus.h"
|
||||
#include "canbus_registers.h"
|
||||
|
||||
#ifdef CONFIG_HAS_MODBUS_WATERLEVEL_SENSOR
|
||||
// Include the water level sensor header file when the feature is enabled
|
||||
#include "waterlevel_sensor.h"
|
||||
#endif // CONFIG_HAS_MODBUS_WATERLEVEL_SENSOR
|
||||
|
||||
#ifdef CONFIG_HAS_VALVE
|
||||
#include "valve.h"
|
||||
#endif // CONFIG_HAS_VALVE
|
||||
|
||||
LOG_MODULE_REGISTER(main, CONFIG_LOG_DEFAULT_LEVEL);
|
||||
|
||||
int main(void)
|
||||
{
|
||||
LOG_INF("Starting main application...");
|
||||
canbus_init();
|
||||
k_sleep(K_MSEC(3000)); // Allow some time for CAN initialization
|
||||
#ifdef CONFIG_HAS_MODBUS_WATERLEVEL_SENSOR
|
||||
int rc = waterlevel_sensor_start_thread();
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to start water level sensor thread: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
#endif // CONFIG_HAS_MODBUS_WATERLEVEL_SENSOR
|
||||
|
||||
valve_cmd(VALVE_COMMAND_CLOSE); // Ensure the valve is closed at startup
|
||||
|
||||
LOG_INF("Main application started successfully.");
|
||||
return 0; // Return 0 on success
|
||||
}
|
||||
|
||||
#ifdef CONFIG_SHELL
|
||||
#include <zephyr/shell/shell.h>
|
||||
#include <zephyr/sys/reboot.h>
|
||||
|
||||
static int reboot_shell_cmd(const struct shell *shell, size_t argc, char **argv)
|
||||
{
|
||||
ARG_UNUSED(argc);
|
||||
ARG_UNUSED(argv);
|
||||
shell_print(shell, "Rebooting the node in 1 second...");
|
||||
k_sleep(K_SECONDS(1));
|
||||
sys_reboot(SYS_REBOOT_COLD);
|
||||
return 0;
|
||||
}
|
||||
SHELL_CMD_REGISTER(reboot, NULL, "Reboot the node", reboot_shell_cmd);
|
||||
#endif // CONFIG_SHELL
|
||||
|
|
@ -1 +0,0 @@
|
|||
build
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
{
|
||||
"configurations": [
|
||||
{
|
||||
"name": "Win32",
|
||||
"includePath": [
|
||||
"${workspaceFolder}/**"
|
||||
],
|
||||
"defines": [
|
||||
"_DEBUG",
|
||||
"UNICODE",
|
||||
"_UNICODE"
|
||||
]
|
||||
}
|
||||
],
|
||||
"version": 4
|
||||
}
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
# SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
cmake_minimum_required(VERSION 3.20.0)
|
||||
|
||||
list(APPEND BOARD_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/..)
|
||||
|
||||
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
|
||||
project(hello_world)
|
||||
|
||||
target_sources(app PRIVATE src/main.c)
|
||||
target_sources(app PRIVATE ../lib/canbus.c)
|
||||
target_include_directories(app PRIVATE
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/../lib
|
||||
)
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
&usart1 {
|
||||
status = "okay";
|
||||
current-speed = <9600>;
|
||||
modbus0 {
|
||||
compatible = "zephyr,modbus-serial";
|
||||
status = "okay";
|
||||
// de-gpios = <&arduino_header 15 GPIO_ACTIVE_LOW>; /* D9 */
|
||||
};
|
||||
};
|
||||
|
|
@ -1,10 +0,0 @@
|
|||
CONFIG_LOG=y
|
||||
CONFIG_LOG_DEFAULT_LEVEL=3
|
||||
CONFIG_CBPRINTF_FP_SUPPORT=y
|
||||
|
||||
CONFIG_UART_CONSOLE=y # Console on USART1
|
||||
#CONFIG_RTT_CONSOLE=y
|
||||
#CONFIG_USE_SEGGER_RTT=y
|
||||
|
||||
CONFIG_LOOPBACK_MODE=y
|
||||
CONFIG_LOG_CAN_LEVEL=4
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
/* Testing MODBUS functionality
|
||||
This code initializes a Modbus client, sets the zero point and the 2m point for water level,
|
||||
and reads the water level in both meters and millimeters.
|
||||
It uses the Zephyr RTOS and its Modbus library to communicate with a Modbus server.
|
||||
*/
|
||||
|
||||
#include <zephyr/logging/log.h>
|
||||
#include <zephyr/kernel.h>
|
||||
#include <zephyr/drivers/gpio.h>
|
||||
|
||||
#include "canbus.h"
|
||||
|
||||
LOG_MODULE_REGISTER(main, CONFIG_LOG_DEFAULT_LEVEL);
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int rc;
|
||||
rc = canbus_init();
|
||||
if (rc != 0)
|
||||
{
|
||||
LOG_ERR("Failed to initialize CAN bus: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
LOG_INF("CAN bus initialized successfully");
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1 +0,0 @@
|
|||
build
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
{
|
||||
"configurations": [
|
||||
{
|
||||
"name": "Win32",
|
||||
"includePath": [
|
||||
"${workspaceFolder}/**"
|
||||
],
|
||||
"defines": [
|
||||
"_DEBUG",
|
||||
"UNICODE",
|
||||
"_UNICODE"
|
||||
]
|
||||
}
|
||||
],
|
||||
"version": 4
|
||||
}
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
# SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
cmake_minimum_required(VERSION 3.20.0)
|
||||
|
||||
list(APPEND BOARD_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/..)
|
||||
|
||||
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
|
||||
project(hello_world)
|
||||
|
||||
target_sources(app PRIVATE src/main.c)
|
||||
target_sources(app PRIVATE ../lib/modbus.c)
|
||||
target_include_directories(app PRIVATE
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/../lib
|
||||
)
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
&usart1 {
|
||||
status = "okay";
|
||||
current-speed = <9600>;
|
||||
modbus0 {
|
||||
compatible = "zephyr,modbus-serial";
|
||||
status = "okay";
|
||||
// de-gpios = <&arduino_header 15 GPIO_ACTIVE_LOW>; /* D9 */
|
||||
};
|
||||
};
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
CONFIG_LOG=y
|
||||
CONFIG_LOG_DEFAULT_LEVEL=3
|
||||
CONFIG_CBPRINTF_FP_SUPPORT=y
|
||||
|
||||
CONFIG_UART_CONSOLE=y # Console on USART1
|
||||
#CONFIG_RTT_CONSOLE=y
|
||||
#CONFIG_USE_SEGGER_RTT=y
|
||||
|
|
@ -1,78 +0,0 @@
|
|||
/* Testing MODBUS functionality
|
||||
This code initializes a Modbus client, sets the zero point and the 2m point for water level,
|
||||
and reads the water level in both meters and millimeters.
|
||||
It uses the Zephyr RTOS and its Modbus library to communicate with a Modbus server.
|
||||
*/
|
||||
|
||||
#include <zephyr/logging/log.h>
|
||||
#include <zephyr/kernel.h>
|
||||
#include <zephyr/drivers/gpio.h>
|
||||
|
||||
#include "modbus.h"
|
||||
|
||||
LOG_MODULE_REGISTER(main, CONFIG_LOG_DEFAULT_LEVEL);
|
||||
|
||||
/* 1000 msec = 1 sec */
|
||||
#define SLEEP_TIME_MS 1000
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int rc;
|
||||
|
||||
rc = mb_init_client();
|
||||
if (rc != 0)
|
||||
{
|
||||
LOG_ERR("Failed to initialize Modbus client: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
LOG_INF("Modbus client initialized successfully");
|
||||
|
||||
double water_level = 0.0;
|
||||
int water_level_mm, water_level_min_mm, water_level_max_mm = 0;
|
||||
|
||||
rc = mb_write_minimum_mm(42); // Set the zero point for water level
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to write minimum water level: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
rc = mb_write_maximum_mm(2000); // Set the 2m point for water level
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to write maximum water level: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
rc = mb_read_minimum_mm(&water_level_min_mm);
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to read minimum water level: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
rc = mb_read_maximum_mm(&water_level_max_mm);
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to read maximum water level: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
LOG_INF("Water zero point is set to: %dmm", water_level_min_mm);
|
||||
LOG_INF("Water 2m point is set to: %dmm", water_level_max_mm);
|
||||
|
||||
/* Read water level */
|
||||
rc = mb_read_water_level(&water_level);
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to read water level: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
rc = mb_read_water_level_mm(&water_level_mm);
|
||||
if (rc < 0)
|
||||
{
|
||||
LOG_ERR("Failed to read water level: %d", rc);
|
||||
return rc;
|
||||
}
|
||||
LOG_INF("Water level: %.3fm", water_level);
|
||||
LOG_INF("Water level: %dmm", water_level_mm);
|
||||
LOG_INF("Modbus test completed successfully");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,132 @@
|
|||
{
|
||||
"folders": [
|
||||
{
|
||||
"path": "."
|
||||
}
|
||||
],
|
||||
"settings": {
|
||||
// Hush CMake
|
||||
"cmake.configureOnOpen": false,
|
||||
|
||||
// IntelliSense
|
||||
"C_Cpp.default.compilerPath": "${userHome}/zephyr-sdk-0.17.1/arm-zephyr-eabi/bin/arm-zephyr-eabi-gcc",
|
||||
"C_Cpp.default.compileCommands": "${workspaceFolder}/build/compile_commands.json",
|
||||
|
||||
// File Associations
|
||||
"files.associations": {
|
||||
"waterlevel_sensor.h": "c",
|
||||
"shell.h": "c",
|
||||
"can.h": "c"
|
||||
}
|
||||
},
|
||||
"tasks": {
|
||||
"version": "2.0.0",
|
||||
"tasks": [
|
||||
{
|
||||
"label": "West Build",
|
||||
"type": "shell",
|
||||
"group": {
|
||||
"kind": "build",
|
||||
"isDefault": true
|
||||
},
|
||||
"command": "${userHome}/zephyrproject/.venv/bin/west",
|
||||
"args": [
|
||||
"build",
|
||||
"-p",
|
||||
"auto",
|
||||
"-b",
|
||||
"valve_node"
|
||||
],
|
||||
"problemMatcher": [
|
||||
"$gcc"
|
||||
],
|
||||
},
|
||||
{
|
||||
"label": "West Configurable Build",
|
||||
"type": "shell",
|
||||
"group": {
|
||||
"kind": "build",
|
||||
},
|
||||
"command": "${userHome}/zephyrproject/.venv/bin/west",
|
||||
"args": [
|
||||
"build",
|
||||
"-p",
|
||||
"${input:pristine}",
|
||||
"-b",
|
||||
"${input:board}"
|
||||
],
|
||||
"problemMatcher": [
|
||||
"$gcc"
|
||||
]
|
||||
},
|
||||
{
|
||||
"label": "West Flash",
|
||||
"type": "shell",
|
||||
"command": "${userHome}/zephyrproject/.venv/bin/west",
|
||||
"args": [
|
||||
"flash"
|
||||
],
|
||||
"problemMatcher": [
|
||||
"$gcc"
|
||||
]
|
||||
}
|
||||
],
|
||||
"inputs": [
|
||||
{
|
||||
"id": "board",
|
||||
"type": "promptString",
|
||||
"default": "vave_node",
|
||||
"description": "See https://docs.zephyrproject.org/latest/boards/index.html"
|
||||
},
|
||||
{
|
||||
"id": "pristine",
|
||||
"type": "pickString",
|
||||
"description": "Choose when to run a pristine build",
|
||||
"default": "auto",
|
||||
"options": [
|
||||
"auto",
|
||||
"always",
|
||||
"never"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
"launch": {
|
||||
"version": "0.2.0",
|
||||
"configurations": [
|
||||
{
|
||||
"name": "Launch",
|
||||
"device": "STM32F103RB",
|
||||
"cwd": "${workspaceFolder}",
|
||||
"executable": "build/zephyr/zephyr.elf",
|
||||
"request": "launch",
|
||||
"type": "cortex-debug",
|
||||
//"runToEntryPoint": "main",
|
||||
"servertype": "jlink",
|
||||
"gdbPath": "${userHome}/zephyr-sdk-0.17.1/arm-zephyr-eabi/bin/arm-zephyr-eabi-gdb",
|
||||
"preLaunchTask": "West Build"
|
||||
},
|
||||
{
|
||||
"name": "Attach",
|
||||
"device": "STM32F103RB",
|
||||
"cwd": "${workspaceFolder}",
|
||||
"executable": "build/zephyr/zephyr.elf",
|
||||
"request": "attach",
|
||||
"type": "cortex-debug",
|
||||
//"runToEntryPoint": "main",
|
||||
"servertype": "jlink",
|
||||
"gdbPath": "${userHome}/zephyr-sdk-0.17.1/arm-zephyr-eabi/bin/arm-zephyr-eabi-gdb"
|
||||
},
|
||||
]
|
||||
},
|
||||
"extensions": {
|
||||
"recommendations": [
|
||||
"ms-vscode.cpptools-extension-pack",
|
||||
"ms-python.python",
|
||||
"ms-vscode.vscode-embedded-tools",
|
||||
"ms-vscode.vscode-serial-monitor",
|
||||
"marus25.cortex-debug",
|
||||
"donjayamanne.python-environment-manager"
|
||||
]
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue