mira/ch32v203-eth-node
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: housekeeping

Browse Source
This commit is contained in:
Mira
2024-11-12 00:55:52 +06:00
parent 5f9c966602
commit 48943ba71f
32 changed files with 715 additions and 854 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
.vscode/settings.json vendored
View File

@@ -27,6 +27,12 @@
"cstdlib": "c",
"modbus_master.h": "c",
"ch32v003_gpio_branchless.h": "c",
"mqttpacket.h": "c"
"mqttpacket.h": "c",
"stdbool.h": "c",
"onewire_temp.h": "c",
"modbus.h": "c",
"network.h": "c",
"cstdint": "c",
"utils.h": "c"
}
}

77
README.md
View File

@@ -1,64 +1,29 @@
# ch32-node fw
fw for a ch32v203 node w/ w5500 ethernet
# CH32V203 Node Firmware
## current
Firmware for a CH32V203 MCU with a W5500 Ethernet controller.
### SysTick IRQ and DMA issue
[Enabling](https://git.hye.su/mira/ch32-node/src/branch/master/src/main.c#L54) the SysTick IRQ leads to a permanent hang of the socket.
- With a 1ms IRQ interval, the hang occurs at `DHCP_ACK` during the `check_DHCP_leasedIP` -> `sendto()` [ARP request](https://git.hye.su/mira/ch32-node/src/branch/master/lib/ioLibrary_Driver/socket.c#L563).
- With a 100ms interval, the hang occurs during the DNS request.
- With a 1s interval it works
- [Disabling SPI DMA](https://git.hye.su/mira/ch32-node/src/branch/master/src/w5500.c#L62) solves it (just commenting out `reg_wizchip_spiburst_cbfunc`), so it's most likely DMA related?
- SPI DMA only works with [prescalers](https://git.hye.su/mira/ch32-node/src/branch/master/src/spi_dma.c#L140) 8 and 64?
- Also, for some reason it needs a ~50ms delay before configuring w5500 when compiled **with** `-O0`, not needed with `-Os`...
## TODO:
UnplatformIOify this
## Diff between SPI w/ and w/o DMA:
### SPI DMA
![SPI_DMA 1](notes/SPI_DMA_no_irq_1.png)
![SPI_DMA 2](notes/SPI_DMA_no_irq_2.png)
### SPI
![SPI 1](notes/SPI_1.png)
![SPI 2](notes/SPI_2.png)
## Features
00 09 04 C0 A8 66 01 02
00 09 04 C0 A8 66 01 02 02
- W5500 Ethernet controller support
- Network protocol support including:
- DHCP client
- MQTT client
- RS485 communication
- OneWire sensors
## ~~previous (DNS Processing)~~
solved by [patching](https://git.hye.su/mira/ch32-node/commit/259d63197e06c1a92b979490d4cd8f0fdb98f8d0#diff-6ba50689ba55dac7cfe3e9b011e594098c931e21) the korean bloatlib (`dns_makequery` in DNS.c)
## Development Environment
w/ ch32v003fun
- Platform: CH32V
- Board: CH32V203C8T6
- Framework: ch32v003fun
- Build System: PlatformIO
- Compiler: RISC-V GCC 14.2.0
> Partial DNS message: `11 23 81 82 00 01 00 00 00 00 00 00 03 68 79 65 00 00 00 02 73`
> **DNS_run() failed, res = 0**
## Project Structure
w/ WCH HAL (none-os).. I get a full response
> Receive DNS message from 192.168.102.1(53). len = 56
> Partial DNS message: `11 23 81 80 00 01 00 02 00 00 00 00 03 68 79 65 02 73 75 00 00 01 00 01 C0 0C 00 01 00 01 00 00 01 2C 00 04 68 15 33 7F C0 0C 00 01 00 01 00 00 01 2C 00 04 AC 43 B4 9A `
> Result: 172.67.180.154
`RCC_CTLR`, GPIO Registers, `SPIx_CTLR1` registers are identical
## LA
### ch32v003fun
![ch32v003fun](notes/2024-10-10-191033_1876x540_scrot.png)
```
00 00 34 11 27 01 00 00 01 00 00 00 00 00 00 03 68 79 65 00 00 00 02 73 75 00 00 00 00 01 00 01
```
- 32 bytes long
- (Post `68 79 65`): `00 00 00 02 73 75 00 00 00 00 01 00 01`
### none-os
![none-os](notes/2024-10-10-191043_1891x525_scrot.png)
```
00 00 34 11 27 01 00 00 01 00 00 00 00 00 00 03 68 79 65 02 73 75 00 00 01 00 01
```
- 27 bytes long
- (Post `68 79 65`): `02 73 75 00 00 01 00 01`
- `/include` - Header files
- `/lib` - Project libraries including WIZnet ioLibrary
- `/src` - Source code

28
include/config.h
View File

@@ -3,52 +3,48 @@
#include <stdint.h>
// Debug flags
// debug flags
#define DEBUG_MODE 1
// Device Bus Types
typedef enum { BUS_RS485, BUS_ONEWIRE } bus_type_t;
// Device Type Definitions
// device type definitions
typedef enum {
DEVICE_RELAY = 1,
DEVICE_SOIL_SENSOR = 2,
DEVICE_THERMOMETER = 3
} device_type_t;
// Node Configuration
// node configuration
typedef struct {
const char* id; // Unique identifier for the node
const char* name; // Human readable name
const char* location; // Optional location description
uint8_t mac[6]; // MAC address
} node_config_t;
// RS485 Device Configuration
// RS485 device configuration
typedef struct {
uint8_t slave_id; // Modbus slave ID
device_type_t type; // Type of device
const char* name; // Device name (used in MQTT topics)
} rs485_device_t;
// Network Configuration
// Network configuration
#define MQTT_SERVER_IP {192, 168, 102, 100}
#define MQTT_PORT 1883
// MQTT Configuration
// MQTT configuration
#define MQTT_KEEP_ALIVE_INTERVAL 60
#define MQTT_TX_BUFFER_SIZE 128
#define MQTT_RX_BUFFER_SIZE 128
#define MQTT_COMMAND_TIMEOUT_MS 1000
// Node Specific Configuration
static const node_config_t NODE_CONFIG = {
.id = "ch32-node1", .name = "CH32 Node 1", .location = "somewhere"};
// node config declaration
extern node_config_t NODE_CONFIG;
// RS485 Devices Configuration
// RS485 devices configuration
#define RS485_DEVICE_COUNT 1
static const rs485_device_t RS485_DEVICES[RS485_DEVICE_COUNT] = {
{.slave_id = 0x01, .type = DEVICE_RELAY, .name = "relay-1"}};
// {.slave_id = 0x02, .type = DEVICE_SOIL_SENSOR, .name = "soil-monitor-1"}};
// RS485 devices declaration
extern const rs485_device_t RS485_DEVICES[RS485_DEVICE_COUNT];
#endif // CONFIG_H

19
include/dhcp.h
View File

@@ -1,19 +0,0 @@
#ifndef DHCP_H
#define DHCP_H
#include <stdint.h>
typedef enum {
DHCP_STATE_INIT,
DHCP_STATE_DISCOVER,
DHCP_STATE_REQUEST,
DHCP_STATE_LEASED,
DHCP_STATE_RENEW,
DHCP_STATE_RELEASE
} dhcp_state_t;
void dhcp_init(void);
void dhcp_process(void);
uint8_t dhcp_get_state(void);
#endif

2
include/gpio.h
View File

@@ -13,7 +13,7 @@ typedef enum {
} led_state_t;
// Initialize GPIO
void init_gpio(void);
void gpio_init(void);
// LED status handling
void led_status_set(led_state_t state);

56
include/modbus.h Normal file
View File

@@ -0,0 +1,56 @@
#ifndef MODBUS_H
#define MODBUS_H
#include <MQTT/MQTTClient.h>
#include <stdbool.h>
#include <stdint.h>
#include "config.h"
// Function codes
#define MODBUS_FC_READ_HOLDING_REGISTERS 0x03
#define MODBUS_FC_WRITE_SINGLE_REGISTER 0x06
#define MODBUS_FC_WRITE_MULTIPLE_REGISTERS 0x10
// Modbus protocol exception codes
#define MODBUS_ERROR_NONE 0x00
#define MODBUS_ERROR_ILLEGAL_FUNCTION 0x01
#define MODBUS_ERROR_ILLEGAL_ADDRESS 0x02
#define MODBUS_ERROR_ILLEGAL_VALUE 0x03
#define MODBUS_ERROR_DEVICE_FAILURE 0x04
#define MODBUS_ERROR_ACKNOWLEDGE 0x05
#define MODBUS_ERROR_DEVICE_BUSY 0x06
#define MODBUS_ERROR_MEMORY_PARITY 0x08
#define MODBUS_ERROR_TIMEOUT 0x0B // No response received
#define MODBUS_ERROR_CRC 0x0C // CRC check failed
// Frame length
#define MB_MIN_LEN 4
#define MB_CRC_LEN 2
#define MB_WREG_LEN 8
#define MB_MAX_BUFFER 32
// States for the Modbus protocol state machine
typedef enum {
MODBUS_IDLE, // Ready to send new request
MODBUS_WAITING_RESPONSE, // Request sent, waiting for slave response
MODBUS_PROCESS_RESPONSE // Response received, processing data
} modbus_state_t;
// Callback function type for handling received Modbus register values
typedef void (*modbus_value_cb)(uint8_t device_idx, const char* property,
uint16_t value);
// Initialize the Modbus protocol handler with callback for received values
void modbus_handler_init(modbus_value_cb value_callback);
void modbus_handler_process(void);
// Send a Modbus read or write request to a slave device
// Returns true if request was queued successfully
bool modbus_handler_send_request(uint8_t device_idx, const char* property,
bool is_write, uint16_t value);
// Publish a Modbus register value to MQTT broker
// Formats topic as device_name/property
void modbus_publish_value(MQTTClient* client, const char* device_name,
const char* property, uint16_t value);
#endif // MODBUS_H

17
include/modbus_handler.h
View File

@@ -1,17 +0,0 @@
#ifndef MODBUS_HANDLER_H
#define MODBUS_HANDLER_H
#include <stdint.h>
#include "config.h"
#include "modbus_master.h"
typedef void (*modbus_value_cb)(uint8_t device_idx, const char* property,
uint16_t value);
void modbus_handler_init(modbus_context_t* ctx, modbus_value_cb value_callback);
void modbus_handler_process(void);
bool modbus_handler_send_request(uint8_t device_idx, const char* property,
uint8_t is_write, uint16_t value);
#endif

57
include/modbus_master.h
View File

@@ -1,57 +0,0 @@
#ifndef __MODBUS_MASTER_H
#define __MODBUS_MASTER_H
#include <stdint.h>
#include <stdbool.h>
// Function codes
#define MODBUS_FC_READ_HOLDING_REGISTERS 0x03
#define MODBUS_FC_WRITE_SINGLE_REGISTER 0x06
#define MODBUS_FC_WRITE_MULTIPLE_REGISTERS 0x10
// Error codes
#define MODBUS_ERROR_NONE 0x00
#define MODBUS_ERROR_FUNCTION 0x01
#define MODBUS_ERROR_ADDRESS 0x02
#define MODBUS_ERROR_VALUE 0x03
#define MODBUS_ERROR_TIMEOUT 0x04
// Frame length
#define MB_MIN_LEN 4
#define MB_CRC_LEN 2
#define MB_WREG_LEN 8
#define MB_MAX_BUFFER 32
// State machine states
typedef enum {
MODBUS_IDLE,
MODBUS_WAITING_RESPONSE,
MODBUS_PROCESS_RESPONSE
} modbus_state_t;
// Modbus context structure
typedef struct {
modbus_state_t state;
uint32_t last_send_time;
uint32_t response_timeout;
uint8_t buffer[MB_MAX_BUFFER];
uint16_t rx_len;
uint16_t current_bit;
uint16_t last_value;
void (*on_response)(uint8_t* buf, uint16_t len,
uint16_t value); // Response callback
void (*on_error)(uint8_t error_code); // Error callback
} modbus_context_t;
uint16_t modbus_create_request(uint8_t* req, uint8_t slave_addr,
uint8_t function, uint16_t address,
uint16_t value);
uint8_t modbus_process_response(uint8_t* buf, uint16_t len, uint16_t* value);
void modbus_init(modbus_context_t* ctx,
void (*response_callback)(uint8_t*, uint16_t, uint16_t),
void (*error_callback)(uint8_t));
void modbus_set_timeout(modbus_context_t* ctx, uint32_t timeout_ms);
void modbus_process(modbus_context_t* ctx);
bool modbus_send_request(modbus_context_t* ctx, uint8_t slave_addr,
uint8_t function, uint16_t address, uint16_t value);
#endif // __MODBUS_MASTER_H

11
include/mqtt_handler.h
View File

@@ -5,7 +5,7 @@
#include <stdbool.h>
#include "ch32v003fun.h"
#include "w5500.h"
#include "network.h"
#define MAX_PAYLOAD_LENGTH 256
@@ -17,6 +17,7 @@ typedef struct {
int qos;
} ch32_mqtt_options_t;
// MQTT state
typedef struct {
Network network;
MQTTClient client;
@@ -28,16 +29,18 @@ typedef struct {
bool discovery_published;
} mqtt_state_t;
// List of connected MQTT nodes
extern char nodes_list[MAX_PAYLOAD_LENGTH];
void mqtt_init(mqtt_state_t* state);
void mqtt_process(mqtt_state_t* state);
// Callback for handling incoming MQTT messages
void message_arrived(MessageData* md);
void publish_value(MQTTClient* client, const char* device_name,
const char* property, uint16_t value);
// Publish a retained message to an MQTT topic
void publish_retained(MQTTClient* client, const char* topic,
const char* payload);
// Publish a QoS 0 message to a MQTT topic
void publish_message(MQTTClient* client, const char* payload,
const char* topic);
#endif
#endif // MQTT_HANDLER_H

27
include/network.h Normal file
View File

@@ -0,0 +1,27 @@
#ifndef NETWORK_H
#define NETWORK_H
#include <MQTT/MQTTClient.h>
#include <stdint.h>
// Definitions for socket indexes
#define DHCP_SOCKET 0
#define DNS_SOCKET 1
#define TCP_SOCKET 2
typedef enum {
DHCP_STATE_INIT,
DHCP_STATE_DISCOVER,
DHCP_STATE_REQUEST,
DHCP_STATE_LEASED,
DHCP_STATE_RENEW,
DHCP_STATE_RELEASE
} dhcp_state_t;
// Initializes the W5500 chip
void configure_network(void);
void network_init(void);
void dhcp_process(void);
uint8_t dhcp_get_state(void);
#endif // NETWORK_H

11
include/rs485.h
View File

@@ -1,11 +0,0 @@
#ifndef RS485_H
#define RS485_H
#include <stdint.h>
void rs485_init(int uart_brr);
void rs485_send(uint8_t *buf, uint16_t len);
uint8_t rs485_available(void);
uint8_t rs485_read(void);
#endif // RS485_H

2
include/spi_dma.h
View File

@@ -12,7 +12,7 @@ typedef enum {
} transfer_state_t;
// SPI DMA initialization function
void init_spidma(void);
void spidma_init(void);
// SPI DMA buffer read
void spidma_read_buffer(uint8_t *buf, uint16_t len);

11
include/system_init.h
View File

@@ -1,11 +0,0 @@
#ifndef SYSTEM_INIT_H
#define SYSTEM_INIT_H
#include <stdbool.h>
#define W5500_INIT_DELAY_MS 55
void init_system(void);
bool wait_for_dhcp(void);
#endif

2
include/systick.h
View File

@@ -10,6 +10,6 @@
// ms counter incremented by SysTick
extern volatile uint32_t systick_millis;
void init_systick(void);
void systick_init(void);
#endif // SYSTICK_H

23
include/uart.h
View File

@@ -3,20 +3,29 @@
#include <stdint.h>
// RS485 baud rate
#define UART1_BAUD_RATE 9600
#define UART2_BAUD_RATE 115200
// Macro definitions
#define APB1_CLOCK (FUNCONF_SYSTEM_CORE_CLOCK / 2) // APB1 is divided by 2
// APB1 bus clock is half the system core clock
#define APB1_CLOCK (FUNCONF_SYSTEM_CORE_CLOCK / 2)
// USART2
#define UART_BRR_APB1 (((APB1_CLOCK) + (UART_BAUD_RATE / 2)) / (UART_BAUD_RATE))
// USART1
// Calculate baud rate divisors
// Adds BAUD_RATE/2 for rounding to nearest integer
#define UART_BRR_APB1 \
(((APB1_CLOCK) + (UART2_BAUD_RATE / 2)) / (UART2_BAUD_RATE))
#define UART_BRR_APB2 \
(((FUNCONF_SYSTEM_CORE_CLOCK) + (UART1_BAUD_RATE / 2)) / (UART1_BAUD_RATE))
// Function prototypes
void init_uart(int uart_brr);
// UART2
void uart2_init(int uart_brr);
// RS485 functions
void rs485_init(int uart_brr);
void rs485_send(uint8_t *buf, uint16_t len);
uint8_t rs485_available(void);
uint8_t rs485_read(void);
#endif // UART_H

51
include/utils.h Normal file
View File

@@ -0,0 +1,51 @@
#ifndef UTILS_H
#define UTILS_H
#include <stdint.h>
/**
* @brief Combines two bytes into a 16-bit word
* @param hi High byte
* @param lo Low byte
* @return Combined 16-bit word
*/
static inline uint16_t to_word(uint8_t hi, uint8_t lo) {
return (hi << 8) | lo;
}
/**
* @brief Splits a 16-bit word into two bytes
* @param val Value to split
* @param hi Pointer to store high byte
* @param lo Pointer to store low byte
*/
static inline void to_bytes(uint16_t val, uint8_t* hi, uint8_t* lo) {
*hi = (val >> 8) & 0xFF;
*lo = val & 0xFF;
}
/**
* @brief Parses a decimal number from a string
* @param str String to parse
* @return Parsed decimal number
*/
static inline uint8_t parse_decimal(const char* str) {
uint8_t num = 0;
while (*str >= '0' && *str <= '9') {
num = num * 10 + (*str - '0');
str++;
}
return num;
}
/**
* @brief Extracts the node number from an ID string
* @param id ID string to extract from
* @return Extracted node number
*/
static inline uint8_t parse_node_number(const char* id) {
const char* last_dash = strrchr(id, '-');
return last_dash ? parse_decimal(last_dash + 1) : 0;
}
#endif // UTILS_H

20
include/w5500.h
View File

@@ -1,20 +0,0 @@
#ifndef W5500_H
#define W5500_H
#include <MQTT/MQTTClient.h>
#include <stdint.h>
// Definitions for socket indexes
#define DHCP_SOCKET 0
#define DNS_SOCKET 1
#define TCP_SOCKET 2
extern volatile int ip_assigned;
// Initializes the W5500 chip
void configure_network(void);
// resolves a domain name
// void resolve_domain_name(const char* domain_name);
#endif // W5500_H

10
src/config.c Normal file
View File

@@ -0,0 +1,10 @@
#include "config.h"
// Node config definition
node_config_t NODE_CONFIG = {.id = "ch32-node-1",
.name = "test node 1, broken usb",
.location = "dunno yet"};
// RS485 devices definition
const rs485_device_t RS485_DEVICES[RS485_DEVICE_COUNT] = {
{.slave_id = 0x01, .type = DEVICE_RELAY, .name = "relay-1"}};

105
src/dhcp.c
View File

@@ -1,105 +0,0 @@
#include "dhcp.h"
#include <DHCP/dhcp.h>
#include <socket.h>
#include "debug.h"
#include "systick.h"
#include "w5500.h"
static volatile dhcp_state_t dhcp_state = DHCP_STATE_INIT;
static volatile uint32_t dhcp_lease_time = 0;
static volatile uint32_t dhcp_last_time = 0;
static volatile uint32_t dhcp_retry_count = 0;
static uint32_t last_check_time = 0;
// Buffers
static uint8_t dhcp_buffer[512];
static wiz_NetInfo current_net_info = {
.mac = {0xEA, 0x11, 0x22, 0x33, 0x44, 0xEA}, .dhcp = NETINFO_DHCP};
static void update_network_config(void) {
wizchip_setnetinfo(&current_net_info);
DEBUG_PRINT("IP config: %d.%d.%d.%d\n", current_net_info.ip[0],
current_net_info.ip[1], current_net_info.ip[2],
current_net_info.ip[3]);
}
void callback_ip_assigned(void) {
dhcp_lease_time = getDHCPLeasetime();
DEBUG_PRINT("IP newly assigned! Lease time: %lu sec\n", dhcp_lease_time);
getIPfromDHCP(current_net_info.ip);
getGWfromDHCP(current_net_info.gw);
getSNfromDHCP(current_net_info.sn);
getDNSfromDHCP(current_net_info.dns);
dhcp_state = DHCP_STATE_LEASED;
}
void callback_ip_updated(void) {
dhcp_lease_time = getDHCPLeasetime();
DEBUG_PRINT("IP lease updated! New lease time: %lu sec\n", dhcp_lease_time);
getIPfromDHCP(current_net_info.ip);
getGWfromDHCP(current_net_info.gw);
getSNfromDHCP(current_net_info.sn);
getDNSfromDHCP(current_net_info.dns);
dhcp_state = DHCP_STATE_LEASED;
}
void callback_ip_conflict(void) {
DEBUG_PRINT("IP conflict!\n");
dhcp_state = DHCP_STATE_INIT;
dhcp_retry_count = 0;
}
void dhcp_init(void) {
setSHAR(current_net_info.mac);
DHCP_init(DHCP_SOCKET, dhcp_buffer);
reg_dhcp_cbfunc(callback_ip_assigned, callback_ip_updated,
callback_ip_conflict);
dhcp_state = DHCP_STATE_INIT;
dhcp_retry_count = 0;
}
void dhcp_process(void) {
uint32_t current_time = millis();
// 500ms processing
if ((current_time - last_check_time) >= 500) {
last_check_time = current_time;
switch (dhcp_state) {
case DHCP_STATE_INIT:
DHCP_run();
if (dhcp_state == DHCP_STATE_LEASED) {
update_network_config();
}
break;
case DHCP_STATE_LEASED:
// renew @ 50% of lease time
if (current_time - dhcp_last_time >= (dhcp_lease_time * 500)) {
dhcp_state = DHCP_STATE_RENEW;
DHCP_run();
}
break;
case DHCP_STATE_RENEW:
DHCP_run();
if (dhcp_state == DHCP_STATE_LEASED) {
update_network_config();
dhcp_last_time = current_time;
}
break;
default:
DHCP_run();
break;
}
}
}
uint8_t dhcp_get_state(void) { return dhcp_state; }

2
src/gpio.c
View File

@@ -24,7 +24,7 @@ typedef struct {
static led_status_t led_status = {0};
void init_gpio(void) {
void gpio_init(void) {
// Enable clock for GPIOB
RCC->APB2PCENR |= RCC_APB2Periph_GPIOB;

36
src/main.c
View File

@@ -3,42 +3,56 @@
#include "ch32v003fun.h"
#include "config.h"
#include "debug.h"
#include "dhcp.h"
#include "gpio.h"
#include "modbus_handler.h"
#include "modbus.h"
#include "mqtt_handler.h"
#include "network.h"
#include "onewire_temp.h"
#include "system_init.h"
#include "spi_dma.h"
#include "systick.h"
#include "w5500.h"
#include "timer.h"
#include "uart.h"
#define W5500_INIT_DELAY_MS 55
static mqtt_state_t mqtt_state;
static modbus_context_t modbus_ctx;
void system_init(void) {
SystemInit();
gpio_init();
systick_init();
tim2_init();
spidma_init();
uart2_init(UART_BRR_APB1);
rs485_init(UART_BRR_APB2);
}
// Callback for modbus values
static void on_modbus_value(uint8_t device_idx, const char* property,
uint16_t value) {
if (mqtt_state.is_connected) {
publish_value(&mqtt_state.client, RS485_DEVICES[device_idx].name, property,
value);
modbus_publish_value(&mqtt_state.client, RS485_DEVICES[device_idx].name,
property, value);
}
}
int main(void) {
init_system();
system_init();
Delay_Ms(W5500_INIT_DELAY_MS);
configure_network();
dhcp_init();
network_init();
// block forever until dhcp resolves
wait_for_dhcp();
while (dhcp_get_state() != DHCP_STATE_LEASED) {
dhcp_process();
}
// init handlers
// init sensors before mqtt so we can add them to discovery
onewire_temp_init();
onewire_temp_set_parallel(true);
mqtt_init(&mqtt_state);
modbus_handler_init(&modbus_ctx, on_modbus_value);
modbus_handler_init(on_modbus_value);
uint32_t last_temp_publish = 0;
uint32_t last_temp_conversion = 0;

277
src/modbus.c Normal file
View File

@@ -0,0 +1,277 @@
#include "modbus.h"
#include <string.h>
#include "debug.h"
#include "systick.h"
#include "uart.h"
#include "utils.h"
// modbus ctx
typedef struct {
uint8_t buffer[256];
uint16_t rx_len;
uint32_t last_send_time;
uint32_t response_timeout;
modbus_state_t state;
void (*on_response)(uint16_t value);
void (*on_error)(uint8_t error);
} modbus_t;
// handler ctx
typedef struct {
uint8_t current_device_idx;
char current_property[16];
void (*value_cb)(uint8_t device_idx, const char* property, uint16_t value);
} modbus_handler_t;
static modbus_t mb;
static modbus_handler_t handler;
static uint16_t modbus_crc16(const unsigned char* buf, unsigned int len) {
static const uint16_t table[256] = {
0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601,
0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440, 0xCC01, 0x0CC0,
0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0x0A00, 0xCAC1, 0xCB81,
0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841, 0xD801, 0x18C0, 0x1980, 0xD941,
0x1B00, 0xDBC1, 0xDA81, 0x1A40, 0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01,
0x1DC0, 0x1C80, 0xDC41, 0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0,
0x1680, 0xD641, 0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081,
0x1040, 0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441, 0x3C00,
0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41, 0xFA01, 0x3AC0,
0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840, 0x2800, 0xE8C1, 0xE981,
0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41, 0xEE01, 0x2EC0, 0x2F80, 0xEF41,
0x2D00, 0xEDC1, 0xEC81, 0x2C40, 0xE401, 0x24C0, 0x2580, 0xE541, 0x2700,
0xE7C1, 0xE681, 0x2640, 0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0,
0x2080, 0xE041, 0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281,
0x6240, 0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41, 0xAA01,
0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840, 0x7800, 0xB8C1,
0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41, 0xBE01, 0x7EC0, 0x7F80,
0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40, 0xB401, 0x74C0, 0x7580, 0xB541,
0x7700, 0xB7C1, 0xB681, 0x7640, 0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101,
0x71C0, 0x7080, 0xB041, 0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0,
0x5280, 0x9241, 0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481,
0x5440, 0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841, 0x8801,
0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40, 0x4E00, 0x8EC1,
0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41, 0x4400, 0x84C1, 0x8581,
0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, 0x8201, 0x42C0, 0x4380, 0x8341,
0x4100, 0x81C1, 0x8081, 0x4040};
uint8_t xor = 0;
uint16_t crc = 0xFFFF;
while (len--) {
xor = (*buf++) ^ crc;
crc >>= 8;
crc ^= table[xor];
}
return crc;
}
static bool modbus_send(uint8_t slave_id, uint8_t function, uint16_t addr,
uint16_t value) {
if (mb.state != MODBUS_IDLE) {
return false;
}
uint8_t* req = mb.buffer;
req[0] = slave_id;
req[1] = function;
uint8_t hi, lo;
to_bytes(addr, &hi, &lo);
req[2] = hi;
req[3] = lo;
to_bytes(value, &hi, &lo);
req[4] = hi;
req[5] = lo;
uint16_t crc = modbus_crc16(req, 6);
req[6] = crc & 0xFF;
req[7] = (crc >> 8) & 0xFF;
rs485_send(req, 8);
mb.last_send_time = millis();
mb.rx_len = 0;
mb.state = MODBUS_WAITING_RESPONSE;
return true;
}
static void process_response(void) {
uint8_t* buf = mb.buffer;
uint16_t len = mb.rx_len;
// check minimum length and CRC
if (len < 5 ||
modbus_crc16(buf, len - 2) != ((buf[len - 1] << 8) | buf[len - 2])) {
mb.on_error(MODBUS_ERROR_CRC);
return;
}
// check for error response
if (buf[1] & 0x80) {
mb.on_error(buf[2]);
return;
}
// extract value based on function code
uint16_t value;
switch (buf[1]) {
case MODBUS_FC_READ_HOLDING_REGISTERS:
if (len >= 7) {
value = (buf[3] << 8) | buf[4];
mb.on_response(value);
}
break;
case MODBUS_FC_WRITE_SINGLE_REGISTER:
if (len == 8) {
value = (buf[4] << 8) | buf[5];
mb.on_response(value);
}
break;
default:
mb.on_error(MODBUS_ERROR_ILLEGAL_FUNCTION);
}
}
static void modbus_process(void) {
if (mb.state != MODBUS_WAITING_RESPONSE) {
return;
}
// chec for timeout
if (millis() - mb.last_send_time >= mb.response_timeout) {
mb.on_error(MODBUS_ERROR_TIMEOUT);
mb.state = MODBUS_IDLE;
return;
}
// read available data
while (rs485_available() && mb.rx_len < sizeof(mb.buffer)) {
mb.buffer[mb.rx_len++] = rs485_read();
// complete message?
if (mb.rx_len >= 8 || (mb.rx_len >= 5 && mb.buffer[1] & 0x80) ||
(mb.rx_len >= 5 && mb.buffer[1] == MODBUS_FC_READ_HOLDING_REGISTERS &&
mb.rx_len >= (3 + mb.buffer[2] + 2))) {
process_response();
mb.state = MODBUS_IDLE;
break;
}
}
}
static void modbus_init(void (*response_cb)(uint16_t),
void (*error_cb)(uint8_t)) {
memset(&mb, 0, sizeof(mb));
mb.state = MODBUS_IDLE;
mb.response_timeout = 200;
mb.on_response = response_cb;
mb.on_error = error_cb;
// flush any stale data - we get 0x00 on startup??
while (rs485_available()) {
rs485_read();
}
}
// internal response cb
static void on_modbus_response(uint16_t value) {
if (handler.current_device_idx >= RS485_DEVICE_COUNT || !handler.value_cb) {
return;
}
// forward value to mqtt cb
handler.value_cb(handler.current_device_idx, handler.current_property, value);
handler.current_device_idx = 0xFF;
handler.current_property[0] = '\0';
}
// internal error cb
static void on_modbus_error(__attribute__((unused)) uint8_t error_code) {
handler.current_device_idx = 0xFF;
handler.current_property[0] = '\0';
}
static uint16_t get_register_address(device_type_t type, const char* property) {
// todo: more device types
if (type == DEVICE_RELAY && strcmp(property, "state") == 0) {
return 0x0000;
}
return 0xFFFF; // invalid reg
}
void modbus_handler_init(modbus_value_cb value_callback) {
memset(&handler, 0xFF, sizeof(handler));
handler.current_property[0] = '\0';
handler.value_cb = value_callback;
modbus_init(on_modbus_response, on_modbus_error);
}
void modbus_handler_process(void) { modbus_process(); }
bool modbus_handler_send_request(uint8_t device_idx, const char* property,
bool is_write, uint16_t value) {
if (device_idx >= RS485_DEVICE_COUNT) {
return false;
}
uint16_t reg = get_register_address(RS485_DEVICES[device_idx].type, property);
if (reg == 0xFFFF) {
return false;
}
uint8_t function = is_write ? MODBUS_FC_WRITE_SINGLE_REGISTER
: MODBUS_FC_READ_HOLDING_REGISTERS;
if (modbus_send(RS485_DEVICES[device_idx].slave_id, function, reg, value)) {
// store ctx for resp handling
handler.current_device_idx = device_idx;
strncpy(handler.current_property, property,
sizeof(handler.current_property) - 1);
handler.current_property[sizeof(handler.current_property) - 1] = '\0';
return true;
}
return false;
}
void modbus_publish_value(MQTTClient* client, const char* device_name,
const char* property, uint16_t value) {
char topic[MAX_TOPIC_LENGTH];
char payload[17]; // 16 bits + null terminator
snprintf(topic, sizeof(topic), "homie/%s/%s/%s", NODE_CONFIG.id, device_name,
property);
// format based on property type
if (strcmp(property, "state") == 0) {
for (int i = 15; i >= 0; i--) {
payload[15 - i] = '0' + ((value >> i) & 1);
}
payload[16] = '\0';
} else {
// todo:
return;
}
MQTTMessage message = {.qos = QOS1,
.retained = 1,
.payload = payload,
.payloadlen = strlen(payload)};
if (MQTTPublish(client, topic, &message) != 0) {
DEBUG_PRINT("Failed to publish to %s\n", topic);
}
}

81
src/modbus_handler.c
View File

@@ -1,81 +0,0 @@
#include "modbus_handler.h"
#include <string.h>
#include "debug.h"
#include "systick.h"
static struct {
modbus_context_t* ctx;
modbus_value_cb value_cb;
uint8_t last_device_idx;
char last_property[16];
} handler;
static void on_modbus_response(uint8_t* buf __attribute__((unused)),
uint16_t len __attribute__((unused)),
uint16_t value) {
if (handler.last_device_idx >= RS485_DEVICE_COUNT || !handler.value_cb) {
return;
}
// call the value callback with parsed data
handler.value_cb(handler.last_device_idx, handler.last_property, value);
// clear the context
handler.last_device_idx = 0xFF;
handler.last_property[0] = '\0';
}
static void on_modbus_error(uint8_t error_code __attribute__((unused))) {
// clear the context on error
handler.last_device_idx = 0xFF;
handler.last_property[0] = '\0';
}
void modbus_handler_init(modbus_context_t* ctx,
modbus_value_cb value_callback) {
handler.ctx = ctx;
handler.value_cb = value_callback;
handler.last_device_idx = 0xFF;
handler.last_property[0] = '\0';
// Initialize modbus with our callbacks
modbus_init(ctx, on_modbus_response, on_modbus_error);
modbus_set_timeout(ctx, 200);
}
void modbus_handler_process(void) { modbus_process(handler.ctx); }
// Get Modbus register for specific device type and property
static uint16_t get_register_address(device_type_t type, const char* property) {
if (type == DEVICE_RELAY && strcmp(property, "state") == 0) {
return 0x0000;
}
return 0xFFFF;
}
bool modbus_handler_send_request(uint8_t device_idx, const char* property,
uint8_t is_write, uint16_t value) {
if (device_idx >= RS485_DEVICE_COUNT) {
return false;
}
uint16_t reg = get_register_address(RS485_DEVICES[device_idx].type, property);
if (reg == 0xFFFF) {
return false;
}
uint8_t fc = is_write ? MODBUS_FC_WRITE_SINGLE_REGISTER
: MODBUS_FC_READ_HOLDING_REGISTERS;
if (modbus_send_request(handler.ctx, RS485_DEVICES[device_idx].slave_id, fc,
reg, value)) {
handler.last_device_idx = device_idx;
strncpy(handler.last_property, property, sizeof(handler.last_property) - 1);
handler.last_property[sizeof(handler.last_property) - 1] = '\0';
return true;
}
return false;
}

247
src/modbus_master.c
View File

@@ -1,247 +0,0 @@
#include "modbus_master.h"
#include "debug.h"
#include "rs485.h"
#include "systick.h"
static uint16_t modbus_crc16(const unsigned char* buf, unsigned int len) {
static const uint16_t table[256] = {
0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601,
0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440, 0xCC01, 0x0CC0,
0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0x0A00, 0xCAC1, 0xCB81,
0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841, 0xD801, 0x18C0, 0x1980, 0xD941,
0x1B00, 0xDBC1, 0xDA81, 0x1A40, 0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01,
0x1DC0, 0x1C80, 0xDC41, 0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0,
0x1680, 0xD641, 0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081,
0x1040, 0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441, 0x3C00,
0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41, 0xFA01, 0x3AC0,
0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840, 0x2800, 0xE8C1, 0xE981,
0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41, 0xEE01, 0x2EC0, 0x2F80, 0xEF41,
0x2D00, 0xEDC1, 0xEC81, 0x2C40, 0xE401, 0x24C0, 0x2580, 0xE541, 0x2700,
0xE7C1, 0xE681, 0x2640, 0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0,
0x2080, 0xE041, 0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281,
0x6240, 0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41, 0xAA01,
0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840, 0x7800, 0xB8C1,
0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41, 0xBE01, 0x7EC0, 0x7F80,
0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40, 0xB401, 0x74C0, 0x7580, 0xB541,
0x7700, 0xB7C1, 0xB681, 0x7640, 0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101,
0x71C0, 0x7080, 0xB041, 0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0,
0x5280, 0x9241, 0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481,
0x5440, 0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841, 0x8801,
0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40, 0x4E00, 0x8EC1,
0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41, 0x4400, 0x84C1, 0x8581,
0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, 0x8201, 0x42C0, 0x4380, 0x8341,
0x4100, 0x81C1, 0x8081, 0x4040};
uint8_t xor = 0;
uint16_t crc = 0xFFFF;
while (len--) {
xor = (*buf++) ^ crc;
crc >>= 8;
crc ^= table[xor];
}
return crc;
}
static inline uint16_t mb_word(uint8_t hi, uint8_t lo) {
return ((uint16_t)hi << 8) | lo;
}
static inline void mb_split(uint16_t val, uint8_t* hi, uint8_t* lo) {
*hi = (val >> 8) & 0xFF;
*lo = val & 0xFF;
}
uint16_t modbus_create_request(uint8_t* req, uint8_t slave_addr,
uint8_t function, uint16_t address,
uint16_t value) {
req[0] = slave_addr;
req[1] = function;
uint8_t hi, lo;
mb_split(address, &hi, &lo);
req[2] = hi;
req[3] = lo;
if (function == MODBUS_FC_WRITE_SINGLE_REGISTER) {
mb_split(value, &hi, &lo);
req[4] = hi;
req[5] = lo;
// add crc
uint16_t crc = modbus_crc16(req, 6);
req[6] = crc & 0xFF;
req[7] = (crc >> 8) & 0xFF;
return 8;
} else if (function == MODBUS_FC_READ_HOLDING_REGISTERS) {
mb_split(value, &hi, &lo); // value = number of registers to read
req[4] = hi;
req[5] = lo;
// add crc
uint16_t crc = modbus_crc16(req, 6);
req[6] = crc & 0xFF;
req[7] = (crc >> 8) & 0xFF;
return 8;
}
return 0;
}
uint8_t modbus_process_response(uint8_t* buf, uint16_t len, uint16_t* value) {
if (len < MB_MIN_LEN) {
return MODBUS_ERROR_VALUE;
}
// check for error response
if (buf[1] & 0x80) {
return buf[2];
}
// verify crc
uint16_t rcv_crc = mb_word(buf[len - 1], buf[len - 2]);
uint16_t calc_crc = modbus_crc16(buf, len - 2);
if (rcv_crc != calc_crc) {
return MODBUS_ERROR_VALUE;
}
switch (buf[1]) {
case MODBUS_FC_WRITE_SINGLE_REGISTER:
if (len != MB_WREG_LEN) {
return MODBUS_ERROR_VALUE;
}
*value = mb_word(buf[4], buf[5]);
break;
case MODBUS_FC_READ_HOLDING_REGISTERS:
if (len < 5) {
return MODBUS_ERROR_VALUE;
}
uint8_t byte_count = buf[2];
for (uint8_t i = 0; i < byte_count / 2; i++) {
value[i] = mb_word(buf[3 + i * 2], buf[4 + i * 2]);
}
break;
default:
return MODBUS_ERROR_FUNCTION;
}
return MODBUS_ERROR_NONE;
}
void modbus_init(modbus_context_t* ctx,
void (*response_callback)(uint8_t*, uint16_t, uint16_t),
void (*error_callback)(uint8_t)) {
while (rs485_available()) {
uint8_t byte = rs485_read();
DEBUG_PRINT("Flushed stale byte: 0x%02X\n", byte);
}
ctx->state = MODBUS_IDLE;
ctx->last_send_time = 0;
ctx->response_timeout = 100; // Default 100ms timeout
ctx->rx_len = 0;
ctx->current_bit = 1;
ctx->last_value = 0;
ctx->on_response = response_callback;
ctx->on_error = error_callback;
}
void modbus_set_timeout(modbus_context_t* ctx, uint32_t timeout_ms) {
ctx->response_timeout = timeout_ms;
}
bool modbus_send_request(modbus_context_t* ctx, uint8_t slave_addr,
uint8_t function, uint16_t address,
uint16_t value) {
if (ctx->state != MODBUS_IDLE) {
return false; // Busy
}
uint16_t len =
modbus_create_request(ctx->buffer, slave_addr, function, address, value);
rs485_send(ctx->buffer, len);
ctx->last_send_time = millis();
ctx->rx_len = 0;
ctx->state = MODBUS_WAITING_RESPONSE;
return true; // Success
}
void modbus_process(modbus_context_t* ctx) {
uint32_t current_time = millis();
switch (ctx->state) {
case MODBUS_IDLE:
break;
case MODBUS_WAITING_RESPONSE:
// Check for timeout
if (current_time - ctx->last_send_time >= ctx->response_timeout) {
DEBUG_PRINT("Timeout after %lu ms with %d bytes received",
current_time - ctx->last_send_time, ctx->rx_len);
if (ctx->on_error) {
ctx->on_error(MODBUS_ERROR_TIMEOUT);
}
ctx->state = MODBUS_IDLE;
break;
}
// Read available data
while (rs485_available() && ctx->rx_len < sizeof(ctx->buffer)) {
ctx->buffer[ctx->rx_len++] = rs485_read();
// DEBUG_PRINT("Received byte: 0x%02X\n", ctx->buffer[ctx->rx_len - 1]);
if (ctx->rx_len >= MB_MIN_LEN) {
// holding reg
if (ctx->buffer[1] == MODBUS_FC_READ_HOLDING_REGISTERS) {
if (ctx->rx_len >= 3 && ctx->rx_len >= (3 + ctx->buffer[2] + 2)) {
ctx->state = MODBUS_PROCESS_RESPONSE;
break;
}
}
// single reg w
else if (ctx->buffer[1] == MODBUS_FC_WRITE_SINGLE_REGISTER) {
if (ctx->rx_len >= MB_WREG_LEN) {
ctx->state = MODBUS_PROCESS_RESPONSE;
break;
}
}
else if (ctx->buffer[1] & 0x80) {
if (ctx->rx_len >= 5) { // err 5b
ctx->state = MODBUS_PROCESS_RESPONSE;
break;
}
}
}
}
break;
case MODBUS_PROCESS_RESPONSE:
uint16_t value;
uint8_t result =
modbus_process_response(ctx->buffer, ctx->rx_len, &value);
if (result == MODBUS_ERROR_NONE) {
if (ctx->on_response) {
ctx->on_response(ctx->buffer, ctx->rx_len, value);
}
ctx->last_value = value;
} else if (ctx->on_error) {
ctx->on_error(result);
}
ctx->state = MODBUS_IDLE;
break;
}
}

46
src/mqtt_handler.c
View File

@@ -6,13 +6,13 @@
#include "debug.h"
#include "gpio.h"
#include "modbus_handler.h"
#include "modbus.h"
#include "onewire_temp.h"
#include "systick.h"
// MQTT
#define MQTT_YIELD_INTERVAL 100 // 100ms between yields in main loop
#define MQTT_MAX_PACKET_WAIT 20 // Only wait up to 20ms for packet processing
#define MQTT_MAX_PACKET_WAIT 20 // Only wait up to 20ms for packet processing
#define MQTT_RECONNECT_INTERVAL 5000 // 5 seconds between reconnection attempts
// Homie convention constants
@@ -158,41 +158,9 @@ void publish_retained(MQTTClient* client, const char* topic,
}
}
// TODO: this is a modbus value only
void publish_value(MQTTClient* client, const char* device_name,
const char* property, uint16_t value) {
DEBUG_PRINT("publish_value(device_name=%s, property=%s, value=%u)\n",
device_name, property, value);
char topic[MAX_TOPIC_LENGTH];
char payload[17]; // 16 bits + null terminator
snprintf(topic, sizeof(topic), "homie/%s/%s/%s", NODE_CONFIG.id, device_name,
property);
// formta based on property type
if (strcmp(property, "state") == 0) {
for (int i = 15; i >= 0; i--) {
payload[15 - i] = '0' + ((value >> i) & 1);
}
payload[16] = '\0';
} else {
// todo:
return;
}
MQTTMessage message = {.qos = QOS1,
.retained = 1,
.payload = payload,
.payloadlen = strlen(payload)};
if (MQTTPublish(client, topic, &message) != 0) {
DEBUG_PRINT("Failed to publish to %s\n", topic);
}
}
static void publish_device_attributes(MQTTClient* client) {
char topic[MAX_TOPIC_LENGTH];
char mac_str[18];
char* ptr = nodes_list;
size_t remaining = sizeof(nodes_list);
@@ -206,6 +174,14 @@ static void publish_device_attributes(MQTTClient* client) {
snprintf(topic, sizeof(topic), "homie/%s/$state", NODE_CONFIG.id);
publish_retained(client, topic, HOMIE_STATE_READY);
// Format MAC address as XX:XX:XX:XX:XX:XX
snprintf(mac_str, sizeof(mac_str), "%02X:%02X:%02X:%02X:%02X:%02X",
NODE_CONFIG.mac[0], NODE_CONFIG.mac[1], NODE_CONFIG.mac[2],
NODE_CONFIG.mac[3], NODE_CONFIG.mac[4], NODE_CONFIG.mac[5]);
snprintf(topic, sizeof(topic), "homie/%s/$mac", NODE_CONFIG.id);
publish_retained(client, topic, mac_str);
ptr = nodes_list;
*ptr = '\0';
// add rs485 devices

130
src/network.c Normal file
View File

@@ -0,0 +1,130 @@
#include "network.h"
#include <DHCP/dhcp.h>
#include <W5500/w5500.h>
#include <string.h>
#include "ch32v003fun.h"
#include "config.h"
#include "debug.h"
#include "spi_dma.h"
#include "systick.h"
#include "utils.h"
#define DHCP_INTERVAL_CONNECTING 50 // init/renew
#define DHCP_INTERVAL_CONNECTED 500 // leased
void configure_network(void) {
DEBUG_PRINT("Starting network configuration...\n");
// Setup chip select and SPI callbacks
reg_wizchip_cs_cbfunc(spi_select, spi_unselect);
// reg_wizchip_spi_cbfunc(spi_read_byte, spi_write_byte);
reg_wizchip_spiburst_cbfunc(spidma_read_buffer, spidma_write_buffer);
uint8_t rx_tx_buff_sizes[] = {2, 2, 2, 2, 2, 2, 2, 2};
wizchip_init(rx_tx_buff_sizes, rx_tx_buff_sizes);
}
static volatile dhcp_state_t dhcp_state = DHCP_STATE_INIT;
static volatile uint32_t dhcp_lease_time = 0;
static volatile uint32_t last_lease_time = 0;
static uint32_t last_processing_time = 0;
// Buffers
static uint8_t dhcp_buffer[512];
static wiz_NetInfo current_net_info = {
.mac = {0x02, 0x32, 0x00, 0x01, 0x00, 0x00}, .dhcp = NETINFO_DHCP};
static void update_network_config(void) {
wizchip_setnetinfo(&current_net_info);
DEBUG_PRINT("IP config: %d.%d.%d.%d\n", current_net_info.ip[0],
current_net_info.ip[1], current_net_info.ip[2],
current_net_info.ip[3]);
}
void callback_dhcp_ip_update(void) {
dhcp_lease_time = getDHCPLeasetime();
DEBUG_PRINT("IP %s! Lease time: %lu sec\n",
dhcp_state == DHCP_STATE_INIT ? "assigned" : "updated",
dhcp_lease_time);
// Update all network configuration at once
getIPfromDHCP(current_net_info.ip);
getGWfromDHCP(current_net_info.gw);
getSNfromDHCP(current_net_info.sn);
getDNSfromDHCP(current_net_info.dns);
dhcp_state = DHCP_STATE_LEASED;
}
void callback_ip_conflict(void) {
DEBUG_PRINT("IP conflict!\n");
dhcp_state = DHCP_STATE_INIT;
}
// Initialize network with MAC based on node ID
void network_init(void) {
uint8_t node_num = parse_node_number(NODE_CONFIG.id);
// MAC address
current_net_info.mac[0] = 0x02; // Locally administered
current_net_info.mac[1] = 0x32; // Organization ID (CH32)
current_net_info.mac[2] = 0x00; // Sub-organization
current_net_info.mac[3] = 0x01; // Device type
current_net_info.mac[4] = node_num >> 8; // Node number high byte
current_net_info.mac[5] = node_num & 0xFF; // Node number low byte
// Copy MAC to network info
memcpy(NODE_CONFIG.mac, current_net_info.mac, 6);
// Initialize network
setSHAR(current_net_info.mac);
DHCP_init(DHCP_SOCKET, dhcp_buffer);
reg_dhcp_cbfunc(callback_dhcp_ip_update, callback_dhcp_ip_update,
callback_ip_conflict);
dhcp_state = DHCP_STATE_INIT;
}
void dhcp_process(void) {
uint32_t current_time = millis();
uint16_t processing_interval =
dhcp_state == DHCP_STATE_INIT || dhcp_state == DHCP_STATE_RENEW
? DHCP_INTERVAL_CONNECTING
: DHCP_INTERVAL_CONNECTED;
if ((current_time - last_processing_time) >= processing_interval) {
last_processing_time = current_time;
switch (dhcp_state) {
case DHCP_STATE_INIT:
DHCP_run();
if (dhcp_state == DHCP_STATE_LEASED) {
update_network_config();
}
break;
case DHCP_STATE_LEASED:
// renew @ 50% of lease time
if (current_time - last_lease_time >= (dhcp_lease_time * 500)) {
dhcp_state = DHCP_STATE_RENEW;
DHCP_run();
}
break;
case DHCP_STATE_RENEW:
DHCP_run();
if (dhcp_state == DHCP_STATE_LEASED) {
update_network_config();
last_lease_time = current_time;
}
break;
default:
DHCP_run();
break;
}
}
}
uint8_t dhcp_get_state(void) { return dhcp_state; }

60
src/rs485.c
View File

@@ -1,60 +0,0 @@
#include "rs485.h"
#include "ch32v003fun.h"
#define RS485_TX_EN (1 << 14) // PB14
#define RS485_RX_EN (1 << 15) // PB15
void rs485_init(int uart_brr) {
RCC->APB2PCENR |= RCC_APB2Periph_GPIOA | // Enable GPIOA
RCC_APB2Periph_GPIOB | // Enable GPIOB
RCC_APB2Periph_USART1; // Enable USART1
// configure uart1 pins (PA9=TX, PA10=RX)
GPIOA->CFGHR &=
~(0xf << (4 * 1) | 0xf << (4 * 2)); // Clear PA9 & PA10 config
GPIOA->CFGHR |= (GPIO_Speed_10MHz | GPIO_CNF_OUT_PP_AF)
<< (4 * 1); // PA9 (TX)
GPIOA->CFGHR |= GPIO_CNF_IN_FLOATING << (4 * 2); // PA10 (RX)
// configure rs485 direction control pins (PB14=TX_EN, PB15=RX_EN)
GPIOB->CFGHR &=
~(0xf << (4 * 6) | 0xf << (4 * 7)); // Clear PB14 & PB15 config
GPIOB->CFGHR |= (GPIO_Speed_10MHz | GPIO_CNF_OUT_PP)
<< (4 * 6); // PB14 (TX_EN)
GPIOB->CFGHR |= (GPIO_Speed_10MHz | GPIO_CNF_OUT_PP)
<< (4 * 7); // PB15 (RX_EN)
// initial state: rx mode
GPIOB->BCR = RS485_TX_EN; // TX_EN low
GPIOB->BSHR = RS485_RX_EN; // RX_EN high
// uart1 configuration
USART1->CTLR1 =
USART_WordLength_8b | USART_Parity_No | USART_Mode_Tx | USART_Mode_Rx;
USART1->CTLR2 = USART_StopBits_1;
USART1->CTLR3 = USART_HardwareFlowControl_None;
USART1->BRR = uart_brr;
USART1->CTLR1 |= CTLR1_UE_Set;
}
void rs485_send(uint8_t *buf, uint16_t len) {
// enable tx mode
GPIOB->BSHR = RS485_TX_EN; // TX_EN high
GPIOB->BSHR = RS485_RX_EN; // RX_EN low
for (uint16_t i = 0; i < len; i++) {
while (!(USART1->STATR & USART_FLAG_TXE));
USART1->DATAR = buf[i];
}
while (!(USART1->STATR & USART_FLAG_TC));
// switch back to rx mode
GPIOB->BCR = RS485_TX_EN; // TX_EN low
GPIOB->BCR = RS485_RX_EN; // RX_EN high
}
uint8_t rs485_available(void) { return (USART1->STATR & USART_FLAG_RXNE) != 0; }
uint8_t rs485_read(void) { return USART1->DATAR & 0xFF; }

2
src/spi_dma.c
View File

@@ -79,7 +79,7 @@ void spidma_write_buffer(uint8_t* buf, uint16_t len) {
TX_Channel->CFGR &= ~DMA_CFGR1_EN;
}
void init_spidma(void) {
void spidma_init(void) {
// Enable clock for GPIOA and SPI1
RCC->APB2PCENR |= RCC_APB2Periph_GPIOA | RCC_APB2Periph_SPI1;
// Enable clock for DMA1

37
src/system_init.c
View File

@@ -1,37 +0,0 @@
#include "system_init.h"
#include <stdbool.h>
#include "ch32v003fun.h"
#include "debug.h"
#include "dhcp.h"
#include "gpio.h"
#include "rs485.h"
#include "spi_dma.h"
#include "systick.h"
#include "timer.h"
#include "uart.h"
#define DHCP_TIMEOUT_MS 120000
void init_system(void) {
SystemInit();
init_gpio();
init_systick();
tim2_init();
init_spidma();
init_uart(UART_BRR_APB1);
rs485_init(UART_BRR_APB2);
}
bool wait_for_dhcp(void) {
// uint32_t start = millis();
while (dhcp_get_state() != DHCP_STATE_LEASED) {
// if (millis() - start >= DHCP_TIMEOUT_MS) {
// DEBUG_PRINT("DHCP timeout\n");
// return false;
// }
dhcp_process();
}
return true;
}

2
src/systick.c
View File

@@ -7,7 +7,7 @@
// ms counter
volatile uint32_t systick_millis = 0;
void init_systick(void) {
void systick_init(void) {
SysTick->CTLR = 0;
SysTick->CMP = SYSTICK_ONE_MILLISECOND - 1;
SysTick->CNT = 0;

59
src/uart.c
View File

@@ -2,6 +2,9 @@
#include "ch32v003fun.h"
#define RS485_TX_EN (1 << 14) // PB14
#define RS485_RX_EN (1 << 15) // PB15
// Write multiple chars to UART
int _write(__attribute__((unused)) int fd, const char *buf, int size) {
for (int i = 0; i < size; i++) {
@@ -18,7 +21,7 @@ int putchar(int c) {
return (unsigned char)c;
}
void init_uart(int uart_brr) {
void uart2_init(int uart_brr) {
RCC->APB2PCENR |= RCC_APB2Periph_GPIOA; // Enable GPIOA on APB2
RCC->APB1PCENR |= RCC_APB1Periph_USART2; // Enable USART2 on APB1
@@ -35,3 +38,57 @@ void init_uart(int uart_brr) {
// Enable USART2
USART2->CTLR1 |= CTLR1_UE_Set;
}
void rs485_init(int uart_brr) {
RCC->APB2PCENR |= RCC_APB2Periph_GPIOA | // Enable GPIOA
RCC_APB2Periph_GPIOB | // Enable GPIOB
RCC_APB2Periph_USART1; // Enable USART1
// configure uart1 pins (PA9=TX, PA10=RX)
GPIOA->CFGHR &=
~(0xf << (4 * 1) | 0xf << (4 * 2)); // Clear PA9 & PA10 config
GPIOA->CFGHR |= (GPIO_Speed_10MHz | GPIO_CNF_OUT_PP_AF)
<< (4 * 1); // PA9 (TX)
GPIOA->CFGHR |= GPIO_CNF_IN_FLOATING << (4 * 2); // PA10 (RX)
// configure rs485 direction control pins (PB14=TX_EN, PB15=RX_EN)
GPIOB->CFGHR &=
~(0xf << (4 * 6) | 0xf << (4 * 7)); // Clear PB14 & PB15 config
GPIOB->CFGHR |= (GPIO_Speed_10MHz | GPIO_CNF_OUT_PP)
<< (4 * 6); // PB14 (TX_EN)
GPIOB->CFGHR |= (GPIO_Speed_10MHz | GPIO_CNF_OUT_PP)
<< (4 * 7); // PB15 (RX_EN)
// initial state: rx mode
GPIOB->BCR = RS485_TX_EN; // TX_EN low
GPIOB->BSHR = RS485_RX_EN; // RX_EN high
// uart1 configuration
USART1->CTLR1 =
USART_WordLength_8b | USART_Parity_No | USART_Mode_Tx | USART_Mode_Rx;
USART1->CTLR2 = USART_StopBits_1;
USART1->CTLR3 = USART_HardwareFlowControl_None;
USART1->BRR = uart_brr;
USART1->CTLR1 |= CTLR1_UE_Set;
}
void rs485_send(uint8_t *buf, uint16_t len) {
// enable tx mode
GPIOB->BSHR = RS485_TX_EN; // TX_EN high
GPIOB->BSHR = RS485_RX_EN; // RX_EN low
for (uint16_t i = 0; i < len; i++) {
while (!(USART1->STATR & USART_FLAG_TXE));
USART1->DATAR = buf[i];
}
while (!(USART1->STATR & USART_FLAG_TC));
// switch back to rx mode
GPIOB->BCR = RS485_TX_EN; // TX_EN low
GPIOB->BCR = RS485_RX_EN; // RX_EN high
}
uint8_t rs485_available(void) { return (USART1->STATR & USART_FLAG_RXNE) != 0; }
uint8_t rs485_read(void) { return USART1->DATAR & 0xFF; }

51
src/w5500.c
View File

@@ -1,51 +0,0 @@
#include "w5500.h"
#include <W5500/w5500.h>
#include <string.h>
#include "ch32v003fun.h"
#include "config.h"
#include "debug.h"
#include "spi_dma.h"
#include "systick.h"
void configure_network(void) {
DEBUG_PRINT("===\n");
DEBUG_PRINT("Starting network configuration...\n");
DEBUG_PRINT("===\n");
// Setup chip select and SPI callbacks
reg_wizchip_cs_cbfunc(spi_select, spi_unselect);
// reg_wizchip_spi_cbfunc(spi_read_byte, spi_write_byte);
reg_wizchip_spiburst_cbfunc(spidma_read_buffer, spidma_write_buffer);
uint8_t rx_tx_buff_sizes[] = {2, 2, 2, 2, 2, 2, 2, 2};
wizchip_init(rx_tx_buff_sizes, rx_tx_buff_sizes);
}
// static uint8_t dns_buffer[512];
// todo: rm !!!
// void resolve_domain_name(const char* domain_name) {
// DEBUG_PRINT("Resolving domain name \"%s\"...\n", domain_name);
// DNS_init(DNS_SOCKET, dns_buffer);
// // cloudflare dns
// uint8_t dns[] = {1, 1, 1, 1};
// uint8_t addr[4];
// int8_t res;
// uint8_t retries = 0;
// while (retries < 3) {
// Delay_Ms(250);
// res = DNS_run(dns, (uint8_t*)domain_name, addr);
// if (res == 1) {
// DEBUG_PRINT("Result: %d.%d.%d.%d\n", addr[0], addr[1], addr[2],
// addr[3]); break;
// } else {
// DEBUG_PRINT("DNS_run() failed, res = %d. Retries: %u\n", res, retries);
// }
// retries++;
// }
// }