551 lines
14 KiB
C
551 lines
14 KiB
C
#include "erpc_core.h"
|
|
|
|
#include "crc16.h"
|
|
|
|
/**
|
|
* 操作系统相关
|
|
*/
|
|
|
|
erpc_sleep erpc_sleep_tick = NULL;
|
|
|
|
static list_t erpc_hw;
|
|
void clean_cache(erpc_hw_cfg_t *hw)
|
|
{
|
|
for (int i = 0; i < MAX_REC_CMD_CACHE_NUM; i++)
|
|
{
|
|
hw->rec_cache->state = ERPC_CMD_NO_ERROR;
|
|
}
|
|
for (int i = 0; i < MAX_SEND_CMD_CACHE_NUM; i++)
|
|
{
|
|
hw->send_cache[i].state = ERPC_CMD_NO_ERROR;
|
|
}
|
|
}
|
|
/**
|
|
* 注册 hardware 设备
|
|
* 线程不安全
|
|
*/
|
|
u32 erpc_hw_add(erpc_hw_cfg_t *hw)
|
|
{
|
|
list_t *list = &erpc_hw;
|
|
if (list->data == NULL)
|
|
{
|
|
list->data = (void *)hw;
|
|
clean_cache(hw);
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
list_t *list_node = malloc(sizeof(list_t));
|
|
if (list_node == NULL)
|
|
{
|
|
return ERPC_ERR_MALLOC_ERROR;
|
|
}
|
|
list_node->data = (void *)hw;
|
|
u8 hw_ord = hw->ord;
|
|
// 检查hw是否已经存在
|
|
while (list != NULL)
|
|
{
|
|
erpc_hw_cfg_t *hw_cfg = (erpc_hw_cfg_t *)list->data;
|
|
if (hw_cfg->ord == hw_ord)
|
|
{
|
|
return ERPC_ERR_HW_EXIST;
|
|
}
|
|
list = list->next;
|
|
}
|
|
list_t *result = list_append(&erpc_hw, hw);
|
|
if (result == NULL)
|
|
{
|
|
return ERPC_ERR_MALLOC_ERROR;
|
|
}
|
|
clean_cache(hw);
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
/**
|
|
* 注册命令列表
|
|
* 线程不安全
|
|
*/
|
|
u32 erpc_add_cmd_list(erpc_hw_cfg_t *hw, erpc_cmd_list_t *cmd_list)
|
|
{
|
|
list_t *list = &hw->cmd_list;
|
|
if (list->data == NULL)
|
|
{
|
|
list->data = (void *)cmd_list;
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
list = list_append(&hw->cmd_list, cmd_list);
|
|
if (list == NULL)
|
|
{
|
|
return ERPC_ERR_MALLOC_ERROR;
|
|
}
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
/**
|
|
* 移除 hardware 设备
|
|
* 线程不安全
|
|
*/
|
|
u32 erpc_hw_remove(u8 hw)
|
|
{
|
|
list_t *list = &erpc_hw;
|
|
if (list->data == NULL)
|
|
{
|
|
return ERPC_ERR_NOFOND_HW;
|
|
}
|
|
while (list != NULL)
|
|
{
|
|
erpc_hw_cfg_t *hw_cfg = (erpc_hw_cfg_t *)list->data;
|
|
if (hw_cfg->ord == hw)
|
|
{
|
|
list_delete(&erpc_hw, list);
|
|
free(list);
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
list = list->next;
|
|
}
|
|
return ERPC_ERR_NOFOND_HW;
|
|
}
|
|
/**
|
|
* 获取 hardware 设备
|
|
*/
|
|
erpc_hw_cfg_t *erpc_hw_get(u8 hw)
|
|
{
|
|
list_t *list = &erpc_hw;
|
|
if (list->data == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
while (list != NULL)
|
|
{
|
|
erpc_hw_cfg_t *hw_cfg = (erpc_hw_cfg_t *)list->data;
|
|
if (hw_cfg->ord == hw)
|
|
{
|
|
return hw_cfg;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
u32 erpc_send_base(erpc_hw_cfg_t *hw_cfg, u8 dest_id, u16 port, u8 package_type,
|
|
u8 *data, u16 len)
|
|
{
|
|
CHECK_IF_ERROR(hw_cfg == NULL, ERPC_ERR_NOFOND_HW);
|
|
u8 cache_ord = 255;
|
|
// 查找可用的发送缓存
|
|
for (int i = 0; i < MAX_SEND_CMD_CACHE_NUM; i++)
|
|
{
|
|
if (hw_cfg->send_cache[i].state == ERPC_CMD_NO_ERROR)
|
|
{
|
|
ERPC_DEBUG("find send cache %d\n", i);
|
|
cache_ord = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
CHECK_IF_ERROR(cache_ord == 255, ERPC_ERR_SEND_CACHE_FULL);
|
|
// 准备数据
|
|
hw_cfg->send_cache[cache_ord].state = ERPC_CMD_DATA_DEAL;
|
|
erpc_cmd_def_t *cmd =
|
|
(erpc_cmd_def_t *)&hw_cfg->send_cache[cache_ord].data[0];
|
|
cmd->head.dest_id = dest_id;
|
|
cmd->head.port = port;
|
|
cmd->head.msg_len = len;
|
|
if (data == NULL)
|
|
{
|
|
cmd->head.msg_len = 0;
|
|
len = 0;
|
|
}
|
|
cmd->head.type = package_type;
|
|
cmd->head.src_id = hw_cfg->local_id;
|
|
if (len > 0 && data != NULL)
|
|
{
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
cmd->data[i] = data[i];
|
|
}
|
|
}
|
|
// 计算校验和
|
|
cmd_cal_crc16(cmd);
|
|
|
|
// 发送数据
|
|
hw_cfg->send_cache[cache_ord].state = ERPC_CMD_WAIT_SEND;
|
|
// 等待数据发送完成
|
|
int wait_time = CMD_TIMEOUT;
|
|
while (wait_time > 0)
|
|
{
|
|
if (hw_cfg->send_cache[cache_ord].state == ERPC_CMD_SEND_OK)
|
|
{
|
|
break;
|
|
}
|
|
if (hw_cfg->send_cache[cache_ord].state == ERPC_CMD_DEST_BUSY)
|
|
{
|
|
return ERPC_ERR_DEST_BUSY;
|
|
}
|
|
if (erpc_sleep_tick != NULL)
|
|
{
|
|
erpc_sleep_tick(1);
|
|
}
|
|
wait_time--;
|
|
}
|
|
u32 ret = ERPC_NO_ERROR;
|
|
do
|
|
{
|
|
if (wait_time == 0)
|
|
{
|
|
ret = ERPC_ERR_SEND_TIMEOUT;
|
|
break;
|
|
}
|
|
if (hw_cfg->send_cache[cache_ord].state == ERPC_CMD_SEND_ONCE)
|
|
{
|
|
ret = ERPC_ERR_DEST_NO_RESPONSE;
|
|
break;
|
|
}
|
|
if (hw_cfg->send_cache[cache_ord].state == ERPC_CMD_SEND_REPEAT)
|
|
{
|
|
ret = ERPC_ERR_DEST_NO_RESPONSE;
|
|
break;
|
|
}
|
|
} while (0);
|
|
hw_cfg->send_cache[cache_ord].state = ERPC_CMD_NO_ERROR;
|
|
return ret;
|
|
}
|
|
u32 erpc_send(u8 hw, u8 dest_id, u16 port, u8 *data, u16 len)
|
|
{
|
|
erpc_hw_cfg_t *hw_cfg = erpc_hw_get(hw);
|
|
u32 ret =
|
|
erpc_send_base(hw_cfg, dest_id, port, PACKAGE_TYPE_CMD_REQ, data, len);
|
|
return ret;
|
|
}
|
|
|
|
u32 erpc_wait_resp_package(u8 hw, u8 dest_id, u16 port, u8 *reply_data,
|
|
u16 *reply_len, u32 time_out)
|
|
{
|
|
erpc_hw_cfg_t *hw_cfg = erpc_hw_get(hw);
|
|
CHECK_IF_ERROR(hw_cfg == NULL, ERPC_ERR_NOFOND_HW);
|
|
while (time_out > 0)
|
|
{
|
|
for (int i = 0; i < MAX_REC_CMD_CACHE_NUM; i++)
|
|
{
|
|
erpc_data_cache_t *rec_cahce = &hw_cfg->rec_cache[i];
|
|
if (rec_cahce->state != ERPC_CMD_RESP_OK)
|
|
{
|
|
continue;
|
|
}
|
|
erpc_cmd_def_t *cmd = (erpc_cmd_def_t *)&rec_cahce->data[0];
|
|
if (cmd->head.port != port)
|
|
{
|
|
continue;
|
|
}
|
|
if (cmd->head.src_id != dest_id)
|
|
{
|
|
continue;
|
|
}
|
|
if (reply_data != NULL)
|
|
{
|
|
// memccpy(reply_data, cmd->data, 0, cmd->head.msg_len);
|
|
memcpy(reply_data, cmd->data, cmd->head.msg_len);
|
|
if (reply_len != NULL)
|
|
{
|
|
*reply_len = cmd->head.msg_len;
|
|
}
|
|
}
|
|
rec_cahce->state = ERPC_CMD_NO_ERROR;
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
if (erpc_sleep_tick != NULL)
|
|
{
|
|
erpc_sleep_tick(1);
|
|
}
|
|
time_out--;
|
|
}
|
|
CHECK_IF_ERROR(time_out == 0, ERPC_ERR_DEST_NO_REPLY);
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
u32 erpc_send_wait_reply(u8 hw, u8 dest_id, u16 port, u8 *data, u16 len,
|
|
u8 *reply_data, u16 *reply_len, u32 timeout)
|
|
{
|
|
u32 ret = erpc_send(hw, dest_id, port, data, len);
|
|
if (reply_len != NULL)
|
|
{
|
|
*reply_len = 0;
|
|
}
|
|
CHECK_IF_ERROR(ret != ERPC_NO_ERROR, ret);
|
|
ret =
|
|
erpc_wait_resp_package(hw, dest_id, port, reply_data, reply_len, timeout);
|
|
CHECK_IF_ERROR(ret != ERPC_NO_ERROR, ret);
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
u32 erpc_replay(u8 hw, u8 dest_id, u16 port, u8 *data_out, u16 len)
|
|
{
|
|
erpc_hw_cfg_t *hw_cfg = erpc_hw_get(hw);
|
|
u32 ret = erpc_send_base(hw_cfg, dest_id, port, PACKAGE_TYPE_CMD_RESP,
|
|
data_out, len);
|
|
|
|
return ret;
|
|
}
|
|
|
|
u32 erpc_send_data(erpc_hw_cfg_t *hw)
|
|
{
|
|
for (int i = 0; i < MAX_SEND_CMD_CACHE_NUM; i++)
|
|
{
|
|
if (hw->send_cache[i].state == ERPC_CMD_WAIT_SEND)
|
|
{
|
|
erpc_cmd_def_t *cmd = (erpc_cmd_def_t *)&hw->send_cache[i].data[0];
|
|
u32 len = sizeof(erpc_cmd_head_t) + 2 + cmd->head.msg_len;
|
|
hw->send_lock();
|
|
u8 ret = hw->write((u8 *)hw->send_cache[i].data, len);
|
|
hw->send_unlock();
|
|
CHECK_IF_ERROR(ret != 0, ERPC_ERR_HW_SEND_FAIL);
|
|
hw->send_cache[i].state = ERPC_CMD_SEND_ONCE;
|
|
}
|
|
}
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
|
|
u32 erpc_rev_ack_package(erpc_hw_cfg_t *hw, erpc_cmd_def_t *cmd_rev)
|
|
{
|
|
for (int i = 0; i < MAX_SEND_CMD_CACHE_NUM; i++)
|
|
{
|
|
if (hw->send_cache[i].state == ERPC_CMD_SEND_ONCE ||
|
|
hw->send_cache[i].state == ERPC_CMD_SEND_REPEAT)
|
|
{
|
|
erpc_cmd_def_t *cmd_send = (erpc_cmd_def_t *)&hw->send_cache[i].data[0];
|
|
if (cmd_rev->head.port == cmd_send->head.port)
|
|
{
|
|
hw->send_cache[i].state = ERPC_CMD_SEND_OK;
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
}
|
|
}
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
u32 erpc_rev_resp_package(erpc_hw_cfg_t *hw, erpc_cmd_def_t *cmd_rev)
|
|
{
|
|
erpc_cmd_def_t cmd_send;
|
|
cmd_send.head.dest_id = cmd_rev->head.src_id;
|
|
cmd_send.head.port = cmd_rev->head.port;
|
|
cmd_send.head.msg_len = 0;
|
|
cmd_send.head.type = PACKAGE_TYPE_CMD_RESP_ACK;
|
|
cmd_send.head.src_id = hw->local_id;
|
|
cmd_cal_crc16(&cmd_send);
|
|
u32 len = sizeof(erpc_cmd_head_t) + 2 + cmd_send.head.msg_len;
|
|
hw->send_lock();
|
|
u8 ret = hw->write((u8 *)&cmd_send, len);
|
|
hw->send_unlock();
|
|
CHECK_IF_ERROR(ret != 0, ERPC_ERR_HW_SEND_FAIL);
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
// 重发数据包
|
|
u32 erpc_rev_repeat_package(erpc_hw_cfg_t *hw, erpc_cmd_def_t *cmd_rev)
|
|
{
|
|
for (int i = 0; i < MAX_SEND_CMD_CACHE_NUM; i++)
|
|
{
|
|
if (hw->send_cache[i].state == ERPC_CMD_SEND_ONCE ||
|
|
hw->send_cache[i].state == ERPC_CMD_SEND_REPEAT)
|
|
{
|
|
erpc_cmd_def_t *cmd_send = (erpc_cmd_def_t *)&hw->send_cache[i].data[0];
|
|
if (cmd_rev->head.port == cmd_send->head.port)
|
|
{
|
|
u32 len = sizeof(erpc_cmd_head_t) + 2 + cmd_send->head.msg_len;
|
|
hw->send_lock();
|
|
u32 ret = hw->write((u8 *)hw->send_cache[i].data, len);
|
|
hw->send_unlock();
|
|
hw->send_cache[i].state = ERPC_CMD_SEND_REPEAT;
|
|
CHECK_IF_ERROR(ret, ERPC_ERR_HW_SEND_FAIL); //
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
}
|
|
}
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
u32 erpc_send_ack_package(erpc_hw_cfg_t *hw, erpc_cmd_def_t *cmd_rev)
|
|
{
|
|
erpc_cmd_def_t cmd_send;
|
|
cmd_send.head.dest_id = cmd_rev->head.src_id;
|
|
cmd_send.head.port = cmd_rev->head.port;
|
|
cmd_send.head.msg_len = 0;
|
|
cmd_send.head.type = PACKAGE_TYPE_CMD_REQ_ACK;
|
|
cmd_send.head.src_id = hw->local_id;
|
|
cmd_cal_crc16(&cmd_send);
|
|
u32 len = sizeof(erpc_cmd_head_t) + 2 + cmd_send.head.msg_len;
|
|
hw->send_lock();
|
|
u8 ret = hw->write((u8 *)&cmd_send, len);
|
|
hw->send_unlock();
|
|
CHECK_IF_ERROR(ret != 0, ERPC_ERR_HW_SEND_FAIL);
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
|
|
u32 erpc_rev_package(erpc_hw_cfg_t *hw)
|
|
{
|
|
for (int i = 0; i < MAX_REC_CMD_CACHE_NUM; i++)
|
|
{
|
|
if (hw->rec_cache[i].state == ERPC_CMD_WAIT_SERVER_DEAL)
|
|
{
|
|
ERPC_DEBUG("find cmd wait server deal %d\n", i);
|
|
erpc_cmd_def_t *cmd = (erpc_cmd_def_t *)&hw->rec_cache[i].data[0];
|
|
// 检查crc
|
|
u8 crc_result = cmd_check_crc16(cmd);
|
|
// 丢弃错误数据包
|
|
if (crc_result)
|
|
{
|
|
hw->rec_cache[i].state = ERPC_CMD_NO_ERROR;
|
|
continue;
|
|
}
|
|
// 丢弃不是本地数据包
|
|
if (cmd->head.dest_id != hw->local_id)
|
|
{
|
|
hw->rec_cache[i].state = ERPC_CMD_NO_ERROR;
|
|
continue;
|
|
}
|
|
// 处理数据包
|
|
switch (cmd->head.type)
|
|
{
|
|
case PACKAGE_TYPE_CMD_REQ:
|
|
ERPC_DEBUG("{REQ}\n");
|
|
erpc_send_ack_package(hw, cmd);
|
|
hw->rec_cache[i].state = ERPC_CMD_WAIT_TASK_DEAL;
|
|
break;
|
|
case PACKAGE_TYPE_CMD_REQ_ACK:
|
|
ERPC_DEBUG("{ACK}\n");
|
|
erpc_rev_ack_package(hw, cmd);
|
|
hw->rec_cache[i].state = ERPC_CMD_NO_ERROR;
|
|
break;
|
|
|
|
case PACKAGE_TYPE_CMD_REPEAT:
|
|
erpc_rev_repeat_package(hw, cmd);
|
|
hw->rec_cache[i].state = ERPC_CMD_NO_ERROR;
|
|
break;
|
|
case PACKAGE_TYPE_CMD_RESP:
|
|
ERPC_DEBUG("{RESP}\n");
|
|
erpc_rev_resp_package(hw, cmd);
|
|
hw->rec_cache[i].state = ERPC_CMD_RESP_OK;
|
|
break;
|
|
case PACKAGE_TYPE_CMD_RESP_ACK:
|
|
ERPC_DEBUG("{RESP_ACK}\n");
|
|
erpc_rev_ack_package(hw, cmd);
|
|
hw->rec_cache[i].state = ERPC_CMD_NO_ERROR;
|
|
break;
|
|
default:
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
void erpc_rev_package_core()
|
|
{
|
|
list_t *list = &erpc_hw;
|
|
if (list->data == NULL)
|
|
{
|
|
return;
|
|
}
|
|
while (list != NULL)
|
|
{
|
|
erpc_hw_cfg_t *hw = (erpc_hw_cfg_t *)list->data;
|
|
erpc_rev_package(hw);
|
|
list = list->next;
|
|
}
|
|
}
|
|
u32 erpc_set_rev_cahce(u8 hw, u8 *data, u16 len)
|
|
{
|
|
erpc_hw_cfg_t *hw_cfg = erpc_hw_get(hw);
|
|
CHECK_IF_ERROR(hw_cfg == NULL, ERPC_ERR_NOFOND_HW);
|
|
for (int i = 0; i < MAX_REC_CMD_CACHE_NUM; i++)
|
|
{
|
|
if (hw_cfg->rec_cache[i].state == ERPC_CMD_NO_ERROR)
|
|
{
|
|
ERPC_DEBUG("set rev cache %d\r\n", i);
|
|
memcpy(hw_cfg->rec_cache[i].data, data, len);
|
|
hw_cfg->rec_cache[i].state = ERPC_CMD_WAIT_SERVER_DEAL;
|
|
return ERPC_NO_ERROR;
|
|
}
|
|
}
|
|
return ERPC_ERR_REC_CACHE_FULL;
|
|
}
|
|
void erpc_send_deal_core()
|
|
{
|
|
list_t *list = &erpc_hw;
|
|
if (list->data == NULL)
|
|
{
|
|
return;
|
|
}
|
|
while (list != NULL)
|
|
{
|
|
erpc_hw_cfg_t *hw = (erpc_hw_cfg_t *)list->data;
|
|
erpc_send_data(hw);
|
|
}
|
|
if (erpc_sleep_tick != NULL)
|
|
{
|
|
erpc_sleep_tick(1);
|
|
}
|
|
}
|
|
|
|
void erpc_rev_deal_core()
|
|
{
|
|
list_t *list = &erpc_hw;
|
|
if (list->data == NULL)
|
|
{
|
|
return;
|
|
}
|
|
while (list != NULL)
|
|
{
|
|
erpc_hw_cfg_t *hw = (erpc_hw_cfg_t *)list->data;
|
|
{ // 遍历接收缓存
|
|
for (int j = 0; j < MAX_REC_CMD_CACHE_NUM; j++)
|
|
{
|
|
{ // 发现等待处理的数据包
|
|
if (hw->rec_cache[j].state != ERPC_CMD_WAIT_TASK_DEAL)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
{ // 多线程下，抢占处理权限
|
|
hw->deal_lock();
|
|
if (hw->rec_cache[j].state == ERPC_CMD_WAIT_TASK_DEAL)
|
|
{
|
|
// 获取指令的处理权限
|
|
hw->rec_cache[j].state = ERPC_CMD_WAIT_TASK_DEAL_FINISH;
|
|
}
|
|
else
|
|
{
|
|
// 已经有线程抢先执行了
|
|
hw->deal_unlock();
|
|
continue;
|
|
}
|
|
hw->deal_unlock();
|
|
}
|
|
{ // 处理指令
|
|
// 搜索指令列表
|
|
list_t *cmd_list = &hw->cmd_list;
|
|
// 链表是空的
|
|
if (cmd_list->data == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
// 获取指令指针
|
|
erpc_cmd_def_t *cmd_def = (erpc_cmd_def_t *)hw->rec_cache[j].data;
|
|
while (cmd_list != NULL)
|
|
{ // 搜索指令列表
|
|
erpc_cmd_list_t *cmd_obj = (erpc_cmd_list_t *)cmd_list->data;
|
|
if (cmd_obj->cmd == cmd_def->head.port)
|
|
{
|
|
if (cmd_obj->handle != NULL)
|
|
{
|
|
// 指令调用
|
|
cmd_obj->handle(hw->ord, cmd_def->head.src_id,
|
|
cmd_def->head.dest_id, cmd_def->head.port,
|
|
cmd_def->data, cmd_def->head.msg_len);
|
|
}
|
|
|
|
break;
|
|
}
|
|
cmd_list = cmd_list->next;
|
|
}
|
|
}
|
|
// 处理完成 丢弃缓存 , 无论是否执行指令，都需要把数据包丢弃
|
|
hw->rec_cache[j].state = ERPC_CMD_NO_ERROR;
|
|
}
|
|
}
|
|
list = list->next;
|
|
}
|
|
if (erpc_sleep_tick != NULL)
|
|
{
|
|
erpc_sleep_tick(1);
|
|
}
|
|
} |