1254 lines
40 KiB
C
1254 lines
40 KiB
C
#include "../inc/hart_master.h"
|
||
#include "../inc/hart_master_req.h"
|
||
|
||
static hart_master_init_t *handle;
|
||
|
||
// 主机请求指令
|
||
|
||
/**
|
||
* @brief hart主机请求指令不需要携带数据域
|
||
* @param {hart_command_req_data_u} *data: 请求指令数据
|
||
* @param {uint8_t} **resp: 待填充数据的区间，指针的指针
|
||
* @return: TRUE: 处理成功
|
||
* FALSE: 处理失败
|
||
*/
|
||
BOOL hart_master_command_without_data_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
// 数据个数为0不需要填充数据域
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入轮训地址
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_6_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_6.poll_address; // 设备的轮询地址
|
||
if (hart_get_current_protocol_version() == HART_PROTOCOL_VERSION_7)
|
||
{
|
||
*resp->data_p++ = req->data.command_6.loop_current_mode; // 回路电流模式
|
||
}
|
||
return TRUE;
|
||
}
|
||
/**
|
||
* @brief 读取具有状态的设备变量
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_9_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = DIN_245; // slot0
|
||
*resp->data_p++ = DIN_246; // slot1
|
||
*resp->data_p++ = DIN_247; // slot2
|
||
*resp->data_p++ = DIN_248; // slot3
|
||
*resp->data_p++ = DIN_249; // slot4
|
||
*resp->data_p++ = DIN_250; // slot5
|
||
*resp->data_p++ = DIN_250; // slot6
|
||
*resp->data_p++ = DIN_250; // slot7
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取与标签关联的唯一标识符V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_11_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
for (uint8_t i = 0; i < HART_PACKED6_LEN; i++)
|
||
{
|
||
*resp->data_p++ = req->data.command_11.tag[i];
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入消息V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_17_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
for (uint8_t i = 0; i < HART_PACKED24_LEN; i++)
|
||
{
|
||
*resp->data_p++ = req->data.command_17.message[i];
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写标签、描述符、日期
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_18_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
for (uint8_t i = 0; i < HART_PACKED6_LEN; i++)
|
||
{
|
||
*resp->data_p++ = req->data.command_18.tag[i];
|
||
}
|
||
for (uint8_t i = 0; i < HART_PACKED12_LEN; i++)
|
||
{
|
||
*resp->data_p++ = req->data.command_18.descriptor[i];
|
||
}
|
||
for (uint8_t i = 0; i < HART_DATE_LEN; i++)
|
||
{
|
||
*resp->data_p++ = req->data.command_18.date[i];
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 编写总装编号
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_19_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
osel_memcpy(resp->data_p, req->data.command_19.final_assembly_number, HART_PACKED3_LEN);
|
||
resp->data_p += HART_PACKED3_LEN;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取与长标签关联的唯一标识符
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_21_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
for (uint8_t i = 0; i < HART_PACKED32_LEN; i++)
|
||
{
|
||
*resp->data_p++ = req->data.command_21.long_tag[i];
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写长标签
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_22_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
for (uint8_t i = 0; i < HART_PACKED32_LEN; i++)
|
||
{
|
||
*resp->data_p++ = req->data.command_22.long_tag[i];
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 重置配置更改标志
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_38_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
uint16_t configuration_change_counter = req->data.command_38.configuration_change_counter;
|
||
configuration_change_counter = B2S_UINT16(configuration_change_counter);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&configuration_change_counter, sizeof(uint16_t));
|
||
resp->data_p += sizeof(uint16_t);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取设备变量V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_33_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
osel_memcpy(resp->data_p, (uint8_t *)&req->data.command_33, sizeof(hart_command_33_t));
|
||
resp->data_p += sizeof(hart_command_33_t);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入主变量阻尼值V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_34_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
float32_u tmp;
|
||
tmp.f = req->data.command_34.pv_damping_value;
|
||
tmp.c = S2B_UINT32(tmp.c);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
|
||
resp->data_p += sizeof(float32_u);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入主变量范围值V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_35_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
float32_u tmp;
|
||
*resp->data_p++ = req->data.command_35.pv_upper_and_lower_range_values_units_code;
|
||
|
||
tmp.f = req->data.command_35.pv_upper_range_value;
|
||
tmp.c = S2B_UINT32(tmp.c);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
|
||
resp->data_p += sizeof(float32_u);
|
||
|
||
tmp.f = req->data.command_35.pv_lower_range_value;
|
||
tmp.c = S2B_UINT32(tmp.c);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
|
||
resp->data_p += sizeof(float32_u);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief EEPROM控制V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_39_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_39.control_code;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 进入/退出固定电流模式V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_40_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
float32_u tmp;
|
||
tmp.f = req->data.command_40.pv_fixed_current_level;
|
||
tmp.c = S2B_UINT32(tmp.c);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
|
||
resp->data_p += sizeof(float32_u);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 编写主变量单元V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_44_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_44.pv_units_code;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 微调回路电流归零
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_45_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
float32_u tmp;
|
||
tmp.f = req->data.command_45.pv_loop_current_level;
|
||
tmp.c = S2B_UINT32(tmp.c);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
|
||
resp->data_p += sizeof(float32_u);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 微调回路电流增益
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_46_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
float32_u tmp;
|
||
tmp.f = req->data.command_46.pv_loop_current_level;
|
||
tmp.c = S2B_UINT32(tmp.c);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
|
||
resp->data_p += sizeof(float32_u);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 编写主变量传递函数V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_47_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_47.pv_transfer_function_code;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入主变量传感器序列号V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_49_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
osel_memcpy(resp->data_p, req->data.command_49.pv_transducer_serial_number.bs, sizeof(uint24_t));
|
||
resp->data_p += sizeof(uint24_t);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 编写动态变量赋值V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_51_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
for (uint8_t i = 0; i < ARRAY_LEN(req->data.command_51.device_ariables); i++)
|
||
{
|
||
*resp->data_p++ = req->data.command_51.device_ariables[i];
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 设置设备变量零V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_52_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_52.device_ariable;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入设备变量单位V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_53_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
osel_memcpy(resp->data_p, (uint8_t *)&req->data.command_53.device_ariable, sizeof(hart_command_53_t));
|
||
resp->data_p += sizeof(hart_command_53_t);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取设备变量信息V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_54_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_54.device_ariable;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入设备可变阻尼值V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_55_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
float32_u tmp;
|
||
*resp->data_p++ = req->data.command_55.device_ariable;
|
||
tmp.f = req->data.command_55.damping_value;
|
||
tmp.c = S2B_UINT32(tmp.c);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u)); // 设备可变阻尼值
|
||
resp->data_p += sizeof(float32_u);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入设备可变传感器序列号V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_56_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
osel_memcpy(resp->data_p, (uint8_t *)&req->data.command_56, sizeof(hart_command_56_t));
|
||
resp->data_p += sizeof(hart_command_56_t);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 编写单位标签、描述符、日期V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_58_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
osel_memcpy(resp->data_p, (uint8_t *)&req->data.command_58, sizeof(hart_command_58_t));
|
||
resp->data_p += sizeof(hart_command_58_t);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入响应序码数V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_59_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_59.s2m_preambles;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief读取模拟通道和范围百分比V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_60_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_60.analog_channel_number_code;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取模拟通道V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_62_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
osel_memcpy(resp->data_p, (uint8_t *)&req->data.command_62, sizeof(hart_command_62_t));
|
||
resp->data_p += sizeof(hart_command_62_t);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取模拟通道信息V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_63_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_63.analog_channel_number_code;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入模拟通道附加阻尼值V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_64_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
float32_u tmp;
|
||
*resp->data_p++ = req->data.command_64.analog_channel_number_code;
|
||
tmp.f = req->data.command_64.damping_value;
|
||
tmp.c = S2B_UINT32(tmp.c);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u)); // 模拟通道附加阻尼值
|
||
resp->data_p += sizeof(float32_u);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入模拟通道范围值V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_65_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
float32_u tmp;
|
||
*resp->data_p++ = req->data.command_65.analog_channel_number_code;
|
||
*resp->data_p++ = req->data.command_65.upper_and_lower_range_values_units_code;
|
||
|
||
tmp.f = req->data.command_65.upper_range_value;
|
||
tmp.c = S2B_UINT32(tmp.c);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u)); // 模拟通道上限值
|
||
resp->data_p += sizeof(float32_u);
|
||
|
||
tmp.f = req->data.command_65.lower_range_value;
|
||
tmp.c = S2B_UINT32(tmp.c);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u)); // 模拟通道下限值
|
||
resp->data_p += sizeof(float32_u);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 进入/退出固定模拟通道模式V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_66_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
float32_u tmp;
|
||
*resp->data_p++ = req->data.command_66.analog_channel_number_code;
|
||
*resp->data_p++ = req->data.command_66.units_code;
|
||
osel_memcpy((uint8_t *)&tmp.c, (uint8_t *)&req->data.command_66.fixed_analog_channel_level, sizeof(int32_t));
|
||
tmp.c = S2B_UINT32(tmp.c);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
|
||
resp->data_p += sizeof(float32_u);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 调整模拟通道零V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_67_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
float32_u tmp;
|
||
*resp->data_p++ = req->data.command_67.analog_channel_number_code;
|
||
*resp->data_p++ = req->data.command_67.units_code;
|
||
osel_memcpy((uint8_t *)&tmp.c, (uint8_t *)&req->data.command_67.actual_analog_channel_level, sizeof(int32_t));
|
||
tmp.c = S2B_UINT32(tmp.c);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
|
||
resp->data_p += sizeof(float32_u);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 微调模拟通道增益V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_68_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
float32_u tmp;
|
||
*resp->data_p++ = req->data.command_68.analog_channel_number_code;
|
||
*resp->data_p++ = req->data.command_68.units_code;
|
||
osel_memcpy((uint8_t *)&tmp.c, (uint8_t *)&req->data.command_68.externally_measured_analog_channel_level, sizeof(int32_t));
|
||
tmp.c = S2B_UINT32(tmp.c);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
|
||
resp->data_p += sizeof(float32_u);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入模拟通道传递函数V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_69_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_69.analog_channel_number_code;
|
||
*resp->data_p++ = req->data.command_69.transfer_function_code;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取模拟通道端点值V5
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_70_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_70.analog_channel_number_code;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 锁定装置
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_71_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_71.lock_code;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 呼叫
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_72_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_72.squawk_control_code;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取I/O系统功能
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_74_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
// 判断是否是广播地址
|
||
if (!is_broadcast_address((uint8_t *)&req->address, HART_LONG_ADDRESS_LEN))
|
||
{
|
||
return FALSE;
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 轮询子设备
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_75_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
if (!is_broadcast_address((uint8_t *)&req->address, HART_LONG_ADDRESS_LEN))
|
||
{
|
||
return FALSE;
|
||
}
|
||
*resp->data_p++ = req->data.command_75.card;
|
||
*resp->data_p++ = req->data.command_75.channel;
|
||
*resp->data_p++ = req->data.command_75.poll_address;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 向子设备发送命令
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_77_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL hart_master_command_78_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入设备变量
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_79_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
float32_u tmp;
|
||
*resp->data_p++ = req->data.command_79.device_ariable;
|
||
*resp->data_p++ = req->data.command_79.device_ariable_command_code;
|
||
*resp->data_p++ = req->data.command_79.device_ariable_unit_code;
|
||
|
||
tmp.f = req->data.command_79.device_ariable_value;
|
||
tmp.c = S2B_UINT32(tmp.c);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
|
||
resp->data_p += sizeof(float32_u);
|
||
|
||
*resp->data_p++ = req->data.command_79.status;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取设备可变微调点
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_80_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_80.device_ariable;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取设备变量调整指南
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_81_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_81.device_ariable;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入设备可变微调点
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_82_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
float32_u tmp;
|
||
*resp->data_p++ = req->data.command_82.device_ariable;
|
||
*resp->data_p++ = req->data.command_82.trim_points;
|
||
*resp->data_p++ = req->data.command_82.units_code;
|
||
|
||
tmp.f = req->data.command_82.value;
|
||
tmp.c = S2B_UINT32(tmp.c);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
|
||
resp->data_p += sizeof(float32_u);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 重置设备变量调整
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_83_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_83.device_ariable;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取子设备标识摘要
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_84_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
// 判断是否是广播地址
|
||
if (!is_broadcast_address((uint8_t *)&req->address, HART_LONG_ADDRESS_LEN))
|
||
{
|
||
return FALSE;
|
||
}
|
||
*resp->data_p++ = HI_UINT16(req->data.command_84.identifier);
|
||
*resp->data_p++ = LO_UINT16(req->data.command_84.identifier);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取I/O通道统计信息
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_85_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
// 判断是否是广播地址
|
||
if (!is_broadcast_address((uint8_t *)&req->address, HART_LONG_ADDRESS_LEN))
|
||
{
|
||
return FALSE;
|
||
}
|
||
*resp->data_p++ = req->data.command_85.card;
|
||
*resp->data_p++ = req->data.command_85.channel;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取子设备统计信息
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_86_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
// 判断是否是广播地址
|
||
if (!is_broadcast_address((uint8_t *)&req->address, HART_LONG_ADDRESS_LEN))
|
||
{
|
||
return FALSE;
|
||
}
|
||
*resp->data_p++ = HI_UINT16(req->data.command_86.identifier);
|
||
*resp->data_p++ = LO_UINT16(req->data.command_86.identifier);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入I/O系统主模式
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_87_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
// 判断是否是广播地址
|
||
if (!is_broadcast_address((uint8_t *)&req->address, HART_LONG_ADDRESS_LEN))
|
||
{
|
||
return FALSE;
|
||
}
|
||
*resp->data_p++ = req->data.command_87.master_mode;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入I/O系统重试计数
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_88_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
// 判断是否是广播地址
|
||
if (!is_broadcast_address((uint8_t *)&req->address, HART_LONG_ADDRESS_LEN))
|
||
{
|
||
return FALSE;
|
||
}
|
||
*resp->data_p++ = req->data.command_88.retry_count;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 设置实时时钟
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_89_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
uint32_t time = 0;
|
||
*resp->data_p++ = req->data.command_89.time_set_code;
|
||
osel_memcpy(resp->data_p, (uint8_t *)&req->data.command_89.date, HART_DATE_LEN);
|
||
resp->data_p += HART_DATE_LEN;
|
||
time = S2B_UINT32(req->data.command_89.time);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&time, sizeof(uint32_t));
|
||
resp->data_p += sizeof(uint32_t);
|
||
*resp->data_p++ = HI_UINT16(req->data.command_89.transmission_time);
|
||
*resp->data_p++ = LO_UINT16(req->data.command_89.transmission_time);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取趋势配置
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_91_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_91.trend_number;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入趋势配置
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_92_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
uint32_t time = 0;
|
||
*resp->data_p++ = req->data.command_92.trend_number;
|
||
*resp->data_p++ = req->data.command_92.trend_code;
|
||
*resp->data_p++ = req->data.command_92.device_variable_code;
|
||
time = req->data.command_92.trend_sample_interval;
|
||
time = S2B_UINT32(time);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&time, sizeof(uint32_t));
|
||
resp->data_p += sizeof(uint32_t);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取趋势
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_93_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_93.trend_number;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取同步操作
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_96_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_96.action_number;
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL hart_master_command_97_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
uint32_t time = 0;
|
||
*resp->data_p++ = req->data.command_97.action_number; // 动作号
|
||
*resp->data_p++ = req->data.command_97.action_control_code; // 动作控制码
|
||
*resp->data_p++ = req->data.command_97.device_variable_code; // 设备变量代码
|
||
*resp->data_p++ = HI_UINT16(req->data.command_97.command_number); // 命令号
|
||
*resp->data_p++ = LO_UINT16(req->data.command_97.command_number);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&req->data.command_97.trigger_date, HART_DATE_LEN); // 命令数据
|
||
resp->data_p += HART_DATE_LEN;
|
||
time = S2B_UINT32(req->data.command_97.trigger_time);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&time, sizeof(uint32_t));
|
||
resp->data_p += sizeof(uint32_t);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief读取命令操作
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_98_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_98.action_number;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 配置命令操作
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_99_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_99.action_number;
|
||
*resp->data_p++ = HI_UINT16(req->data.command_99.command_number); // 命令号
|
||
*resp->data_p++ = LO_UINT16(req->data.command_99.command_number);
|
||
*resp->data_p++ = req->data.command_99.command_data_length;
|
||
osel_memcpy(resp->data_p, (uint8_t *)req->data.command_99.command_data, req->data.command_99.command_data_length);
|
||
resp->data_p += req->data.command_99.command_data_length;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 写入主变量报警码
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_100_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_100.pv_alarm_selection_code;
|
||
return TRUE;
|
||
}
|
||
/**
|
||
* @brief 读取子设备到突发消息映射
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_101_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_101.burst_message;
|
||
return TRUE;
|
||
}
|
||
/**
|
||
* @brief将子设备映射到突发信息
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_102_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_102.burst_message;
|
||
*resp->data_p++ = HI_UINT16(req->data.command_102.sub_device_index);
|
||
*resp->data_p++ = LO_UINT16(req->data.command_102.sub_device_index);
|
||
return TRUE;
|
||
}
|
||
/**
|
||
* @brief 写入突发周期
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_103_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
uint32_t time = 0;
|
||
*resp->data_p++ = req->data.command_103.burst_message;
|
||
time = S2B_UINT32(req->data.command_103.update_period_time);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&time, sizeof(uint32_t));
|
||
resp->data_p += sizeof(uint32_t);
|
||
time = S2B_UINT32(req->data.command_103.max_update_period_time);
|
||
osel_memcpy(resp->data_p, (uint8_t *)&time, sizeof(uint32_t));
|
||
resp->data_p += sizeof(uint32_t);
|
||
return TRUE;
|
||
}
|
||
/**
|
||
* @brief 写入突发触发器
|
||
* @param {hart_command_req_t} *req
|
||
* @param {hart_response_t} *resp
|
||
* @return {*}
|
||
*/
|
||
BOOL hart_master_command_104_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
float32_u f;
|
||
f.f = req->data.command_104.trigger_level;
|
||
f.c = S2B_UINT32(f.c);
|
||
*resp->data_p++ = req->data.command_104.burst_message; // 突发消息编号
|
||
*resp->data_p++ = req->data.command_104.burst_message_trigger_code; // 突发触发器代码
|
||
*resp->data_p++ = req->data.command_104.device_variable_vlassification_for_trigger_level; // 触发器级别的设备变量分类
|
||
*resp->data_p++ = req->data.command_104.units_code; // 突发触发器单位代码
|
||
osel_memcpy(resp->data_p, (uint8_t *)&f, sizeof(float32_u)); // 触发电平
|
||
resp->data_p += sizeof(float32_u);
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL hart_master_command_105_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = req->data.command_105.burst_message;
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL hart_master_command_107_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
osel_memcpy(resp->data_p, (uint8_t *)&req->data.command_107, sizeof(hart_command_107_t));
|
||
resp->data_p += sizeof(hart_command_107_t);
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL hart_master_command_513_req(const hart_command_req_t *const req, hart_response_t *resp)
|
||
{
|
||
*resp->data_p++ = HI_UINT16(req->data.command_513.country_code);
|
||
*resp->data_p++ = LO_UINT16(req->data.command_513.country_code);
|
||
*resp->data_p++ = req->data.command_513.si_units_control_code;
|
||
return TRUE;
|
||
}
|
||
|
||
// 结束:主机请求指令
|
||
|
||
/**
|
||
* @brief 主机请求指令接口
|
||
* @param {hart_command_req_t} *req: 请求参数
|
||
* @return: TRUE: 请求成功
|
||
* FALSE: 请求失败
|
||
*/
|
||
BOOL hart_master_command_req(const hart_command_req_t *const req)
|
||
{
|
||
uint8_t rsp_len = 0; // 响应数据长度
|
||
uint8_t xor = 0; // 异或校验
|
||
uint8_t preamble_def = HART_PREAMBLE_DEFAULT_LEN; // 引导码默认长度
|
||
hart_delimiter_u delimiter; // 界定符
|
||
hart_short_address_u poll_address;
|
||
hart_long_address_u long_address;
|
||
uint8_t *data_len_p = NULL; // 数据长度指针
|
||
|
||
handle->response->data_length = 0;
|
||
handle->response->data_p = handle->response->data;
|
||
osel_memset((uint8_t *)handle->response->data, 0, HART_RESPONSE_MAX_LEN);
|
||
|
||
delimiter.data = 0;
|
||
osel_memset(&poll_address.data, 0, HART_SHORT_ADDRESS_LEN);
|
||
osel_memset((uint8_t *)&long_address.data, 0, HART_LONG_ADDRESS_LEN);
|
||
|
||
// 检查参数
|
||
if (!DBG_ASSERT(handle->response_call != NULL __DBG_LINE))
|
||
return FALSE;
|
||
|
||
// 检查请求命令
|
||
if (req->command > HART_COMMAND_MAX)
|
||
return FALSE;
|
||
|
||
if (FALSE == hart_is_support_command(req->command)) // 当前模式使用的版本号，请求命令是否支持
|
||
return FALSE;
|
||
|
||
// 检查界定符和命令关系： HART协议规定只有0号通用命令支持短帧格式,其他命令发送之前通过发送命令0获取设备长地址，除非使用长地址发送命令
|
||
if (req->command > HART_COMMAND_0)
|
||
{
|
||
if (!DBG_ASSERT(req->delimiter_type != HART_DELIMITER_TYPE_SHORT __DBG_LINE)) // 除命令0以外的数据帧都是长帧格式
|
||
return FALSE;
|
||
}
|
||
|
||
// 填充请求数据
|
||
|
||
// 填充引导码
|
||
if (req->delimiter_type == HART_DELIMITER_TYPE_SHORT && req->command == HART_COMMAND_0)
|
||
{
|
||
// 一般是5-20个0xFF, 它是一组同步传输的同步信号， 用以保证信息的同步。在开始通讯的时候，使用的是20个FF引导码，用以保证通讯的同步。
|
||
preamble_def = 20;
|
||
}
|
||
for (uint8_t i = 0; i < preamble_def; i++)
|
||
{
|
||
*handle->response->data_p++ = HART_PREAMBLE;
|
||
}
|
||
|
||
// 填充界定符。如果命令大于0xFF，填充界定符中的扩展字节数量
|
||
delimiter.bits.frame_type = HART_STX_FRAME;
|
||
delimiter.bits.addr_type = req->delimiter_type;
|
||
if (req->command < 0xFF)
|
||
{
|
||
delimiter.bits.ext_bytes = 0;
|
||
}
|
||
else
|
||
{
|
||
delimiter.bits.ext_bytes = 1;
|
||
}
|
||
*handle->response->data_p++ = delimiter.data;
|
||
|
||
// 填充地址
|
||
if (req->delimiter_type == HART_DELIMITER_TYPE_SHORT)
|
||
{
|
||
poll_address.bits.master = handle->address_bit;
|
||
poll_address.bits.slave = req->address[0];
|
||
*handle->response->data_p++ = poll_address.data;
|
||
}
|
||
else
|
||
{
|
||
long_address.bits.master = handle->address_bit;
|
||
long_address.bits.reserved = req->address[0];
|
||
// long_address.data.bs[0] = req->address[0];
|
||
osel_memcpy((uint8_t *)&long_address.bits.slave, &req->address[1], HART_LONG_ADDRESS_LEN - 1);
|
||
osel_memcpy(handle->response->data_p, (uint8_t *)&long_address.data, HART_LONG_ADDRESS_LEN); // 长地址5个字节
|
||
handle->response->data_p += HART_LONG_ADDRESS_LEN;
|
||
}
|
||
|
||
// 填充命令
|
||
if (delimiter.bits.ext_bytes == 0)
|
||
{
|
||
*handle->response->data_p++ = req->command;
|
||
}
|
||
else
|
||
{
|
||
// 目前为止扩展字节只有1个，所以只考虑1个的情况
|
||
uint16_t command = (uint16_t)(req->command);
|
||
*handle->response->data_p++ = HI_UINT16(command);
|
||
*handle->response->data_p++ = LO_UINT16(command);
|
||
}
|
||
|
||
if (hart_command_ptr_arr[req->command] != NULL)
|
||
{
|
||
// 检查数据域，并填充数据长度和数据
|
||
data_len_p = handle->response->data_p;
|
||
hart_frame_data_length_start(&data_len_p);
|
||
handle->response->data_p++;
|
||
if (!hart_command_ptr_arr[req->command](req, handle->response))
|
||
{
|
||
// TODO
|
||
return FALSE;
|
||
}
|
||
else
|
||
{
|
||
hart_frame_data_length_end(handle->response->data_p);
|
||
// 填充校验码
|
||
rsp_len = handle->response->data_p - handle->response->data;
|
||
xor = xor_compute(&handle->response->data[preamble_def], (rsp_len - preamble_def)); // 除前导码和校验字节外所有字节的异或之后
|
||
*handle->response->data_p++ = xor;
|
||
rsp_len++;
|
||
handle->response->data_length = rsp_len;
|
||
|
||
if (handle->response->data_length > 0)
|
||
{
|
||
handle->response_call(0, handle->response->data, handle->response->data_length);
|
||
}
|
||
return TRUE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
BOOL hart_master_req_init(const hart_master_init_t *const init)
|
||
{
|
||
if (!DBG_ASSERT(init != NULL __DBG_LINE))
|
||
return FALSE;
|
||
|
||
handle = (hart_master_init_t *)init;
|
||
// 初始化指令处理函数，指向hart_master_command_without_data_req，不需要携带数据域
|
||
for (uint16_t i = 0; i < HART_COMMAND_MAX; i++)
|
||
{
|
||
hart_command_ptr_arr[i] = hart_master_command_without_data_req;
|
||
}
|
||
// 需要携带数据域的指令处理函数，指向对应的处理函数
|
||
hart_command_ptr_arr[HART_COMMAND_6] = hart_master_command_6_req;
|
||
hart_command_ptr_arr[HART_COMMAND_9] = hart_master_command_9_req;
|
||
hart_command_ptr_arr[HART_COMMAND_11] = hart_master_command_11_req;
|
||
hart_command_ptr_arr[HART_COMMAND_17] = hart_master_command_17_req;
|
||
hart_command_ptr_arr[HART_COMMAND_18] = hart_master_command_18_req;
|
||
hart_command_ptr_arr[HART_COMMAND_19] = hart_master_command_19_req;
|
||
hart_command_ptr_arr[HART_COMMAND_21] = hart_master_command_21_req;
|
||
hart_command_ptr_arr[HART_COMMAND_22] = hart_master_command_22_req;
|
||
hart_command_ptr_arr[HART_COMMAND_38] = hart_master_command_38_req;
|
||
|
||
hart_command_ptr_arr[HART_COMMAND_33] = hart_master_command_33_req;
|
||
hart_command_ptr_arr[HART_COMMAND_34] = hart_master_command_34_req;
|
||
hart_command_ptr_arr[HART_COMMAND_35] = hart_master_command_35_req;
|
||
hart_command_ptr_arr[HART_COMMAND_39] = hart_master_command_39_req;
|
||
hart_command_ptr_arr[HART_COMMAND_40] = hart_master_command_40_req;
|
||
hart_command_ptr_arr[HART_COMMAND_44] = hart_master_command_44_req;
|
||
hart_command_ptr_arr[HART_COMMAND_45] = hart_master_command_45_req;
|
||
hart_command_ptr_arr[HART_COMMAND_46] = hart_master_command_46_req;
|
||
hart_command_ptr_arr[HART_COMMAND_47] = hart_master_command_47_req;
|
||
hart_command_ptr_arr[HART_COMMAND_49] = hart_master_command_49_req;
|
||
hart_command_ptr_arr[HART_COMMAND_51] = hart_master_command_51_req;
|
||
hart_command_ptr_arr[HART_COMMAND_52] = hart_master_command_52_req;
|
||
hart_command_ptr_arr[HART_COMMAND_53] = hart_master_command_53_req;
|
||
hart_command_ptr_arr[HART_COMMAND_54] = hart_master_command_54_req;
|
||
hart_command_ptr_arr[HART_COMMAND_55] = hart_master_command_55_req;
|
||
hart_command_ptr_arr[HART_COMMAND_56] = hart_master_command_56_req;
|
||
hart_command_ptr_arr[HART_COMMAND_58] = hart_master_command_58_req;
|
||
hart_command_ptr_arr[HART_COMMAND_59] = hart_master_command_59_req;
|
||
hart_command_ptr_arr[HART_COMMAND_60] = hart_master_command_60_req;
|
||
hart_command_ptr_arr[HART_COMMAND_62] = hart_master_command_62_req;
|
||
hart_command_ptr_arr[HART_COMMAND_63] = hart_master_command_63_req;
|
||
hart_command_ptr_arr[HART_COMMAND_64] = hart_master_command_64_req;
|
||
hart_command_ptr_arr[HART_COMMAND_65] = hart_master_command_65_req;
|
||
hart_command_ptr_arr[HART_COMMAND_66] = hart_master_command_66_req;
|
||
hart_command_ptr_arr[HART_COMMAND_67] = hart_master_command_67_req;
|
||
hart_command_ptr_arr[HART_COMMAND_68] = hart_master_command_68_req;
|
||
hart_command_ptr_arr[HART_COMMAND_69] = hart_master_command_69_req;
|
||
hart_command_ptr_arr[HART_COMMAND_70] = hart_master_command_70_req;
|
||
hart_command_ptr_arr[HART_COMMAND_71] = hart_master_command_71_req;
|
||
hart_command_ptr_arr[HART_COMMAND_72] = hart_master_command_72_req;
|
||
hart_command_ptr_arr[HART_COMMAND_74] = hart_master_command_74_req;
|
||
hart_command_ptr_arr[HART_COMMAND_75] = hart_master_command_75_req;
|
||
hart_command_ptr_arr[HART_COMMAND_77] = hart_master_command_77_req;
|
||
hart_command_ptr_arr[HART_COMMAND_78] = hart_master_command_78_req;
|
||
hart_command_ptr_arr[HART_COMMAND_79] = hart_master_command_79_req;
|
||
hart_command_ptr_arr[HART_COMMAND_80] = hart_master_command_80_req;
|
||
hart_command_ptr_arr[HART_COMMAND_81] = hart_master_command_81_req;
|
||
hart_command_ptr_arr[HART_COMMAND_82] = hart_master_command_82_req;
|
||
hart_command_ptr_arr[HART_COMMAND_83] = hart_master_command_83_req;
|
||
hart_command_ptr_arr[HART_COMMAND_84] = hart_master_command_84_req;
|
||
hart_command_ptr_arr[HART_COMMAND_85] = hart_master_command_85_req;
|
||
hart_command_ptr_arr[HART_COMMAND_86] = hart_master_command_86_req;
|
||
hart_command_ptr_arr[HART_COMMAND_87] = hart_master_command_87_req;
|
||
hart_command_ptr_arr[HART_COMMAND_88] = hart_master_command_88_req;
|
||
hart_command_ptr_arr[HART_COMMAND_89] = hart_master_command_89_req;
|
||
hart_command_ptr_arr[HART_COMMAND_91] = hart_master_command_91_req;
|
||
hart_command_ptr_arr[HART_COMMAND_92] = hart_master_command_92_req;
|
||
hart_command_ptr_arr[HART_COMMAND_93] = hart_master_command_93_req;
|
||
hart_command_ptr_arr[HART_COMMAND_96] = hart_master_command_96_req;
|
||
hart_command_ptr_arr[HART_COMMAND_97] = hart_master_command_97_req;
|
||
hart_command_ptr_arr[HART_COMMAND_98] = hart_master_command_98_req;
|
||
hart_command_ptr_arr[HART_COMMAND_99] = hart_master_command_99_req;
|
||
hart_command_ptr_arr[HART_COMMAND_100] = hart_master_command_100_req;
|
||
hart_command_ptr_arr[HART_COMMAND_101] = hart_master_command_101_req;
|
||
hart_command_ptr_arr[HART_COMMAND_102] = hart_master_command_102_req;
|
||
hart_command_ptr_arr[HART_COMMAND_103] = hart_master_command_103_req;
|
||
hart_command_ptr_arr[HART_COMMAND_104] = hart_master_command_104_req;
|
||
hart_command_ptr_arr[HART_COMMAND_105] = hart_master_command_105_req;
|
||
hart_command_ptr_arr[HART_COMMAND_107] = hart_master_command_107_req;
|
||
hart_command_ptr_arr[HART_COMMAND_513] = hart_master_command_513_req;
|
||
|
||
hart_master_req_init_user();
|
||
return TRUE;
|
||
}
|