feat(project): Restructure software for multi-app setup
- Reorganize the software directory to support multiple Zephyr applications (gateway, slave_node). - Create a clear separation between applications and shared libraries. - Add placeholder files for gateway and slave_node applications.
This commit is contained in:
4
software/lib/CMakeLists.txt
Normal file
4
software/lib/CMakeLists.txt
Normal file
@@ -0,0 +1,4 @@
|
||||
# Add your shared libraries here
|
||||
# Example:
|
||||
# add_library(modbus modbus/modbus.c)
|
||||
# target_include_directories(modbus PUBLIC .)
|
||||
@@ -1,286 +0,0 @@
|
||||
#include "canbus.h"
|
||||
#include <zephyr/logging/log.h>
|
||||
#include <zephyr/kernel.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));
|
||||
|
||||
LOG_MODULE_REGISTER(canbus, CONFIG_LOG_CAN_LEVEL);
|
||||
|
||||
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)
|
||||
{
|
||||
int rc;
|
||||
ARG_UNUSED(dev);
|
||||
ARG_UNUSED(user_data);
|
||||
|
||||
if (frame->id >> 8 != node_id) // Check if the frame ID matches the 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);
|
||||
}
|
||||
}
|
||||
|
||||
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 = 0;
|
||||
|
||||
if (!device_is_ready(can_dev))
|
||||
{
|
||||
LOG_ERR("CAN device %s is not ready", can_dev->name);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_LOOPBACK_MODE
|
||||
rc = can_set_mode(can_dev, CAN_MODE_LOOPBACK);
|
||||
if (rc != 0)
|
||||
{
|
||||
LOG_ERR("Failed to set CAN loopback mode: %d", rc);
|
||||
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,16 +0,0 @@
|
||||
#ifndef __CANBUS_H__
|
||||
#define __CANBUS_H__
|
||||
|
||||
#include <stdint.h>
|
||||
#include "canbus_registers.h"
|
||||
|
||||
#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_send8(uint16_t reg, uint8_t value);
|
||||
int canbus_send16(uint16_t reg, uint16_t value);
|
||||
|
||||
#endif // __CANBUS_H__
|
||||
@@ -1,42 +0,0 @@
|
||||
#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 <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;
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
#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__
|
||||
@@ -1,383 +0,0 @@
|
||||
#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,
|
||||
},
|
||||
};
|
||||
|
||||
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
|
||||
@@ -1,27 +0,0 @@
|
||||
#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__
|
||||
Reference in New Issue
Block a user