import { isEmpty } from '../../@core/base/shared/src/utils';
|
|
// ========== IOT - 依赖注入 ==========
|
/** IoT 依赖注入 KEY */
|
export const IOT_PROVIDE_KEY = {
|
PRODUCT: 'IOT_PRODUCT',
|
} as const;
|
|
// ========== IOT - 设备模块 ==========
|
/** 设备状态枚举 */
|
export const DeviceStateEnum = {
|
INACTIVE: 0, // 未激活
|
ONLINE: 1, // 在线
|
OFFLINE: 2, // 离线
|
} as const;
|
|
/** 设备状态选择器特殊选项 */
|
export const DEVICE_SELECTOR_OPTIONS = {
|
ALL_DEVICES: {
|
id: 0,
|
deviceName: '全部设备',
|
},
|
};
|
|
/**
|
* 设备状态汇总；label / value 给业务用，tagType 给 UI 层做颜色映射（不同框架可能各取所需）
|
*/
|
export const IoTDeviceStatusEnum = {
|
// 在线状态
|
ONLINE: {
|
label: '在线',
|
value: 'online',
|
tagType: 'success',
|
},
|
OFFLINE: {
|
label: '离线',
|
value: 'offline',
|
tagType: 'danger',
|
},
|
// 启用状态
|
ENABLED: {
|
label: '正常',
|
value: 0,
|
value2: 'enabled',
|
tagType: 'success',
|
},
|
DISABLED: {
|
label: '禁用',
|
value: 1,
|
value2: 'disabled',
|
tagType: 'danger',
|
},
|
// 激活状态
|
ACTIVATED: {
|
label: '已激活',
|
value2: 'activated',
|
tagType: 'success',
|
},
|
NOT_ACTIVATED: {
|
label: '未激活',
|
value2: 'not_activated',
|
tagType: 'info',
|
},
|
};
|
|
// ========== IOT - 产品模块 ==========
|
/** 产品设备类型枚举 */
|
export const DeviceTypeEnum = {
|
DEVICE: 0, // 直连设备
|
GATEWAY: 2, // 网关设备
|
GATEWAY_SUB: 1, // 网关子设备
|
} as const;
|
|
/** 产品设备类型枚举（与 DeviceTypeEnum 同义，保留旧名兼容旧代码） */
|
export const IoTProductDeviceTypeEnum = DeviceTypeEnum;
|
|
/** 产品状态枚举 */
|
export const ProductStatusEnum = {
|
UNPUBLISHED: 0, // 开发中
|
PUBLISHED: 1, // 已发布
|
} as const;
|
|
/** 数据格式（编解码器类型）枚举 */
|
export const CodecTypeEnum = {
|
ALINK: 'Alink', // 阿里云 Alink 协议
|
} as const;
|
|
// ========== IOT - 告警模块 ==========
|
/** IoT 告警接收方式枚举，与后端 IotAlertReceiveTypeEnum 保持一致 */
|
export const IotAlertReceiveTypeEnum = {
|
SMS: 1, // 短信
|
MAIL: 2, // 邮箱
|
NOTIFY: 3, // 站内信
|
} as const;
|
|
// ========== IOT - 物模型 ==========
|
/** IoT 产品物模型类型枚举类 */
|
export const IoTThingModelTypeEnum = {
|
PROPERTY: 1, // 属性
|
SERVICE: 2, // 服务
|
EVENT: 3, // 事件
|
};
|
|
/** 物模型组标签常量 */
|
export const THING_MODEL_GROUP_LABELS = {
|
PROPERTY: '设备属性',
|
EVENT: '设备事件',
|
SERVICE: '设备服务',
|
};
|
|
/** IoT 产品物模型服务调用方式枚举 */
|
export const IoTThingModelServiceCallTypeEnum = {
|
ASYNC: { label: '异步', value: 'async' },
|
SYNC: { label: '同步', value: 'sync' },
|
};
|
|
/** 获取服务调用方式标签 */
|
export const getThingModelServiceCallTypeLabel = (
|
value: string,
|
): string | undefined =>
|
Object.values(IoTThingModelServiceCallTypeEnum).find(
|
(type) => type.value === value,
|
)?.label;
|
|
/** IoT 产品物模型事件类型枚举 */
|
export const IoTThingModelEventTypeEnum = {
|
INFO: { label: '信息', value: 'info' },
|
ALERT: { label: '告警', value: 'alert' },
|
ERROR: { label: '故障', value: 'error' },
|
};
|
|
/** 获取事件类型标签 */
|
export const getEventTypeLabel = (value: string): string | undefined =>
|
Object.values(IoTThingModelEventTypeEnum).find((type) => type.value === value)
|
?.label;
|
|
/** IoT 产品物模型参数方向：输入参数 / 输出参数 */
|
export const IoTThingModelParamDirectionEnum = {
|
INPUT: 'input', // 输入参数
|
OUTPUT: 'output', // 输出参数
|
};
|
|
/** IoT 产品物模型访问模式枚举 */
|
export const IoTThingModelAccessModeEnum = {
|
READ_WRITE: { label: '读写', value: 'rw' },
|
READ_ONLY: { label: '只读', value: 'r' },
|
WRITE_ONLY: { label: '只写', value: 'w' },
|
};
|
|
/** 获取访问模式标签 */
|
export const getAccessModeLabel = (value: string): string => {
|
const mode = Object.values(IoTThingModelAccessModeEnum).find(
|
(item) => item.value === value,
|
);
|
return mode?.label || value;
|
};
|
|
/** 属性值的数据类型 */
|
export const IoTDataSpecsDataTypeEnum = {
|
INT: 'int',
|
FLOAT: 'float',
|
DOUBLE: 'double',
|
ENUM: 'enum',
|
BOOL: 'bool',
|
TEXT: 'text',
|
DATE: 'date',
|
STRUCT: 'struct',
|
ARRAY: 'array',
|
};
|
|
const DATA_TYPE_OPTIONS = Object.freeze([
|
{ value: IoTDataSpecsDataTypeEnum.INT, label: '整数型' },
|
{ value: IoTDataSpecsDataTypeEnum.FLOAT, label: '单精度浮点型' },
|
{ value: IoTDataSpecsDataTypeEnum.DOUBLE, label: '双精度浮点型' },
|
{ value: IoTDataSpecsDataTypeEnum.ENUM, label: '枚举型' },
|
{ value: IoTDataSpecsDataTypeEnum.BOOL, label: '布尔型' },
|
{ value: IoTDataSpecsDataTypeEnum.TEXT, label: '文本型' },
|
{ value: IoTDataSpecsDataTypeEnum.DATE, label: '时间型' },
|
{ value: IoTDataSpecsDataTypeEnum.STRUCT, label: '结构体' },
|
{ value: IoTDataSpecsDataTypeEnum.ARRAY, label: '数组' },
|
]);
|
|
/** 获取物模型数据类型选项 */
|
export const getDataTypeOptions = () => DATA_TYPE_OPTIONS;
|
|
/** 获取数据类型选项展示标签（value 含括号说明） */
|
export const getDataTypeOptionsLabel = (value: string) => {
|
if (isEmpty(value)) {
|
return value;
|
}
|
const dataType = getDataTypeOptions().find(
|
(option) => option.value === value,
|
);
|
return dataType && `${dataType.value}(${dataType.label})`;
|
};
|
|
/** 获取数据类型显示名称（用于属性选择器） */
|
export const getDataTypeName = (dataType: string): string => {
|
const typeMap: Record<string, string> = {
|
[IoTDataSpecsDataTypeEnum.INT]: '整数',
|
[IoTDataSpecsDataTypeEnum.FLOAT]: '浮点数',
|
[IoTDataSpecsDataTypeEnum.DOUBLE]: '双精度',
|
[IoTDataSpecsDataTypeEnum.TEXT]: '字符串',
|
[IoTDataSpecsDataTypeEnum.BOOL]: '布尔值',
|
[IoTDataSpecsDataTypeEnum.ENUM]: '枚举',
|
[IoTDataSpecsDataTypeEnum.DATE]: '日期',
|
[IoTDataSpecsDataTypeEnum.STRUCT]: '结构体',
|
[IoTDataSpecsDataTypeEnum.ARRAY]: '数组',
|
};
|
return typeMap[dataType] || dataType;
|
};
|
|
/** 获取数据类型标签类型（用于 tag 的 type 属性） */
|
export const getDataTypeTagType = (
|
dataType: string,
|
): 'danger' | 'info' | 'primary' | 'success' | 'warning' => {
|
const tagMap: Record<
|
string,
|
'danger' | 'info' | 'primary' | 'success' | 'warning'
|
> = {
|
[IoTDataSpecsDataTypeEnum.INT]: 'primary',
|
[IoTDataSpecsDataTypeEnum.FLOAT]: 'success',
|
[IoTDataSpecsDataTypeEnum.DOUBLE]: 'success',
|
[IoTDataSpecsDataTypeEnum.TEXT]: 'info',
|
[IoTDataSpecsDataTypeEnum.BOOL]: 'warning',
|
[IoTDataSpecsDataTypeEnum.ENUM]: 'danger',
|
[IoTDataSpecsDataTypeEnum.DATE]: 'primary',
|
[IoTDataSpecsDataTypeEnum.STRUCT]: 'info',
|
[IoTDataSpecsDataTypeEnum.ARRAY]: 'warning',
|
};
|
return tagMap[dataType] || 'info';
|
};
|
|
// ========== IOT - 设备消息 ==========
|
/** IoT 设备消息的方法枚举 */
|
export const IotDeviceMessageMethodEnum = {
|
// ========== 设备状态 ==========
|
STATE_UPDATE: {
|
method: 'thing.state.update',
|
name: '设备状态更新',
|
upstream: true,
|
},
|
|
// ========== 拓扑管理 ==========
|
TOPO_ADD: {
|
method: 'thing.topo.add',
|
name: '添加拓扑关系',
|
upstream: true,
|
},
|
TOPO_DELETE: {
|
method: 'thing.topo.delete',
|
name: '删除拓扑关系',
|
upstream: true,
|
},
|
TOPO_GET: {
|
method: 'thing.topo.get',
|
name: '获取拓扑关系',
|
upstream: true,
|
},
|
TOPO_CHANGE: {
|
method: 'thing.topo.change',
|
name: '拓扑关系变更通知',
|
upstream: false,
|
},
|
|
// ========== 设备注册 ==========
|
DEVICE_REGISTER: {
|
method: 'thing.auth.register',
|
name: '设备动态注册',
|
upstream: true,
|
},
|
SUB_DEVICE_REGISTER: {
|
method: 'thing.auth.register.sub',
|
name: '子设备动态注册',
|
upstream: true,
|
},
|
|
// ========== 设备属性 ==========
|
PROPERTY_POST: {
|
method: 'thing.property.post',
|
name: '属性上报',
|
upstream: true,
|
},
|
PROPERTY_SET: {
|
method: 'thing.property.set',
|
name: '属性设置',
|
upstream: false,
|
},
|
PROPERTY_PACK_POST: {
|
method: 'thing.event.property.pack.post',
|
name: '批量上报（属性 + 事件 + 子设备）',
|
upstream: true,
|
},
|
|
// ========== 设备事件 ==========
|
EVENT_POST: {
|
method: 'thing.event.post',
|
name: '事件上报',
|
upstream: true,
|
},
|
|
// ========== 服务调用 ==========
|
SERVICE_INVOKE: {
|
method: 'thing.service.invoke',
|
name: '服务调用',
|
upstream: false,
|
},
|
|
// ========== 设备配置 ==========
|
CONFIG_PUSH: {
|
method: 'thing.config.push',
|
name: '配置推送',
|
upstream: false,
|
},
|
|
// ========== OTA 固件 ==========
|
OTA_UPGRADE: {
|
method: 'thing.ota.upgrade',
|
name: 'OTA 固件信息推送',
|
upstream: false,
|
},
|
OTA_PROGRESS: {
|
method: 'thing.ota.progress',
|
name: 'OTA 升级进度上报',
|
upstream: true,
|
},
|
} as const;
|
|
// ========== IOT - OTA ==========
|
/** IoT OTA 任务设备范围枚举 */
|
export const IoTOtaTaskDeviceScopeEnum = {
|
ALL: { label: '全部设备', value: 1 },
|
SELECT: { label: '指定设备', value: 2 },
|
};
|
|
/** IoT OTA 任务状态枚举 */
|
export const IoTOtaTaskStatusEnum = {
|
IN_PROGRESS: { label: '进行中', value: 10 },
|
END: { label: '已结束', value: 20 },
|
CANCELED: { label: '已取消', value: 30 },
|
};
|
|
/** IoT OTA 升级记录状态枚举 */
|
export const IoTOtaTaskRecordStatusEnum = {
|
PENDING: { label: '待推送', value: 0 },
|
PUSHED: { label: '已推送', value: 10 },
|
UPGRADING: { label: '升级中', value: 20 },
|
SUCCESS: { label: '升级成功', value: 30 },
|
FAILURE: { label: '升级失败', value: 40 },
|
CANCELED: { label: '升级取消', value: 50 },
|
};
|
|
// ========== IOT - 场景联动 ==========
|
/** IoT 场景联动触发器类型枚举 */
|
export const IotRuleSceneTriggerTypeEnum = {
|
DEVICE_STATE_UPDATE: 1, // 设备上下线变更
|
DEVICE_PROPERTY_POST: 2, // 物模型属性上报
|
DEVICE_EVENT_POST: 3, // 设备事件上报
|
DEVICE_SERVICE_INVOKE: 4, // 设备服务调用
|
TIMER: 100, // 定时触发
|
};
|
|
/** 触发器类型选项配置 */
|
export const triggerTypeOptions = [
|
{
|
value: IotRuleSceneTriggerTypeEnum.DEVICE_STATE_UPDATE,
|
label: '设备状态变更',
|
},
|
{
|
value: IotRuleSceneTriggerTypeEnum.DEVICE_PROPERTY_POST,
|
label: '设备属性上报',
|
},
|
{
|
value: IotRuleSceneTriggerTypeEnum.DEVICE_EVENT_POST,
|
label: '设备事件上报',
|
},
|
{
|
value: IotRuleSceneTriggerTypeEnum.DEVICE_SERVICE_INVOKE,
|
label: '设备服务调用',
|
},
|
{
|
value: IotRuleSceneTriggerTypeEnum.TIMER,
|
label: '定时触发',
|
},
|
];
|
|
/** 判断是否为设备触发器类型 */
|
export function isDeviceTrigger(type: number): boolean {
|
const deviceTriggerTypes = [
|
IotRuleSceneTriggerTypeEnum.DEVICE_STATE_UPDATE,
|
IotRuleSceneTriggerTypeEnum.DEVICE_PROPERTY_POST,
|
IotRuleSceneTriggerTypeEnum.DEVICE_EVENT_POST,
|
IotRuleSceneTriggerTypeEnum.DEVICE_SERVICE_INVOKE,
|
] as number[];
|
return deviceTriggerTypes.includes(type);
|
}
|
|
/** 获取触发器类型标签 */
|
export const getTriggerTypeLabel = (type: number): string => {
|
const option = triggerTypeOptions.find((item) => item.value === type);
|
return option?.label || '未知类型';
|
};
|
|
/** IoT 场景联动执行器类型枚举 */
|
export const IotRuleSceneActionTypeEnum = {
|
DEVICE_PROPERTY_SET: 1, // 设备属性设置
|
DEVICE_SERVICE_INVOKE: 2, // 设备服务调用
|
ALERT_TRIGGER: 100, // 告警触发
|
ALERT_RECOVER: 101, // 告警恢复
|
};
|
|
/** 执行器类型选项配置 */
|
export const actionTypeOptions = [
|
{
|
value: IotRuleSceneActionTypeEnum.DEVICE_PROPERTY_SET,
|
label: '设备属性设置',
|
},
|
{
|
value: IotRuleSceneActionTypeEnum.DEVICE_SERVICE_INVOKE,
|
label: '设备服务调用',
|
},
|
{ value: IotRuleSceneActionTypeEnum.ALERT_TRIGGER, label: '触发告警' },
|
{ value: IotRuleSceneActionTypeEnum.ALERT_RECOVER, label: '恢复告警' },
|
];
|
|
/** 兼容旧调用：保留函数形态 */
|
export const getActionTypeOptions = () => actionTypeOptions;
|
|
/** 获取执行器类型标签 */
|
export const getActionTypeLabel = (type: number): string => {
|
const option = actionTypeOptions.find((opt) => opt.value === type);
|
return option?.label || '未知类型';
|
};
|
|
/** IoT 场景联动触发条件参数操作符枚举 */
|
export const IotRuleSceneTriggerConditionParameterOperatorEnum = {
|
EQUALS: { name: '等于', value: '=' },
|
NOT_EQUALS: { name: '不等于', value: '!=' },
|
GREATER_THAN: { name: '大于', value: '>' },
|
GREATER_THAN_OR_EQUALS: { name: '大于等于', value: '>=' },
|
LESS_THAN: { name: '小于', value: '<' },
|
LESS_THAN_OR_EQUALS: { name: '小于等于', value: '<=' },
|
IN: { name: '在...之中', value: 'in' },
|
NOT_IN: { name: '不在...之中', value: 'not in' },
|
BETWEEN: { name: '在...之间', value: 'between' },
|
NOT_BETWEEN: { name: '不在...之间', value: 'not between' },
|
LIKE: { name: '字符串匹配', value: 'like' },
|
NOT_NULL: { name: '非空', value: 'not null' },
|
};
|
|
/** IoT 场景联动触发条件类型枚举 */
|
export const IotRuleSceneTriggerConditionTypeEnum = {
|
DEVICE_STATUS: 1, // 设备状态
|
DEVICE_PROPERTY: 2, // 设备属性
|
CURRENT_TIME: 3, // 当前时间
|
};
|
|
/** 条件类型选项配置 */
|
export const conditionTypeOptions = [
|
{
|
value: IotRuleSceneTriggerConditionTypeEnum.DEVICE_STATUS,
|
label: '设备状态',
|
},
|
{
|
value: IotRuleSceneTriggerConditionTypeEnum.DEVICE_PROPERTY,
|
label: '设备属性',
|
},
|
{
|
value: IotRuleSceneTriggerConditionTypeEnum.CURRENT_TIME,
|
label: '当前时间',
|
},
|
];
|
|
/** 兼容旧调用：保留函数形态 */
|
export const getConditionTypeOptions = () => conditionTypeOptions;
|
|
/** IoT 场景联动触发时间操作符枚举 */
|
export const IotRuleSceneTriggerTimeOperatorEnum = {
|
BEFORE_TIME: { name: '在时间之前', value: 'before_time' },
|
AFTER_TIME: { name: '在时间之后', value: 'after_time' },
|
BETWEEN_TIME: { name: '在时间之间', value: 'between_time' },
|
AT_TIME: { name: '在指定时间', value: 'at_time' },
|
BEFORE_TODAY: { name: '在今日之前', value: 'before_today' },
|
AFTER_TODAY: { name: '在今日之后', value: 'after_today' },
|
TODAY: { name: '在今日之间', value: 'today' },
|
};
|
|
// ========== IOT - JSON 参数输入 ==========
|
/** JSON 参数输入组件类型枚举 */
|
export const JsonParamsInputTypeEnum = {
|
SERVICE: 'service',
|
EVENT: 'event',
|
PROPERTY: 'property',
|
CUSTOM: 'custom',
|
};
|
|
/** JSON 参数输入组件类型 */
|
export type JsonParamsInputType =
|
(typeof JsonParamsInputTypeEnum)[keyof typeof JsonParamsInputTypeEnum];
|
|
/** JSON 参数输入组件文本常量 */
|
export const JSON_PARAMS_INPUT_CONSTANTS = {
|
// 基础文本
|
PLACEHOLDER: '请输入JSON格式的参数',
|
JSON_FORMAT_CORRECT: 'JSON 格式正确',
|
QUICK_FILL_LABEL: '快速填充：',
|
EXAMPLE_DATA_BUTTON: '示例数据',
|
CLEAR_BUTTON: '清空',
|
VIEW_EXAMPLE_TITLE: '查看参数示例',
|
COMPLETE_JSON_FORMAT: '完整 JSON 格式：',
|
REQUIRED_TAG: '必填',
|
|
// 错误信息
|
PARAMS_MUST_BE_OBJECT: '参数必须是一个有效的 JSON 对象',
|
PARAM_REQUIRED_ERROR: (paramName: string) => `参数 ${paramName} 为必填项`,
|
JSON_FORMAT_ERROR: (error: string) => `JSON格式错误: ${error}`,
|
UNKNOWN_ERROR: '未知错误',
|
|
// 类型相关标题
|
TITLES: {
|
SERVICE: (name?: string) => `${name || '服务'} - 输入参数示例`,
|
EVENT: (name?: string) => `${name || '事件'} - 输出参数示例`,
|
PROPERTY: '属性设置 - 参数示例',
|
CUSTOM: (name?: string) => `${name || '自定义'} - 参数示例`,
|
DEFAULT: '参数示例',
|
},
|
|
// 参数标签
|
PARAMS_LABELS: {
|
SERVICE: '输入参数',
|
EVENT: '输出参数',
|
PROPERTY: '属性参数',
|
CUSTOM: '参数列表',
|
DEFAULT: '参数',
|
},
|
|
// 空状态消息
|
EMPTY_MESSAGES: {
|
SERVICE: '此服务无需输入参数',
|
EVENT: '此事件无输出参数',
|
PROPERTY: '无可设置的属性',
|
CUSTOM: '无参数配置',
|
DEFAULT: '无参数',
|
},
|
|
// 无配置消息
|
NO_CONFIG_MESSAGES: {
|
SERVICE: '请先选择服务',
|
EVENT: '请先选择事件',
|
PROPERTY: '请先选择产品',
|
CUSTOM: '请先进行配置',
|
DEFAULT: '请先进行配置',
|
},
|
};
|
|
/** JSON 参数输入组件图标常量 */
|
export const JSON_PARAMS_INPUT_ICONS = {
|
// 标题图标
|
TITLE_ICONS: {
|
SERVICE: 'ep:service',
|
EVENT: 'ep:bell',
|
PROPERTY: 'ep:edit',
|
CUSTOM: 'ep:document',
|
DEFAULT: 'ep:document',
|
},
|
|
// 参数图标
|
PARAMS_ICONS: {
|
SERVICE: 'ep:edit',
|
EVENT: 'ep:upload',
|
PROPERTY: 'ep:setting',
|
CUSTOM: 'ep:list',
|
DEFAULT: 'ep:edit',
|
},
|
|
// 状态图标
|
STATUS_ICONS: {
|
ERROR: 'ep:warning',
|
SUCCESS: 'ep:circle-check',
|
},
|
};
|
|
/** JSON 参数输入组件示例值常量 */
|
export const JSON_PARAMS_EXAMPLE_VALUES: Record<string, any> = {
|
[IoTDataSpecsDataTypeEnum.INT]: { display: '25', value: 25 },
|
[IoTDataSpecsDataTypeEnum.FLOAT]: { display: '25.5', value: 25.5 },
|
[IoTDataSpecsDataTypeEnum.DOUBLE]: { display: '25.5', value: 25.5 },
|
[IoTDataSpecsDataTypeEnum.BOOL]: { display: 'false', value: false },
|
[IoTDataSpecsDataTypeEnum.TEXT]: { display: '"auto"', value: 'auto' },
|
[IoTDataSpecsDataTypeEnum.ENUM]: { display: '"option1"', value: 'option1' },
|
[IoTDataSpecsDataTypeEnum.STRUCT]: { display: '{}', value: {} },
|
[IoTDataSpecsDataTypeEnum.ARRAY]: { display: '[]', value: [] },
|
DEFAULT: { display: '""', value: '' },
|
};
|
|
// ========== IOT - Modbus ==========
|
/** Modbus 模式枚举 */
|
export const ModbusModeEnum = {
|
POLLING: 1, // 云端轮询
|
ACTIVE_REPORT: 2, // 主动上报
|
} as const;
|
|
/** Modbus 帧格式枚举 */
|
export const ModbusFrameFormatEnum = {
|
MODBUS_TCP: 1, // Modbus TCP
|
MODBUS_RTU: 2, // Modbus RTU
|
} as const;
|
|
/** Modbus 功能码枚举 */
|
export const ModbusFunctionCodeEnum = {
|
READ_COILS: 1, // 读线圈
|
READ_DISCRETE_INPUTS: 2, // 读离散输入
|
READ_HOLDING_REGISTERS: 3, // 读保持寄存器
|
READ_INPUT_REGISTERS: 4, // 读输入寄存器
|
} as const;
|
|
/** Modbus 功能码选项 */
|
export const ModbusFunctionCodeOptions = [
|
{ value: 1, label: '01 - 读线圈 (Coils)', description: '可读写布尔值' },
|
{
|
value: 2,
|
label: '02 - 读离散输入 (Discrete Inputs)',
|
description: '只读布尔值',
|
},
|
{
|
value: 3,
|
label: '03 - 读保持寄存器 (Holding Registers)',
|
description: '可读写 16 位数据',
|
},
|
{
|
value: 4,
|
label: '04 - 读输入寄存器 (Input Registers)',
|
description: '只读 16 位数据',
|
},
|
];
|
|
/** Modbus 原始数据类型枚举 */
|
export const ModbusRawDataTypeEnum = {
|
INT16: 'INT16',
|
UINT16: 'UINT16',
|
INT32: 'INT32',
|
UINT32: 'UINT32',
|
FLOAT: 'FLOAT',
|
DOUBLE: 'DOUBLE',
|
BOOLEAN: 'BOOLEAN',
|
STRING: 'STRING',
|
} as const;
|
|
/** Modbus 原始数据类型选项 */
|
export const ModbusRawDataTypeOptions = [
|
{
|
value: 'INT16',
|
label: 'INT16',
|
description: '有符号16位整数',
|
registerCount: 1,
|
},
|
{
|
value: 'UINT16',
|
label: 'UINT16',
|
description: '无符号16位整数',
|
registerCount: 1,
|
},
|
{
|
value: 'INT32',
|
label: 'INT32',
|
description: '有符号32位整数',
|
registerCount: 2,
|
},
|
{
|
value: 'UINT32',
|
label: 'UINT32',
|
description: '无符号32位整数',
|
registerCount: 2,
|
},
|
{
|
value: 'FLOAT',
|
label: 'FLOAT',
|
description: '32位浮点数',
|
registerCount: 2,
|
},
|
{
|
value: 'DOUBLE',
|
label: 'DOUBLE',
|
description: '64位浮点数',
|
registerCount: 4,
|
},
|
{
|
value: 'BOOLEAN',
|
label: 'BOOLEAN',
|
description: '布尔值',
|
registerCount: 1,
|
},
|
{ value: 'STRING', label: 'STRING', description: '字符串', registerCount: 0 },
|
];
|
|
/** Modbus 字节序选项 - 16 位 */
|
export const ModbusByteOrder16Options = [
|
{ value: 'AB', label: 'AB', description: '大端序' },
|
{ value: 'BA', label: 'BA', description: '小端序' },
|
];
|
|
/** Modbus 字节序选项 - 32 位 */
|
export const ModbusByteOrder32Options = [
|
{ value: 'ABCD', label: 'ABCD', description: '大端序' },
|
{ value: 'CDAB', label: 'CDAB', description: '大端字交换' },
|
{ value: 'DCBA', label: 'DCBA', description: '小端序' },
|
{ value: 'BADC', label: 'BADC', description: '小端字交换' },
|
];
|
|
/** 根据数据类型获取字节序选项 */
|
export const getByteOrderOptions = (rawDataType: string) => {
|
if (['FLOAT', 'INT32', 'UINT32'].includes(rawDataType)) {
|
return ModbusByteOrder32Options;
|
}
|
if (rawDataType === 'DOUBLE') {
|
// 64 位复用 32 位字节序
|
return ModbusByteOrder32Options;
|
}
|
return ModbusByteOrder16Options;
|
};
|
