1067 lines
37 KiB
C
1067 lines
37 KiB
C
|
||
#include "app.h"
|
||
#include "app_hart.h"
|
||
|
||
#include "mode.h"
|
||
#include "mode_diagnosis.h"
|
||
#include "menus.h"
|
||
|
||
specification_table_data_t spec_table_data __attribute__((section("NOINIT"), zero_init));
|
||
mode_diagnosis_test_t diagnosis_test;
|
||
/**
|
||
* @brief 更新映射表
|
||
* @return {*}
|
||
* @note
|
||
Failure(故障):3
|
||
Function Check(功能检查):5
|
||
Out of Specification(超出规格):4
|
||
Maintenance Required(需要维护):1
|
||
*/
|
||
static void update_compression_state_mapping_table(hart_condensed_status_map_u *const map)
|
||
{
|
||
DBG_ASSERT(map != NULL __DBG_LINE);
|
||
// 举例：当前输入电流 这里判断上限和下限
|
||
if (get_diagnosis_fault_result(DIAGNOSIS_INPUT) == FAIL)
|
||
{
|
||
map->bits.u1.csm_loop_current = HART_STATE_COMMAND_31_FAILURE;
|
||
}
|
||
else
|
||
{
|
||
if (get_diagnosis_fault_result(DIAGNOSIS_INPUT) == FAIL)
|
||
{
|
||
map->bits.u1.csm_loop_current = HART_STATE_COMMAND_31_FAILURE;
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 更新其他状态
|
||
*
|
||
* 根据当前情况更新其他状态信息。
|
||
*
|
||
* @param status 指向其他状态结构体的指针
|
||
*/
|
||
static void update_other_status(hart_other_status_u *const status)
|
||
{
|
||
DBG_ASSERT(status != NULL __DBG_LINE);
|
||
// 举例：参考电压故障
|
||
// status->bits.hard_failures.stem_position_sensor_fail = get_diagnosis_fault_result_of_enable_state(DIAGNOSIS_MAGNET);
|
||
// status->bits.hard_failures.pressure_sensor_fail = get_diagnosis_fault_result(DIAGNOSIS_PRESS_SENSOR);
|
||
// status->bits.hard_failures.temp_sensor_fail = get_diagnosis_fault_result(DIAGNOSIS_TEMPERATURE_SENSOR);
|
||
// status->bits.hard_failures.nvm_alert = get_diagnosis_fault_result(DIAGNOSIS_MICRO_LOOP);
|
||
// status->bits.hard_failures.drive_current_fail = get_diagnosis_fault_result(DIAGNOSIS_DRIVE_SIGNAL);
|
||
// status->bits.hard_failures.ref_voltage_fail_and_ram_fail = get_diagnosis_fault_result_of_enable_state(DIAGNOSIS_VREF);
|
||
// status->bits.hard_failures.mlfb_sensor_fail_and_no_free_time = get_diagnosis_fault_result_of_enable_state(DIAGNOSIS_MICRO_LOOP);
|
||
// status->bits.hard_failures.flash_crc_error = get_diagnosis_fault_result_of_enable_state(DIAGNOSIS_FLASH_INTEGRITY);
|
||
|
||
// status->bits.status_integ_1.auto_cal_in_progress6k_and_auto_tune_in_progress6k = (get_diagnosis_fault_result_of_enable_state(INDICATE_AUTO_CALIBRATION) || get_diagnosis_fault_result_of_enable_state(INDICATE_CALIBRATION));
|
||
if (get_diagnosis_fault_result(DIAGNOSIS_VREF) == FAIL)
|
||
{
|
||
status->bits.hard_failures.ref_voltage_fail_and_ram_fail = FAIL;
|
||
}
|
||
else
|
||
{
|
||
// RAM故障：这里不检测RAM故障
|
||
}
|
||
}
|
||
|
||
// 133-获取打开的文件信息
|
||
static BOOL hart_read_file_information_req(hart_user_req_t *const req)
|
||
{
|
||
hart_read_file_information_t rsp;
|
||
hart_command_133_t *cmd = &req->data.command_133;
|
||
osel_memset((uint8_t *)&rsp, 0, sizeof(hart_read_file_information_t));
|
||
switch (cmd->file_id)
|
||
{
|
||
case DVC_FILE_ID_DIAG_DATA_BUFFER:
|
||
rsp.readwrite_bytes = mode_diagnosis_get_storage()->file_size_written;
|
||
rsp.max_bytes = mode_diagnosis_get_storage()->file_size;
|
||
rsp.write_access_control = mode_diagnosis_get_storage()->file_status;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
// 回复数据
|
||
rsp.readwrite_bytes = S2B_UINT16(rsp.readwrite_bytes);
|
||
rsp.max_bytes = S2B_UINT16(rsp.max_bytes);
|
||
|
||
req->rsp.len = sizeof(hart_read_file_information_t);
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, req->rsp.len);
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)&cmd, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 134-处理HART读取文件内容请求
|
||
* 读取内存表数据
|
||
* @param[in] req HART读取文件内容请求
|
||
* @return TRUE or FALSE
|
||
*/
|
||
static BOOL hart_file_read_req(hart_user_req_t *const req)
|
||
{
|
||
uint8_t offset = 0;
|
||
BOOL ret = FALSE;
|
||
hart_command_134_t *cmd = &req->data.command_134;
|
||
switch (cmd->file_index)
|
||
{
|
||
case DVC_FILE_ID_CUSTOM_CHAR:
|
||
{
|
||
uint16_t setpoiont = 0;
|
||
uint16_t value = 0;
|
||
custom_property_table_t *p = (custom_property_table_t *)&udevice.custom_property_table;
|
||
req->rsp.pbuf[offset] = p->points;
|
||
offset += 1;
|
||
for (uint8_t i = 0; i < p->points; i++)
|
||
{
|
||
setpoiont = S2B_UINT16(p->setpoint[i]);
|
||
osel_memcpy(&req->rsp.pbuf[offset], (uint8_t *)&setpoiont, sizeof(uint16_t));
|
||
offset += sizeof(uint16_t);
|
||
}
|
||
for (uint8_t i = 0; i < p->points; i++)
|
||
{
|
||
value = S2B_UINT16(p->value[i]);
|
||
osel_memcpy(&req->rsp.pbuf[offset], (uint8_t *)&value, sizeof(uint16_t));
|
||
offset += sizeof(uint16_t);
|
||
}
|
||
req->rsp.len = offset;
|
||
break;
|
||
}
|
||
|
||
case DVC_FILE_ID_DIAG_DATA_BUFFER:
|
||
{
|
||
if (cmd->read_length == 0)
|
||
{
|
||
return FALSE;
|
||
}
|
||
req->rsp.len = 0;
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
|
||
ret = mode_diagnosis_file_read(cmd->file_offset, cmd->read_length, req->rsp.pbuf, &req->rsp.len);
|
||
if (ret == FALSE)
|
||
{
|
||
req->rsp.len = 0;
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 135-处理HART写入文件内容请求
|
||
* 写入数据到内存表
|
||
* @param[in] req HART写入文件内容请求
|
||
* @return TRUE or FALSE
|
||
*/
|
||
static BOOL hart_file_write_req(hart_user_req_t *const req)
|
||
{
|
||
uint8_t offset = 0, remain = 0;
|
||
hart_command_135_t *cmd = &req->data.command_135;
|
||
switch (cmd->file_index)
|
||
{
|
||
case DVC_FILE_ID_CUSTOM_CHAR:
|
||
{
|
||
uint16_t value = 0;
|
||
uint8_t *source_ptr = cmd->pbuf;
|
||
uint8_t *target_ptr = (uint8_t *)&udevice.custom_property_table;
|
||
|
||
if (cmd->address == 0x0000)
|
||
{
|
||
*target_ptr = *source_ptr++;
|
||
target_ptr += sizeof(udevice.custom_property_table.points);
|
||
remain = req->data_length - 3 - sizeof(udevice.custom_property_table.points); // 减去已经读取的points和剩余数据头
|
||
}
|
||
else
|
||
{
|
||
remain = req->data_length - 3; // 根据地址计算剩余数据长度
|
||
target_ptr += cmd->address; // 移动到正确的目标位置
|
||
}
|
||
|
||
for (uint8_t i = 0; i < (remain >> 1) && i < udevice.custom_property_table.points; i++)
|
||
{ // 防止越界
|
||
osel_memcpy((uint8_t *)&value, source_ptr, sizeof(uint16_t));
|
||
value = B2S_UINT16(value);
|
||
osel_memcpy(target_ptr, (uint8_t *)&value, sizeof(uint16_t));
|
||
source_ptr += sizeof(uint16_t);
|
||
target_ptr += sizeof(uint16_t);
|
||
}
|
||
|
||
// 回复数据
|
||
offset = 0;
|
||
target_ptr = (uint8_t *)&udevice.custom_property_table;
|
||
req->rsp.len = req->data_length;
|
||
req->rsp.pbuf[offset++] = cmd->file_index;
|
||
uint16_t address = S2B_UINT16(cmd->address);
|
||
osel_memcpy(&req->rsp.pbuf[offset], (uint8_t *)&address, sizeof(uint16_t));
|
||
offset += sizeof(uint16_t);
|
||
|
||
if (cmd->address == 0x0000)
|
||
{
|
||
req->rsp.pbuf[offset++] = udevice.custom_property_table.points;
|
||
target_ptr += sizeof(udevice.custom_property_table.points);
|
||
}
|
||
else
|
||
{
|
||
target_ptr += cmd->address; // 移动到正确的目标位置
|
||
}
|
||
for (uint8_t i = 0; i < (remain >> 1); i++)
|
||
{
|
||
osel_memcpy((uint8_t *)&value, target_ptr, sizeof(uint16_t));
|
||
value = B2S_UINT16(value);
|
||
osel_memcpy(&req->rsp.pbuf[offset], (uint8_t *)&value, sizeof(uint16_t));
|
||
offset += sizeof(uint16_t);
|
||
target_ptr += sizeof(uint16_t);
|
||
}
|
||
break;
|
||
}
|
||
case DVC_FILE_ID_FACTORY_DEFAULTS: // TODO
|
||
return FALSE;
|
||
case DVC_FILE_ID_PARAMETER_IMPORT: // TODO
|
||
return FALSE;
|
||
default:
|
||
return FALSE;
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
// 136-读取/解除/写入EEPROM
|
||
static BOOL hart_epprom_multiple_operations(hart_user_req_t *const req)
|
||
{
|
||
hart_command_136_t *cmd = &req->data.command_136;
|
||
eeprom_lock_state_e state = EEPROM_STATE_UNLOCK;
|
||
switch (cmd->sub_cmd)
|
||
{
|
||
case EEPROM_COMMAND_WRITE:
|
||
state = (eeprom_lock_state_e)cmd->lock_type;
|
||
break;
|
||
case EEPROM_COMMAND_UNLOCK:
|
||
state = EEPROM_STATE_UNLOCK;
|
||
break;
|
||
case EEPROM_COMMAND_READ:
|
||
state = EEPROM_STATE_DIAGNOSTIOCS;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
// 回复数据
|
||
req->rsp.len = 1;
|
||
req->rsp.pbuf[0] = (uint8_t)state;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 142-处理HART自整定请求
|
||
*
|
||
* @param[in] req HART自整定请求
|
||
* @return TRUE or FALSE
|
||
*/
|
||
static BOOL hart_tuning_req(hart_user_req_t *const req)
|
||
{
|
||
hart_command_142_t *cmd = &req->data.command_142;
|
||
if (cmd->code == HART_TUNING_EXIT)
|
||
{
|
||
DBG_ASSERT(mode_get()->interface_req.mode_adjust_stop != NULL __DBG_LINE);
|
||
mode_get()->interface_req.mode_adjust_stop();
|
||
mode_get()->interface_req.mode_process_start();
|
||
params_restart_set(PARAMS_RESET_PRESSURE_SENSOR);
|
||
rt_data.flag.bits.tuning_enter = FALSE;
|
||
rt_data.flag.bits.auto_tuning_enter = FALSE;
|
||
}
|
||
else if (cmd->code == HART_TUNING_AUTO)
|
||
{
|
||
DBG_ASSERT(mode_get()->interface_req.mode_adjust_stop != NULL __DBG_LINE);
|
||
mode_get()->interface_req.mode_adjust_stop();
|
||
mode_get()->interface_req.mode_adjust_start();
|
||
mode_get()->adjust_initiate = ADJUST_INITIATE_EXTERNAL;
|
||
rt_data.flag.bits.auto_tuning_enter = TRUE;
|
||
}
|
||
else
|
||
{
|
||
if (cmd->code == HART_TUNING_ENTER)
|
||
{
|
||
rt_data.flag.bits.tuning_enter = TRUE;
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
// 109-突发模式控制
|
||
static BOOL hart_burst_mode_control_req(hart_user_req_t *const req)
|
||
{
|
||
hart_command_109_t *cmd = &req->data.command_109;
|
||
udevice.burst_mode = cmd->burst_mode == FALSE ? FALSE : TRUE;
|
||
switch (cmd->message_no)
|
||
{
|
||
case 0:
|
||
/* code */
|
||
break;
|
||
case 1:
|
||
/* code */
|
||
break;
|
||
case 2:
|
||
/* code */
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
uint16_t year = rt_save.real_time.date.year;
|
||
uint8_t month = rt_save.real_time.date.month;
|
||
uint8_t day = rt_save.real_time.date.day;
|
||
uint8_t hour = rt_save.real_time.date.hour;
|
||
uint8_t minute = rt_save.real_time.date.minute;
|
||
uint8_t second = rt_save.real_time.date.second;
|
||
hart_storage_variable_t *p = &hart_device_attribute.flash_variable;
|
||
uint8_t message[HART_PACKED32_LEN] = "";
|
||
sprintf((char *)message, "BURST %d-%d %02d-%02d-%02d %02d:%02d:%02d", cmd->burst_mode, cmd->message_no, year, month, day, hour, minute, second);
|
||
osel_memcpy(p->message, message, sizeof(message)); // 消息
|
||
|
||
// 回复数据
|
||
req->rsp.len = sizeof(hart_command_109_t);
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)cmd, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
// 144-读取阀门序列号
|
||
static BOOL hart_read_valve_sn_req(hart_user_req_t *const req)
|
||
{
|
||
req->rsp.len = VALVE_SERIAL_NUM_LEN;
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)udevice.valve_serial_num, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
// 145 读取仪器序列号
|
||
static BOOL hart_read_device_sn_req(hart_user_req_t *const req)
|
||
{
|
||
req->rsp.len = INST_SERIAL_NUM_LEN;
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)udevice.dev_serial_num, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
// 147-读取设备等级
|
||
static BOOL hart_read_device_level_req(hart_user_req_t *const req)
|
||
{
|
||
hart_command_147_t cmd;
|
||
cmd.seed = 0;
|
||
cmd.level = S2B_UINT16(udevice.dev_usfeatures);
|
||
cmd.update_count = 0;
|
||
req->rsp.len = sizeof(hart_command_147_t);
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)&cmd, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
// 149-设置仪器时间
|
||
static BOOL hart_set_dev_time_req(hart_user_req_t *const req)
|
||
{
|
||
uint32_t base_secs = HART_BASE_SECS; // 1980-01-01 0:0:0
|
||
hart_command_149_t rsp;
|
||
hart_command_149_t *cmd = &req->data.command_149;
|
||
rtc_date_t date;
|
||
rtc_time_t time;
|
||
stamp2time(base_secs + cmd->secs, &date, &time);
|
||
// 设置时钟
|
||
set_real_time(date.year, date.month, date.day, time.hour, time.minute, time.second);
|
||
|
||
// 回复数据
|
||
date.year = rt_save.real_time.date.year;
|
||
date.month = rt_save.real_time.date.month;
|
||
date.day = rt_save.real_time.date.day;
|
||
time.hour = rt_save.real_time.date.hour;
|
||
time.minute = rt_save.real_time.date.minute;
|
||
time.second = rt_save.real_time.date.second;
|
||
rsp.secs = time2stamp(&date, &time) - base_secs;
|
||
rsp.secs = S2B_UINT32(rsp.secs);
|
||
req->rsp.len = sizeof(hart_command_149_t);
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)&rsp, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
// 150-读取仪器时间
|
||
static BOOL hart_read_dev_time_req(hart_user_req_t *const req)
|
||
{
|
||
uint32_t base_secs = HART_BASE_SECS; // 1980-01-01 0:0:0
|
||
hart_command_150_t rsp;
|
||
|
||
rtc_date_t date;
|
||
rtc_time_t time;
|
||
|
||
// 回复数据
|
||
date.year = rt_save.real_time.date.year;
|
||
date.month = rt_save.real_time.date.month;
|
||
date.day = rt_save.real_time.date.day;
|
||
time.hour = rt_save.real_time.date.hour;
|
||
time.minute = rt_save.real_time.date.minute;
|
||
time.second = rt_save.real_time.date.second;
|
||
rsp.secs = time2stamp(&date, &time) - base_secs;
|
||
rsp.secs = S2B_UINT32(rsp.secs);
|
||
rsp.reserve = 0; ///< 保留
|
||
req->rsp.len = sizeof(hart_command_150_t);
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)&rsp, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
// 151-读取版本信息
|
||
static BOOL hart_read_version_req(hart_user_req_t *const req)
|
||
{
|
||
// 当前指令没有任何意义，只是为了模拟协议
|
||
hart_command_151_t cmd;
|
||
osel_memset((uint8_t *)&cmd, 0, sizeof(hart_command_151_t));
|
||
cmd.nvm_version = 1;
|
||
cmd.valvelink_version = 1;
|
||
cmd.date[0] = 0x05;
|
||
cmd.date[1] = 0x20;
|
||
cmd.date[2] = 0x23; // 这里是将十六进制按照十进制显示
|
||
cmd.reserve[0] = 0xef;
|
||
cmd.reserve[1] = 0x8a;
|
||
cmd.reserve[2] = 0x01;
|
||
req->rsp.len = sizeof(hart_command_151_t);
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)&cmd, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
// 153-读取校准记录
|
||
static BOOL hart_read_calibration_record_req(hart_user_req_t *const req)
|
||
{
|
||
hart_command_153_t cmd;
|
||
osel_memset((uint8_t *)&cmd, 0, sizeof(hart_command_153_t));
|
||
osel_memcpy((uint8_t *)&cmd, (uint8_t *)&udevice.calib_record, sizeof(hart_command_153_t));
|
||
req->rsp.len = sizeof(hart_command_153_t);
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)&cmd, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
// 168-读取部分行程报警
|
||
static BOOL hart_read_partial_stroke_alarm_req(hart_user_req_t *const req)
|
||
{
|
||
hart_command_168_t cmd;
|
||
osel_memset((uint8_t *)&cmd, 0, sizeof(hart_command_168_t));
|
||
osel_memcpy(cmd.pbuf, (uint8_t *)udevice.pst_prohibit_detail, ARRAY_LEN(udevice.pst_prohibit_detail));
|
||
req->rsp.len = sizeof(hart_command_168_t);
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)&cmd, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
// 170-读取制造信息序列号
|
||
static BOOL hart_read_manufacturing_sn_req(hart_user_req_t *const req)
|
||
{
|
||
uint8_t *pbuf = (uint8_t *)req->rsp.pbuf;
|
||
osel_memset(pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
uint8_t offset = 0;
|
||
// 类型
|
||
pbuf[offset++] = req->data.command_170.code;
|
||
req->rsp.len = 1;
|
||
// 数据
|
||
switch (req->data.command_170.code)
|
||
{
|
||
case HART_MAN_INFO:
|
||
osel_memcpy((uint8_t *)&pbuf[offset], (uint8_t *)udevice.man_info_serial_num, MAN_SERIAL_NUM_LEN);
|
||
break;
|
||
case HART_MAN_SCHEME:
|
||
osel_memcpy((uint8_t *)&pbuf[offset], (uint8_t *)udevice.man_scheme_serial_num, MAN_SERIAL_NUM_LEN);
|
||
break;
|
||
default:
|
||
return FALSE;
|
||
}
|
||
req->rsp.len += MAN_SERIAL_NUM_LEN;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
// 基金会测试指令 187
|
||
static BOOL hart_test_req(hart_user_req_t *const req)
|
||
{
|
||
uint8_t *pbuf = (uint8_t *)req->rsp.pbuf;
|
||
osel_memset(pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
uint8_t offset = 0;
|
||
// 类型
|
||
pbuf[offset++] = req->data.command_187.code;
|
||
req->rsp.len = 1;
|
||
|
||
switch (req->data.command_187.code)
|
||
{
|
||
case COMMAND_187_CLEAR_MORE_STATUS_BIT_AND_WRITE_PROTECT_OFF: // 清除更多状态位并关闭写保护
|
||
osel_memset((uint8_t *)&hart_device_attribute.device_status, 0, sizeof(hart_device_status_t));
|
||
hart_additional_device_status_crc_init();
|
||
hart_device_attribute.flash_variable.write_protect_code = WRITE_PROTECT_CODE_NOT_WRITE_PROTECT;
|
||
hart_storage_write_item(HART_STORAGE_PARAMS, HPB_WRITE_PROTECT_CODE,
|
||
(uint8_t *)&hart_device_attribute.flash_variable.write_protect_code);
|
||
hart_device_status_set_operational_state(DEVICE_OPERATIONAL_STATE_7);
|
||
break;
|
||
case COMMAND_187_SET_MORE_STATUS_AVAILABLE_STATUS_BIT: // 请更改设备条件以设置“更多状态可用”状态位
|
||
hart_device_attribute.device_status.additional_device_status.extended_device_status = EXTENDED_DEVICE_STATUS_1;
|
||
hart_device_status_set_operational_state(DEVICE_OPERATIONAL_STATE_5);
|
||
break;
|
||
case COMMAND_187_PLACE_DEVICE_INTO_WRITE_PROTECT: // 将设备置于写保护状态
|
||
hart_device_attribute.flash_variable.write_protect_code = WRITE_PROTECT_CODE_WRITE_PROTECT;
|
||
hart_storage_write_item(HART_STORAGE_PARAMS, HPB_WRITE_PROTECT_CODE,
|
||
(uint8_t *)&hart_device_attribute.flash_variable.write_protect_code);
|
||
hart_device_status_set_operational_state(DEVICE_OPERATIONAL_STATE_7);
|
||
break;
|
||
case COMMAND_187_RESET_IT_IN_COMMAND_48: // 请更改设备条件以重置命令48中设置的状态
|
||
hart_device_attribute.device_status.additional_device_status.extended_device_status = EXTENDED_DEVICE_STATUS_0;
|
||
hart_additional_device_status_crc_init();
|
||
hart_device_status_clr_operational_state(DEVICE_OPERATIONAL_STATE_5);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
// 200-读取NVW非易失性存储器数据
|
||
static BOOL hart_read_nvw_data_req(hart_user_req_t *const req)
|
||
{
|
||
uint8_t *pbuf = (uint8_t *)req->rsp.pbuf;
|
||
osel_memset(pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
|
||
/*
|
||
内容暂未实现
|
||
*/
|
||
req->rsp.len += B2S_UINT16(req->data.command_200.length - 2);
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
/**
|
||
* @brief 155-处理HART模式诊断请求
|
||
*
|
||
* @param[in] req HART模式诊断请求
|
||
* @return TRUE or FALSE
|
||
*/
|
||
static BOOL hart_mode_diagnosis_req(hart_user_req_t *const req)
|
||
{
|
||
hart_command_155_t *cmd = &req->data.command_155;
|
||
hart_diagnosis_t diag;
|
||
BOOL ret = FALSE;
|
||
if (udevice.control_mode != TEST_CTRL_MODE) // 在执行诊断前先需要设置控制模式
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
osel_memcpy((uint8_t *)&diag, cmd->pbuf, sizeof(hart_diagnosis_t));
|
||
diag.target = B2S_UINT16(diag.target);
|
||
diag.ramp = B2S_UINT16(diag.ramp);
|
||
diag.points = B2S_UINT16(diag.points);
|
||
if (diag.diag_type != DIAG_TYPE_OFFLINE_COMMANDED)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
if (diag.ramp != 0 && diag.points == 0)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
mode_diagnosis_file_head_u head;
|
||
osel_memset((uint8_t *)&head.slope, 0, sizeof(mode_diagnosis_slop_file_head_t));
|
||
osel_memcpy(head.slope.variable_code, diag.variable_code, HART_PACKED4_LEN); // 设备变量
|
||
head.slope.sampling_time = diag.sampling_time; // 采样时间
|
||
head.slope.target = diag.target; // 目标位置
|
||
head.slope.ramp = diag.ramp; // 斜率
|
||
head.slope.points = diag.points;
|
||
mode_get()->interface_req.mode_process_start();
|
||
ret = mode_diagnosis_start(MODE_DIAGNOSIS_TYPE_SLOPE_STEP, &head);
|
||
|
||
if (ret == TRUE)
|
||
{
|
||
gui_clr();
|
||
mode_enter_test(TEST_ITEM_DIAGNOSIS);
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
|
||
/**
|
||
* @brief 156-读取诊断状态
|
||
*
|
||
* @param[in] req HART模式诊断请求
|
||
* @return TRUE or FALSE
|
||
*/
|
||
static BOOL hart_read_diagnosis_state_req(hart_user_req_t *const req)
|
||
{
|
||
diagnosis_state_u state;
|
||
state.data = 0;
|
||
|
||
// 测试数据
|
||
state.bits.is_in_diagnosis = FALSE;
|
||
state.bits.trigger_status = TRUE;
|
||
state.bits.data_compression_enabled = FALSE;
|
||
state.bits.diag_type = diagnosis_test.diag_type;
|
||
|
||
req->rsp.len = sizeof(diagnosis_state_u);
|
||
req->rsp.pbuf[0] = state.data;
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 162-设置气源压力/A口/B口
|
||
*
|
||
* @param[in] req HART模式诊断请求
|
||
* @return TRUE or FALSE
|
||
*/
|
||
static BOOL hart_set_pressure_req(hart_user_req_t *const req)
|
||
{
|
||
hart_command_162_t *cmd = &req->data.command_162;
|
||
pressure_type_e index = PRESSURE_PARAM_S;
|
||
if (cmd->press_type == 0x08) ///< 气源压力
|
||
{
|
||
index = PRESSURE_PARAM_S;
|
||
}
|
||
else if (cmd->press_type == 0x02) ///< A口
|
||
{
|
||
index = PRESSURE_PARAM_A;
|
||
}
|
||
else ///< B口
|
||
{
|
||
index = PRESSURE_PARAM_B;
|
||
}
|
||
|
||
if (cmd->press_value == 0)
|
||
{
|
||
set_pressure_min(cmd->press_unit, cmd->press_value, index);
|
||
}
|
||
else
|
||
{
|
||
set_pressure_max(cmd->press_unit, cmd->press_value, index);
|
||
}
|
||
|
||
// 回复数据
|
||
req->rsp.len = sizeof(hart_command_162_t); ///< 返回数据长度
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
|
||
cmd->press_value = S2B_FLOAT32(cmd->press_value);
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)cmd, req->rsp.len); ///< 返回数据
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 157-处理HART模式诊断停止请求
|
||
*
|
||
* @return TRUE or FALSE
|
||
*/
|
||
static BOOL hart_mode_diagnosis_stop_req(void)
|
||
{
|
||
mode_diagnosis_stop();
|
||
menus_jump_asynchronous(MENUS_WORK, TRUE);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 158-在线诊断测试
|
||
*
|
||
* @return TRUE or FALSE
|
||
*/
|
||
static BOOL hart_mode_diagnosis_test_req(hart_user_req_t *const req)
|
||
{
|
||
hart_command_158_t *cmd = &req->data.command_158;
|
||
if (cmd->diagnostic_type != DIAG_TYPE_ONLINE_COMMANDED)
|
||
{
|
||
return FALSE;
|
||
}
|
||
mode_diagnosis_file_head_u head;
|
||
osel_memset((uint8_t *)&head.online, 0, sizeof(mode_diagnosis_online_file_head_t));
|
||
osel_memcpy(head.online.variable_code, cmd->variable_code, HART_PACKED4_LEN); // 设备变量
|
||
head.online.sampling_time = cmd->sampling_time; // 采样时间
|
||
head.online.points = cmd->points; // 总点数
|
||
|
||
return mode_diagnosis_start(MODE_DIAGNOSIS_TYPE_ONLINE, &head);
|
||
}
|
||
|
||
/**
|
||
* @brief 写入校准记录
|
||
*
|
||
* @param[in] req HART操作消息请求
|
||
* @return TRUE or FALSE
|
||
*/
|
||
static BOOL hart_set_calibration_record_req(hart_user_req_t *const req)
|
||
{
|
||
hart_command_167_t *cmd = &req->data.command_167;
|
||
osel_memcpy((uint8_t *)&udevice.calib_record, (uint8_t *)cmd, sizeof(hart_command_167_t));
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
// 143-设置阀门序列号
|
||
static BOOL hart_set_valve_sn_req(hart_user_req_t *const req)
|
||
{
|
||
hart_command_143_t *cmd = &req->data.command_143;
|
||
osel_memcpy((uint8_t *)udevice.valve_serial_num, cmd->pbuf, ARRAY_LEN(udevice.valve_serial_num));
|
||
req->rsp.len = ARRAY_LEN(udevice.valve_serial_num);
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)udevice.valve_serial_num, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
// 154-设置仪器序列号
|
||
static BOOL hart_set_dev_sn_req(hart_user_req_t *const req)
|
||
{
|
||
hart_command_154_t *cmd = &req->data.command_154;
|
||
osel_memcpy((uint8_t *)udevice.dev_serial_num, cmd->pbuf, ARRAY_LEN(udevice.dev_serial_num));
|
||
req->rsp.len = ARRAY_LEN(udevice.dev_serial_num);
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
osel_memcpy(req->rsp.pbuf, req->data.command_143.pbuf, req->rsp.len);
|
||
|
||
hart_long_addr_set();
|
||
hart_storage_write_item(HART_STORAGE_PARAMS, HPB_LONG_ADDRESS,
|
||
hart_device_attribute.flash_variable.long_address);
|
||
return TRUE;
|
||
}
|
||
|
||
// 138-读取其他状态
|
||
static BOOL hart_read_other_status_req(hart_user_req_t *const req)
|
||
{
|
||
hart_other_status_u status;
|
||
osel_memset((uint8_t *)&status, 0, sizeof(hart_other_status_u));
|
||
update_other_status(&status);
|
||
req->rsp.len = sizeof(hart_other_status_u);
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)&status, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
// 140-读取触发器定义的内容
|
||
static BOOL hart_read_trigger_definition_req(hart_user_req_t *const req)
|
||
{
|
||
hart_read_trigger_definition_t cmd;
|
||
osel_memset((uint8_t *)&cmd, 0, sizeof(hart_read_trigger_definition_t));
|
||
/****************测试数据****************/
|
||
cmd.start_addr = req->data.command_140.start_addr;
|
||
cmd.trigger_type = diagnosis_test.diag_type;
|
||
cmd.variable_1 = diagnosis_test.v1;
|
||
cmd.variable_2 = diagnosis_test.v2;
|
||
cmd.variable_3 = diagnosis_test.v3;
|
||
cmd.variable_4 = diagnosis_test.v4;
|
||
cmd.acquisition_time = diagnosis_test.collection_time;
|
||
cmd.data_points = diagnosis_test.total_data_points;
|
||
cmd.trigger_enable = 0x77;
|
||
cmd.unknow = 0x8899aabb;
|
||
/**************************************/
|
||
/*大小端转换*/
|
||
cmd.unknow = S2B_UINT32(cmd.unknow);
|
||
cmd.data_points = S2B_UINT16(cmd.data_points);
|
||
cmd.start_addr = S2B_UINT16(cmd.start_addr);
|
||
req->rsp.len = sizeof(hart_read_trigger_definition_t);
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, req->rsp.len);
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)&cmd, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
// 146-读取标准跨度信息(不实现功能)
|
||
static BOOL hart_read_standard_span_req(hart_user_req_t *const req)
|
||
{
|
||
hart_standard_span_information_t span;
|
||
osel_memset((uint8_t *)&span, 0, sizeof(hart_standard_span_information_t));
|
||
span.upper_limit_of_span = 0x2800;
|
||
span.lower_limit_of_span = 0x0800;
|
||
span.flash_address = 0x0C9F;
|
||
span.download_address = 0x0211;
|
||
|
||
span.upper_limit_of_span = S2B_UINT16(span.upper_limit_of_span);
|
||
span.lower_limit_of_span = S2B_UINT16(span.lower_limit_of_span);
|
||
span.flash_address = S2B_UINT16(span.flash_address);
|
||
span.download_address = S2B_UINT16(span.download_address);
|
||
|
||
req->rsp.len = sizeof(hart_standard_span_information_t);
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)&span, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
// 523-扩展指令(读取压缩状态映射)
|
||
static BOOL hart_read_compression_state_mapping_req(hart_user_req_t *const req)
|
||
{
|
||
hart_condensed_status_map_u map;
|
||
osel_memset((uint8_t *)&map, 0, sizeof(hart_condensed_status_map_u));
|
||
uint8_t address = req->data.command_523.address * 0.5f;
|
||
uint8_t count = req->data.command_523.count * 0.5f; // 读取状态个数，根据hart_condensed_status_map_u中的数据类型定义1个字节分为2个状态，这里不考虑存在奇数个状态查询的情况
|
||
hart_command_523_t command_523_rsp;
|
||
if (address > ARRAY_LEN(map.data))
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
osel_memcpy((uint8_t *)&command_523_rsp, (uint8_t *)&req->data.command_523, sizeof(hart_command_523_t));
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)&command_523_rsp, sizeof(hart_command_523_t));
|
||
req->rsp.len = sizeof(hart_command_523_t);
|
||
|
||
update_compression_state_mapping_table(&map);
|
||
uint8_t *p = &map.data[address];
|
||
if (address + count > ARRAY_LEN(map.data))
|
||
{
|
||
count = ARRAY_LEN(map.data) - address;
|
||
}
|
||
osel_memcpy(req->rsp.pbuf + req->rsp.len, p, count);
|
||
req->rsp.len += count;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
// 524-扩展指令(写入压缩状态映射)
|
||
static BOOL hart_write_compression_state_mapping_req(hart_user_req_t *const req)
|
||
{
|
||
return TRUE;
|
||
}
|
||
|
||
// 35-写入电流上下限（主变量范围）
|
||
static BOOL hart_write_input_range_req(hart_command_req_t *const req)
|
||
{
|
||
float32_u tmp;
|
||
|
||
tmp.f = req->data.command_35.pv_upper_range_value;
|
||
tmp.c = B2S_UINT32(tmp.c);
|
||
osel_memcpy((uint8_t *)&udevice.input_range_hi, (uint8_t *)&tmp.f, sizeof(float32));
|
||
tmp.f = req->data.command_35.pv_lower_range_value;
|
||
tmp.c = B2S_UINT32(tmp.c);
|
||
osel_memcpy((uint8_t *)&udevice.input_range_lo, (uint8_t *)&tmp.f, sizeof(float32));
|
||
return TRUE;
|
||
}
|
||
|
||
// 44-主变量单位
|
||
static BOOL hart_write_pv_unit_req(hart_command_req_t *const req)
|
||
{
|
||
hart_device_variable_t *variable = NULL;
|
||
udevice.input_unit = req->data.command_44.pv_units_code;
|
||
variable = get_device_variable_by_standard_code(DIN_246);
|
||
variable->units_code = req->data.command_44.pv_units_code;
|
||
return TRUE;
|
||
}
|
||
|
||
// 53-同步压力或者电流变量单位
|
||
static BOOL hart_write_variable_unit_req(hart_command_req_t *const req)
|
||
{
|
||
if (req->data.command_53.device_ariable == DEV_TEMPERATURE) ///< 将命令53修改的变量：温度同步到命令129的变量：温度单位
|
||
{
|
||
udevice.temp_unit = req->data.command_53.device_ariable_unit_code;
|
||
}
|
||
else if (req->data.command_53.device_ariable == DEV_PRESS) ///< 将命令53修改的变量：压力同步到命令129的变量：压力单位
|
||
{
|
||
udevice.press_unit = req->data.command_53.device_ariable_unit_code;
|
||
}
|
||
return TRUE;
|
||
}
|
||
// 131-写入整定参数
|
||
static BOOL hart_write_tuning_param_req(hart_user_req_t *const req)
|
||
{
|
||
hart_command_131_t *cmd = &req->data.command_131;
|
||
if (cmd->tuning_type == 0x01)
|
||
{
|
||
// 位置整定参数
|
||
udevice.pos_tuning_set = cmd->tuning_data;
|
||
}
|
||
else if (cmd->tuning_type == 0x02)
|
||
{
|
||
// 压力整定参数
|
||
udevice.press_tuning_set = cmd->tuning_data;
|
||
}
|
||
else
|
||
{
|
||
return FALSE;
|
||
}
|
||
req->rsp.len = sizeof(hart_command_131_t);
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)cmd, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
// 132-读取整定参数
|
||
static BOOL hart_read_tuning_param_req(hart_user_req_t *const req)
|
||
{
|
||
hart_command_132_t cmd;
|
||
cmd.pos_tuning_set = udevice.pos_tuning_set;
|
||
cmd.press_tuning_set = udevice.press_tuning_set;
|
||
req->rsp.len = sizeof(hart_command_132_t);
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)&cmd, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
// 164-读取规格表数据
|
||
static BOOL hart_read_specification_req(hart_user_req_t *const req)
|
||
{
|
||
uint8_t *address = &spec_table_data.ss2_ver;
|
||
address += req->data.command_164.address;
|
||
req->rsp.len = req->data.command_164.length;
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
osel_memcpy(req->rsp.pbuf, address, req->rsp.len);
|
||
return TRUE;
|
||
}
|
||
|
||
// 165-写入规格表数据
|
||
static BOOL hart_write_specification_req(hart_user_req_t *const req)
|
||
{
|
||
uint8_t length = req->data_length - 2;
|
||
|
||
uint8_t *address = &spec_table_data.ss2_ver;
|
||
address += req->data.command_165.address;
|
||
|
||
if (req->data.command_165.address + length > sizeof(specification_table_data_t))
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
osel_memcpy(address, req->data.command_165.pbuf, length);
|
||
|
||
// 回复数据
|
||
req->rsp.len = req->data_length;
|
||
req->data.command_165.address = S2B_UINT16(req->data.command_165.address);
|
||
osel_memset((uint8_t *)&req->rsp.pbuf, 0, HART_RESPONSE_MAX_LEN);
|
||
osel_memcpy(req->rsp.pbuf, (uint8_t *)&req->data.command_165.address, sizeof(uint16_t));
|
||
osel_memcpy(req->rsp.pbuf + sizeof(uint16_t), address, length);
|
||
|
||
spec_table_data_mapping(FALSE); // 规格表中的数据和udevice中的属性做映射关系
|
||
fal_execution_sem_update();
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 处理HART接口用户事件
|
||
*
|
||
* 根据传入的事件和数据，执行相应的处理函数。
|
||
*
|
||
* @param event HART接口用户事件
|
||
* @param data 事件相关数据
|
||
*
|
||
* @return 处理结果，成功返回TRUE，失败返回FALSE
|
||
*/
|
||
BOOL hart_user_handle(hart_interface_user_event_e event, const void *const data)
|
||
{
|
||
BOOL ret = FALSE;
|
||
switch (event)
|
||
{
|
||
case HART_COMMAND_35_EVENT: // 写入电流上下限（主变量范围）
|
||
ret = hart_write_input_range_req((hart_command_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_44_EVENT: // 写入主变量单位
|
||
ret = hart_write_pv_unit_req((hart_command_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_53_EVENT: // 写入设备变量单位
|
||
ret = hart_write_variable_unit_req((hart_command_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_109_EVENT: // 突发模式控制
|
||
ret = hart_burst_mode_control_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_131_EVENT: // 写入整定参数
|
||
ret = hart_write_tuning_param_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_132_EVENT: // 读取整定参数
|
||
ret = hart_read_tuning_param_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_133_EVENT: // 获取打开的文件信息
|
||
ret = hart_read_file_information_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_134_EVENT: // 读取文件
|
||
ret = hart_file_read_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_135_EVENT: // 写入文件
|
||
ret = hart_file_write_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_136_EVENT: // 读取/解除/写入EEPROM
|
||
ret = hart_epprom_multiple_operations((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_138_EVENT: // 读取其他状态
|
||
ret = hart_read_other_status_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_140_EVENT: // 读取触发器定义的内容
|
||
ret = hart_read_trigger_definition_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_142_EVENT: // 执行校准
|
||
ret = hart_tuning_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_143_EVENT: // 设置阀门序列号
|
||
ret = hart_set_valve_sn_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_144_EVENT: // 读取阀门序列号
|
||
ret = hart_read_valve_sn_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_145_EVENT: // 读取仪器序列号
|
||
ret = hart_read_device_sn_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_146_EVENT: // 读取标准跨度信息
|
||
ret = hart_read_standard_span_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_147_EVENT: // 读取设备等级
|
||
ret = hart_read_device_level_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_149_EVENT: // 设置仪器时间
|
||
ret = hart_set_dev_time_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_150_EVENT: // 读取设备时间
|
||
ret = hart_read_dev_time_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_151_EVENT: // 读取版本
|
||
ret = hart_read_version_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_153_EVENT: // 读取校准记录
|
||
ret = hart_read_calibration_record_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_154_EVENT: // 设置仪器序列号
|
||
ret = hart_set_dev_sn_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_155_EVENT: // 执行诊断
|
||
ret = hart_mode_diagnosis_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_156_EVENT: // 读取诊断状态
|
||
ret = hart_read_diagnosis_state_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_157_EVENT: // 停止诊断
|
||
ret = hart_mode_diagnosis_stop_req();
|
||
break;
|
||
case HART_COMMAND_158_EVENT: // 在线诊断测试
|
||
ret = hart_mode_diagnosis_test_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_162_EVENT: // 设置气源气压/A口/B口
|
||
ret = hart_set_pressure_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_164_EVENT: // 读取规格表数据
|
||
ret = hart_read_specification_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_165_EVENT: // 写入规格表数据
|
||
ret = hart_write_specification_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_167_EVENT: // 写入校准记录（操作日期和操作人员）
|
||
ret = hart_set_calibration_record_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_168_EVENT: // 读取部分行程报警
|
||
ret = hart_read_partial_stroke_alarm_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_170_EVENT: // 读取制造信息序列号
|
||
ret = hart_read_manufacturing_sn_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_187_EVENT: // 测试指令
|
||
ret = hart_test_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_200_EVENT: // 读取NVM非易失性存储器数据
|
||
ret = hart_read_nvw_data_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_523_EVENT: // 读取压缩状态映射
|
||
ret = hart_read_compression_state_mapping_req((hart_user_req_t *)data);
|
||
break;
|
||
case HART_COMMAND_524_EVENT: // 写入压缩状态映射
|
||
ret = hart_write_compression_state_mapping_req((hart_user_req_t *)data);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
return ret;
|
||
}
|