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

Added shell functions

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

13
software/test_canbus/prj.conf
View File

@@ -1,11 +1,20 @@
CONFIG_LOG=y
CONFIG_LOG_DEFAULT_LEVEL=3
CONFIG_LOG_SETTINGS_LEVEL=4
CONFIG_LOG_CAN_LEVEL=4
# CONFIG_LOG_SETTINGS_LEVEL=4
# CONFIG_LOG_CAN_LEVEL=4
CONFIG_CBPRINTF_FP_SUPPORT=y
CONFIG_UART_CONSOLE=y # Console on USART1
#CONFIG_RTT_CONSOLE=y
#CONFIG_USE_SEGGER_RTT=y
# CAN loopback mode for testing
CONFIG_LOOPBACK_MODE=y
CONFIG_SHELL=y
CONFIG_CAN_SHELL=y
CONFIG_GPIO_SHELL=y
CONFIG_REBOOT=y
# CONFIG_USE_SEGGER_RTT=y
# CONFIG_SHELL_BACKEND_RTT=y
# CONFIG_SHELL_BACKEND_SERIAL=n

108
software/test_canbus/src/main.c
View File

@@ -7,17 +7,80 @@
#include <zephyr/logging/log.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/shell/shell.h>
#include "canbus.h"
#include "modbus.h"
#include "config.h"
LOG_MODULE_REGISTER(main, CONFIG_LOG_DEFAULT_LEVEL);
K_THREAD_STACK_DEFINE(fake_modbus_stack, MODBUS_THREAD_STACK_SIZE);
K_MSGQ_DEFINE(modbus_msgq, sizeof(modbus_register_t), 10, 4);
int water_min = 0;
int water_max = 2000; // Maximum water level in mm
void fake_modbus_thread(void *arg1, void *arg2, void *arg3)
{
modbus_register_t reg;
ARG_UNUSED(arg1);
ARG_UNUSED(arg2);
ARG_UNUSED(arg3);
LOG_INF("Fake Modbus thread started");
while (1)
{
k_msgq_get(&modbus_msgq, &reg, K_FOREVER);
LOG_INF("Received Modbus register: 0x%02x, command: %s, value: %d", reg.reg, reg.command ? "GET" : "SET", reg.value);
switch (reg.command)
{
case CANBUS_REGISTER_COMMAND_SET:
switch (reg.reg)
{
case CANBUS_REGISTER_WATER_MINIMUM:
water_min = reg.value;
LOG_INF("Set water minimum to %d mm", water_min);
break;
case CANBUS_REGISTER_WATER_MAXIMUM:
water_max = reg.value;
LOG_INF("Set water maximum to %d mm", water_max);
break;
default:
LOG_INF("Received unknown command: 0x%02x for register: 0x%02x", reg.command, reg.reg);
break;
}
case CANBUS_REGISTER_COMMAND_GET:
switch (reg.reg)
{
case CANBUS_REGISTER_WATER_LEVEL_MM:
// Simulate reading water level in mm
reg.value = (water_min + water_max) / 2; // Example: average of min and max
LOG_INF("Read water level: %d mm", reg.value);
break;
case CANBUS_REGISTER_WATER_MINIMUM:
reg.value = water_min;
LOG_INF("Read water minimum: %d mm", reg.value);
break;
case CANBUS_REGISTER_WATER_MAXIMUM:
reg.value = water_max;
LOG_INF("Read water maximum: %d mm", reg.value);
break;
default:
LOG_INF("Received unknown command: 0x%02x for register: 0x%02x", reg.command, reg.reg);
break;
}
break;
}
}
}
int main(void)
{
int rc;
LOG_INF("Starting CAN bus initialization...");
// Initialize the configuration and CAN bus
rc = config_init();
if (rc != 0)
@@ -32,25 +95,38 @@ int main(void)
return rc;
}
LOG_INF("CAN bus initialized successfully");
uint16_t counter = 0;
k_sleep(K_SECONDS(1)); // Sleep for 1 second before starting the loop
struct k_thread fake_modbus_thread_data;
k_tid_t fake_modbus_tid = k_thread_create(&fake_modbus_thread_data, fake_modbus_stack,
K_THREAD_STACK_SIZEOF(fake_modbus_stack), fake_modbus_thread, NULL, NULL, NULL,
MODBUS_THREAD_PRIORITY, 0, K_NO_WAIT);
if (fake_modbus_tid == NULL)
{
LOG_ERR("Failed to create fake Modbus thread");
return -ENOMEM; // Not enough memory to create thread
}
LOG_INF("Fake Modbus thread created successfully");
while (1)
{
uint8_t data[2] = {0x00};
UNALIGNED_PUT(sys_cpu_to_be16(counter), (uint16_t *)&data[0]);
canbus_send_message(1, 0x01, data, sizeof(data)); // Example message sending
LOG_DBG("Sent message with counter: %d", counter);
canbus_send_message(2, 0x01, data, sizeof(data)); // Example message sending
LOG_DBG("Sent message with counter: %d", counter);
counter++;
if (counter > 1000) // Reset counter after 1000
{
counter = 0;
}
canbus_request_register(0x01, CANBUS_REGISTER_WATER_LEVEL_MM); // Request water level in mm
k_sleep(K_MSEC(150)); // Wait for 150 ms to allow the request to be processed
canbus_request_register(0x01, CANBUS_REGISTER_WATER_MINIMUM); // Request water minimum
k_sleep(K_MSEC(150)); // Wait for 150 ms to allow the request to be processed
int water_tmp = -100;
uint8_t data[2];
sys_put_be16(water_tmp, data); // Convert water_tmp to big-endian format
rc = canbus_send_register(0x01, CANBUS_REGISTER_WATER_MINIMUM, data, sizeof(data));
k_sleep(K_MSEC(150)); // Wait for 150 ms to allow the request to be processed
canbus_request_register(0x01, CANBUS_REGISTER_WATER_LEVEL_MM); // Request water level in mm
k_sleep(K_MSEC(150)); // Wait for 150 ms to allow the request to be processed
canbus_request_register(0x01, CANBUS_REGISTER_WATER_MINIMUM); // Request water minimum
k_sleep(K_SECONDS(5)); // Sleep for 5 second before next iteration
return 0; // Exit the loop after one iteration for testing purposes
// In a real application, you would likely not return here and continue the loop indefinitely
return 0; // Exit the loop after one iteration for testing purposes
// In a real application, you would remove this return statement
// to keep the loop running indefinitely.
}
return 0;
}