459 lines
15 KiB
C
459 lines
15 KiB
C
/*
|
||
* @Author: shenghao.xu
|
||
* @Date: 2023-04-10 13:08:00
|
||
* @LastEditors: shenghao.xu
|
||
* @LastEditTime: 2023-04-25 23:05:46
|
||
* @Description:
|
||
* email:545403892@qq.com
|
||
* Copyright (c) 2023 by shenghao.xu, All Rights Reserved.
|
||
*/
|
||
|
||
#include "agreement_frame.h"
|
||
|
||
config_t *g_config = NULL;
|
||
calibration_sensor_t *g_calibration_sensor = NULL;
|
||
query_data_t *g_query_data = NULL;
|
||
execute_process_t g_execute_process; // 执行流程数据域
|
||
void config_print(config_t *config)
|
||
{
|
||
if (config != NULL)
|
||
{
|
||
if (config->processes != NULL)
|
||
{
|
||
for (uint8_t i = 0; i < config->process_count; i++)
|
||
{
|
||
if (config->processes[i].plans != NULL)
|
||
{
|
||
for (uint8_t j = 0; j < config->processes[i].plan_count; j++)
|
||
{
|
||
if (config->processes[i].plans[j].actions != NULL)
|
||
{
|
||
for (uint8_t k = 0; k < config->processes[i].plans[j].action_count; k++)
|
||
{
|
||
#ifdef STM32
|
||
|
||
#else
|
||
LOG_PRINT("process[%d] plan[%d] action[%d] type:%02x\r", i, j, k, config->processes[i].plans[j].actions[k].type);
|
||
uint8_t *ptr = (uint8_t *)&config->processes[i].plans[j].actions[k].data;
|
||
LOG_HEX(ptr, 10);
|
||
#endif
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @description: 配置参数释放
|
||
* @param {config} *config
|
||
* @return {*}
|
||
*/
|
||
void config_free(config_t *config)
|
||
{
|
||
if (config != NULL)
|
||
{
|
||
if (config->processes != NULL)
|
||
{
|
||
for (uint8_t i = 0; i < config->process_count; i++)
|
||
{
|
||
if (config->processes[i].plans != NULL)
|
||
{
|
||
for (uint8_t j = 0; j < config->processes[i].plan_count; j++)
|
||
{
|
||
if (config->processes[i].plans[j].actions != NULL)
|
||
{
|
||
osel_mem_free(config->processes[i].plans[j].actions);
|
||
}
|
||
}
|
||
osel_mem_free(config->processes[i].plans);
|
||
}
|
||
}
|
||
osel_mem_free(config->processes);
|
||
}
|
||
osel_mem_free(config);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @description: 配置参数数据结构初始化
|
||
* @param {uint8_t} process_count
|
||
* @param {uint8_t} plan_count
|
||
* @param {uint8_t} action_count
|
||
* @return {*}
|
||
*/
|
||
config_t *config_alloc(uint8_t process_count, uint8_t plan_count, uint8_t action_count)
|
||
{
|
||
config_t *config = osel_mem_alloc(sizeof(config_t));
|
||
if (config != NULL)
|
||
{
|
||
config->process_count = process_count;
|
||
config->processes = osel_mem_alloc(sizeof(process_t) * process_count);
|
||
if (config->processes != NULL)
|
||
{
|
||
for (uint8_t i = 0; i < process_count; i++)
|
||
{
|
||
config->processes[i].plan_count = plan_count;
|
||
config->processes[i].plans = osel_mem_alloc(sizeof(plan_t) * plan_count);
|
||
if (config->processes[i].plans != NULL)
|
||
{
|
||
for (uint8_t j = 0; j < plan_count; j++)
|
||
{
|
||
config->processes[i].plans[j].action_count = action_count;
|
||
config->processes[i].plans[j].actions = osel_mem_alloc(sizeof(action_t) * action_count);
|
||
if (config->processes[i].plans[j].actions == NULL)
|
||
{
|
||
config_free(config);
|
||
return NULL;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
config_free(config);
|
||
return NULL;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
config_free(config);
|
||
return NULL;
|
||
}
|
||
}
|
||
return config;
|
||
}
|
||
|
||
/**
|
||
* @description: 二进制数据转换为配置参数
|
||
* @param {uint8_t} *data
|
||
* @param {uint16_t} len
|
||
* @return {*}
|
||
*/
|
||
config_t *data_convert_config(uint8_t *data, uint16_t len)
|
||
{
|
||
uint16_t length = 0;
|
||
uint16_t offset = 0;
|
||
uint8_t process_count = 0, plan_count = 0, action_count = 0;
|
||
|
||
if (g_config != NULL)
|
||
{
|
||
config_free(g_config);
|
||
g_config = NULL;
|
||
}
|
||
|
||
g_config = osel_mem_alloc(sizeof(config_t));
|
||
|
||
osel_memset((uint8_t *)g_config, 0, sizeof(config_t));
|
||
length = length;
|
||
length = BUILD_UINT16(data[1], data[0]);
|
||
|
||
offset += 2;
|
||
process_count = data[offset];
|
||
offset++;
|
||
g_config->processes = (process_t *)osel_mem_alloc(process_count * sizeof(process_t));
|
||
g_config->process_count = process_count;
|
||
|
||
for (uint8_t i = 0; i < process_count; i++)
|
||
{
|
||
length = BUILD_UINT16(data[offset + 1], data[offset]);
|
||
offset += 2;
|
||
plan_count = data[offset];
|
||
offset++;
|
||
g_config->processes[i].plans = (plan_t *)osel_mem_alloc(plan_count * sizeof(plan_t));
|
||
g_config->processes[i].plan_count = plan_count;
|
||
|
||
for (uint8_t j = 0; j < plan_count; j++)
|
||
{
|
||
length = BUILD_UINT16(data[offset + 1], data[offset]);
|
||
offset += 2;
|
||
action_count = data[offset];
|
||
offset++;
|
||
g_config->processes[i].plans[j].actions = (action_t *)osel_mem_alloc(action_count * sizeof(action_t));
|
||
g_config->processes[i].plans[j].action_count = action_count;
|
||
for (uint8_t k = 0; k < action_count; k++)
|
||
{
|
||
osel_memcpy((uint8_t *)&g_config->processes[i].plans[j].actions[k], &data[offset], sizeof(action_t));
|
||
offset += sizeof(action_t);
|
||
}
|
||
}
|
||
}
|
||
|
||
return g_config;
|
||
}
|
||
|
||
/**
|
||
* @description: 配置请求结构体转换为pbuf
|
||
* @param {config_t} config
|
||
* @param {pbuf_t} *
|
||
* @return {*}
|
||
*/
|
||
void config_convert_pbuf(config_t config, pbuf_t **const pbuf)
|
||
{
|
||
uint8_t *process_ptr, *plan_ptr, *action_ptr;
|
||
uint16_t length = 0;
|
||
uint16_t offset = 0;
|
||
uint8_t process_count = 0, plan_count = 0, action_count = 0;
|
||
process_t *processes_ptr;
|
||
plan_t *plans_ptr;
|
||
action_t *actions_ptr;
|
||
if (config.processes == NULL)
|
||
{
|
||
return;
|
||
}
|
||
process_count = config.process_count;
|
||
offset = (*pbuf)->data_len; // data_len初始不是为0，在app层已经赋值用来存储长度
|
||
// 填写流程的长度
|
||
process_ptr = &(*pbuf)->data_p[offset];
|
||
offset += 2;
|
||
// 填写流程数量
|
||
(*pbuf)->data_p[offset] = process_count;
|
||
offset++;
|
||
processes_ptr = config.processes;
|
||
|
||
for (uint8_t i = 0; i < process_count; i++)
|
||
{
|
||
processes_ptr += i * sizeof(process_t);
|
||
plans_ptr = processes_ptr->plans;
|
||
plan_count = processes_ptr->plan_count;
|
||
// 填写流程1的长度
|
||
plan_ptr = &(*pbuf)->data_p[offset];
|
||
offset += 2;
|
||
// 填写流程1方案数量
|
||
(*pbuf)->data_p[offset] = plan_count;
|
||
offset++;
|
||
|
||
for (uint8_t j = 0; j < plan_count; j++)
|
||
{
|
||
plans_ptr += j * sizeof(plan_t);
|
||
actions_ptr = plans_ptr->actions;
|
||
|
||
action_count = plans_ptr->action_count;
|
||
// 填写方案1的长度
|
||
action_ptr = &(*pbuf)->data_p[offset];
|
||
offset += 2;
|
||
// 填写方案1动作数量
|
||
(*pbuf)->data_p[offset] = action_count;
|
||
offset++;
|
||
for (uint8_t k = 0; k < action_count; k++)
|
||
{
|
||
osel_memcpy(&(*pbuf)->data_p[offset], (uint8_t *)(&actions_ptr[k]), sizeof(action_t));
|
||
offset += sizeof(action_t);
|
||
}
|
||
length = (&(*pbuf)->data_p[offset] - action_ptr);
|
||
length = S2B_UINT16(length - 2);
|
||
osel_memcpy(action_ptr, (uint8_t *)&length, 2);
|
||
}
|
||
|
||
length = (&(*pbuf)->data_p[offset] - plan_ptr);
|
||
length = S2B_UINT16(length - 2);
|
||
osel_memcpy(plan_ptr, (uint8_t *)&length, 2);
|
||
}
|
||
|
||
length = (&(*pbuf)->data_p[offset] - process_ptr);
|
||
length = S2B_UINT16(length - 2);
|
||
osel_memcpy(process_ptr, (uint8_t *)&length, 2);
|
||
(*pbuf)->data_len = offset;
|
||
}
|
||
|
||
config_t *mock_commond_req_config(void)
|
||
{
|
||
config_t *config;
|
||
uint8_t action_count = 6, plan_count = 1, process_count = 1;
|
||
action_t action;
|
||
valve_t valve;
|
||
uint8_t action_offset = 0;
|
||
|
||
config = config_alloc(process_count, plan_count, action_count);
|
||
|
||
// 打开两通阀6
|
||
osel_memset((uint8_t *)&action, 0, sizeof(action_t));
|
||
osel_memset((uint8_t *)&valve, 0, sizeof(valve_t));
|
||
valve.valve_type = UNIT_TWO_WAY_VALVE;
|
||
valve.no = 4;
|
||
valve.data.open = true;
|
||
action.type = ACTION_VALVE;
|
||
osel_memcpy((uint8_t *)&action.data.valve, (uint8_t *)&valve, sizeof(valve_t));
|
||
osel_memcpy((uint8_t *)(&config->processes->plans->actions[action_offset]), (uint8_t *)&action, sizeof(action_t));
|
||
action_offset++;
|
||
|
||
// 等待1秒
|
||
osel_memset((uint8_t *)&action, 0, sizeof(action_t));
|
||
osel_memset((uint8_t *)&valve, 0, sizeof(valve_t));
|
||
action.type = ACTION_WAIT;
|
||
action.data.sleep = S2B_UINT16(1000);
|
||
osel_memcpy((uint8_t *)(&config->processes->plans->actions[action_offset]), (uint8_t *)&action, sizeof(action_t));
|
||
action_offset++;
|
||
|
||
// 关闭两通阀6
|
||
osel_memset((uint8_t *)&action, 0, sizeof(action_t));
|
||
osel_memset((uint8_t *)&valve, 0, sizeof(valve_t));
|
||
valve.valve_type = UNIT_TWO_WAY_VALVE;
|
||
valve.no = 4;
|
||
valve.data.open = false;
|
||
action.type = ACTION_VALVE;
|
||
osel_memcpy((uint8_t *)&action.data.valve, (uint8_t *)&valve, sizeof(valve_t));
|
||
osel_memcpy((uint8_t *)(&config->processes->plans->actions[action_offset]), (uint8_t *)&action, sizeof(action_t));
|
||
action_offset++;
|
||
|
||
// 打开两通阀2
|
||
osel_memset((uint8_t *)&action, 0, sizeof(action_t));
|
||
osel_memset((uint8_t *)&valve, 0, sizeof(valve_t));
|
||
valve.valve_type = UNIT_TWO_WAY_VALVE;
|
||
valve.no = 2;
|
||
valve.data.open = true;
|
||
action.type = ACTION_VALVE;
|
||
osel_memcpy((uint8_t *)&action.data.valve, (uint8_t *)&valve, sizeof(valve_t));
|
||
osel_memcpy((uint8_t *)(&config->processes->plans->actions[action_offset]), (uint8_t *)&action, sizeof(action_t));
|
||
action_offset++;
|
||
// 等待2秒
|
||
osel_memset((uint8_t *)&action, 0, sizeof(action_t));
|
||
osel_memset((uint8_t *)&valve, 0, sizeof(valve_t));
|
||
action.type = ACTION_WAIT;
|
||
action.data.sleep = S2B_UINT16(2000);
|
||
osel_memcpy((uint8_t *)(&config->processes->plans->actions[action_offset]), (uint8_t *)&action, sizeof(action_t));
|
||
action_offset++;
|
||
// 开始测试
|
||
osel_memset((uint8_t *)&action, 0, sizeof(action_t));
|
||
osel_memset((uint8_t *)&valve, 0, sizeof(valve_t));
|
||
action.type = ACTION_WORK;
|
||
osel_memcpy((uint8_t *)(&config->processes->plans->actions[action_offset]), (uint8_t *)&action, sizeof(action_t));
|
||
action_offset++;
|
||
return config;
|
||
}
|
||
|
||
void calibration_sensor_free(calibration_sensor_t *data)
|
||
{
|
||
if (data != NULL)
|
||
{
|
||
if (data->sensor_data.sensors != NULL)
|
||
{
|
||
osel_mem_free(data->sensor_data.sensors);
|
||
}
|
||
osel_mem_free(data);
|
||
}
|
||
}
|
||
/**
|
||
* @description:二进制数据转换为标定传感器结构体
|
||
* @param {uint8_t} *data
|
||
* @param {uint16_t} len
|
||
* @return {*}
|
||
*/
|
||
calibration_sensor_t *data_convert_calibration_sensor(uint8_t *data, uint16_t len)
|
||
{
|
||
uint16_t offset = 0;
|
||
if (g_calibration_sensor != NULL)
|
||
{
|
||
calibration_sensor_free(g_calibration_sensor);
|
||
g_calibration_sensor = NULL;
|
||
}
|
||
|
||
g_calibration_sensor = osel_mem_alloc(sizeof(calibration_sensor_t));
|
||
g_calibration_sensor->state = data[offset];
|
||
offset += 1;
|
||
|
||
g_calibration_sensor->sensor_data.count = data[offset];
|
||
offset += 1;
|
||
if (g_calibration_sensor->sensor_data.count > 0)
|
||
{
|
||
g_calibration_sensor->sensor_data.sensors = osel_mem_alloc(sizeof(query_data_sensor_t) * g_calibration_sensor->sensor_data.count);
|
||
}
|
||
for (uint8_t i = 0; i < g_calibration_sensor->sensor_data.count; i++)
|
||
{
|
||
osel_memcpy((uint8_t *)&g_calibration_sensor->sensor_data.sensors[i], &data[offset], sizeof(query_data_sensor_t));
|
||
offset += sizeof(query_data_sensor_t);
|
||
}
|
||
return g_calibration_sensor;
|
||
}
|
||
|
||
void calibration_sensor_convert_pbuf(calibration_sensor_t calibration_sensor, pbuf_t **const pbuf)
|
||
{
|
||
uint16_t offset = 0;
|
||
(*pbuf)->data_p[offset] = calibration_sensor.state;
|
||
offset++;
|
||
|
||
(*pbuf)->data_p[offset] = calibration_sensor.sensor_data.count;
|
||
offset++;
|
||
for (uint8_t i = 0; i < calibration_sensor.sensor_data.count; i++)
|
||
{
|
||
osel_memcpy((uint8_t *)&(*pbuf)->data_p[offset], (uint8_t *)&calibration_sensor.sensor_data.sensors[i], sizeof(query_data_sensor_t));
|
||
offset += sizeof(query_data_sensor_t);
|
||
}
|
||
(*pbuf)->data_len = offset;
|
||
}
|
||
|
||
static void query_data_free(query_data_t *data)
|
||
{
|
||
if (data != NULL)
|
||
{
|
||
if (data->sensors != NULL)
|
||
{
|
||
osel_mem_free(data->sensors);
|
||
}
|
||
osel_mem_free(data);
|
||
}
|
||
}
|
||
/**
|
||
* @description:二进制数据转换为查询数据结构体
|
||
* @param {uint8_t} *data
|
||
* @param {uint16_t} len
|
||
* @return {*}
|
||
*/
|
||
query_data_t *data_convert_query_data(uint8_t *data, uint16_t len)
|
||
{
|
||
uint16_t offset = 0;
|
||
if (g_query_data != NULL)
|
||
{
|
||
query_data_free(g_query_data);
|
||
g_query_data = NULL;
|
||
}
|
||
g_query_data = osel_mem_alloc(sizeof(query_data_t));
|
||
g_query_data->count = data[offset];
|
||
offset += 1;
|
||
if (g_query_data->count > 0)
|
||
{
|
||
g_query_data->sensors = osel_mem_alloc(sizeof(query_data_sensor_t) * g_query_data->count);
|
||
}
|
||
for (uint8_t i = 0; i < g_query_data->count; i++)
|
||
{
|
||
osel_memcpy((uint8_t *)&g_query_data->sensors[i], &data[offset], sizeof(query_data_sensor_t));
|
||
offset += sizeof(query_data_sensor_t);
|
||
}
|
||
|
||
return g_query_data;
|
||
}
|
||
|
||
void query_data_convert_pbuf(query_data_rsp_t *query_data, uint8_t count, pbuf_t **const pbuf)
|
||
{
|
||
uint16_t offset = 0;
|
||
uint8_t len = 0;
|
||
uint8_t *len_ptr;
|
||
query_data_rsp_t *ptr = query_data;
|
||
|
||
(*pbuf)->data_p[offset] = count;
|
||
offset++;
|
||
for (uint8_t i = 0; i < count; i++)
|
||
{
|
||
(*pbuf)->data_p[offset] = ptr->sensor_class;
|
||
offset++;
|
||
(*pbuf)->data_p[offset] = ptr->sensor.data;
|
||
offset++;
|
||
len_ptr = &(*pbuf)->data_p[offset];
|
||
offset++;
|
||
for (uint8_t j = 0; j < ptr->count; j++)
|
||
{
|
||
ptr->data[j].c = B2S_UINT32(ptr->data[j].c);
|
||
osel_memcpy((uint8_t *)&(*pbuf)->data_p[offset], (uint8_t *)&ptr->data[j].c, sizeof(uint32_t));
|
||
offset += sizeof(uint32_t);
|
||
len += sizeof(uint32_t);
|
||
}
|
||
*len_ptr = len;
|
||
ptr++;
|
||
len = 0;
|
||
}
|
||
(*pbuf)->data_len = offset;
|
||
osel_mem_free(query_data); // 释放内存
|
||
}
|