172 lines
2.5 KiB
C
172 lines
2.5 KiB
C
#include "modbus.h"
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#define MAX_NODES 20
|
|
#define MAX_callback_NODES 10
|
|
#define TABLE_SIZE (sizeof(table)/ sizeof(table[0]))
|
|
|
|
static modbus_task node_pool[MAX_NODES];
|
|
static uint8_t node_used[MAX_NODES] = {0};
|
|
static modbus_task* free_list =NULL;
|
|
|
|
static CallbackNode callback_pool[MAX_callback_NODES];
|
|
static CallbackNode* callback_list_head = NULL;
|
|
static CallbackNode* callback_free_list = NULL;
|
|
|
|
|
|
void modbus_init(void)
|
|
{
|
|
for(int i = MAX_NODES-1; i >= 0; i--)
|
|
{
|
|
node_pool[i].next = free_list;
|
|
free_list = &node_pool[i];
|
|
node_used[i] = 0;
|
|
}
|
|
|
|
}
|
|
|
|
modbus_task* allocate_task(void)
|
|
{
|
|
if(free_list == NULL)
|
|
{
|
|
return NULL;
|
|
|
|
}
|
|
|
|
modbus_task* node = free_list;
|
|
free_list = free_list->next;
|
|
uint8_t index = node - node_pool;
|
|
node_used[index] = 1;
|
|
|
|
memset(node, 0, sizeof(modbus_task));
|
|
node->next = NULL;
|
|
|
|
return node;
|
|
}
|
|
|
|
void free_task(modbus_task* node)
|
|
{
|
|
if(node == NULL)return;
|
|
|
|
uint8_t index = node - node_pool;
|
|
if(index < 0 || index >= MAX_NODES || node_used[index] == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
node->next = free_list;
|
|
free_list = node;
|
|
node_used[index] = 0;
|
|
|
|
|
|
}
|
|
|
|
void check_align_table(uint8_t slave, uint16_t addr, uint8_t* data)
|
|
{
|
|
for(int i = 0; i < TABLE_SIZE; i++ )
|
|
{
|
|
if((table[i].slave == slave)&&(table[i].reg_addr) == addr)
|
|
{
|
|
if(addr == 1000)
|
|
{
|
|
|
|
|
|
}
|
|
else if(addr == 2000)
|
|
{
|
|
|
|
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void callback_pool_init(void)
|
|
{
|
|
for(int i = MAX_callback_NODES-1; i >= 0; i--)
|
|
{
|
|
callback_pool[i].next = callback_free_list;
|
|
callback_free_list = &callback_pool[i];
|
|
}
|
|
callback_list_head = NULL;
|
|
}
|
|
|
|
CallbackNode* allocate_callback_node(void)
|
|
{
|
|
if(callback_free_list == NULL) return NULL;
|
|
CallbackNode* node = callback_free_list;
|
|
callback_free_list = callback_free_list->next;
|
|
|
|
memset(node, 0, sizeof(CallbackNode));
|
|
node->next = NULL;
|
|
|
|
return node;
|
|
|
|
}
|
|
|
|
void free_callback_node(CallbackNode* node)
|
|
{
|
|
if(node == NULL)return;
|
|
|
|
uint8_t index = node - callback_pool;
|
|
if(index < 0 || index >= MAX_callback_NODES )
|
|
{
|
|
return;
|
|
}
|
|
|
|
node->next = callback_free_list;
|
|
callback_free_list = node;
|
|
}
|
|
|
|
|
|
void reg_callback(uint8_t slave, uint16_t addr, ModbusCallback func)
|
|
{
|
|
if(func == NULL)return;
|
|
CallbackNode* new_node = allocate_callback_node();
|
|
if(new_node == NULL)return;
|
|
|
|
new_node->slave = slave;
|
|
new_node->addr = addr;
|
|
new_node->callback = func;
|
|
new_node->next = NULL;
|
|
|
|
new_node->next = callback_list_head;
|
|
callback_list_head = new_node;
|
|
|
|
|
|
}
|
|
|
|
void execute_callback()
|
|
{
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|