请求与响应

请求

1
2
3
4
{
  command: 'ping', // 请求指令 (String)
  data: {}, // 请求数据 (根据 command(指令) 不同而不同)
}

响应

1
2
3
4
5
{
  statusCode: 200, // 响应状态码 200 为成功 (200 成功 | 400 指令错误 | 404 指令不存在 | 408 超时 | 500 设备错误) (Number)
  message: '操作成功!', // 成功或失败信息 (String)
  data: {}, // 响应数据 (根据 command(指令) 不同而不同)
}

指令

Ping

1
2
3
4
{
  command: 'ping',
  data: {},
}
1
2
3
4
5
{
  statusCode: 200,
  message: 'pong!',
  data: {},
}

获取设备信息

1
2
3
4
{
  command: 'get-info',
  data: {},
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{
  statusCode: 200,
  message: '操作成功!',
  data: {
    id: 'haas531-123456123456', // 设备 ID (String)
    version: 1, // 固件版本 (Number)
    io: { // 硬件接口信息
      uart1: { // 串口1
        type: 'UART', // 接口类型 (String)
        port: 2, // 端口值 跟芯片 datasheet 上的端口对应 (Number)
        dataWidth: 8, // 串口数据宽度值 (Number)
        baudRate: 9600, // 串口波特率 (Number)
        stopBits: 1, // 串口停止位 (Number)
        flowControl: 'disable', // 流控设置 ('disable' | 'cts' | 'rts' | 'rtscts')
        parity: 'none', // 奇偶校验 ('none' | 'odd' | 'even')
      }
    },
    supportGB26875Names: ['default'], // 此设备支持的 GB26875 协议变种名称 (String[])
  },
}

获取配置

1
2
3
4
{
  command: 'get-config',
  data: {},
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
{
  statusCode: 200,
  message: '操作成功!',
  data: {
    server: [
      {
        host: '127.0.0.1', // 服务器域名或 IP (String)
        port: 233, // 服务器端口 (Number)
        username: '233', // 服务器用户名 (String)
        password: '233', // 服务器密码 (String)
      },
    ], // 可以多个服务器同时连接
    debugServer: {
      host: '127.0.0.1', // 调试服务器域名或 IP (String)
      port: 233, // 调试服务器端口 (Number)
      username: '233', // 调试服务器用户名 (String)
      password: '233', // 调试服务器密码 (String)
    },
    active: {
      realTimeData: { // 实时数据主动上报
        open: true, // 是否开启实时数据主动上报 (Boolean)
        uartCommandData: [1, 2, 3, 4, 5, 6], // 通过串口发送的指令 (Number[])
        uartCommandInterval: 500, // 通过串口发送指令的间隔 (Number)
      },
      alarm: { // 告警主动上报
        open: true, // 是否开启 (Boolean)
        threshold: [ // 阈值
          {
            key: '压力', // 字段名称 根据 protocol(协议) 解析后得到的 数据(parsed) 进行匹配的键名 (String)
            rawRanges: [ // 触发范围值 范围值是原始值 结束范围可空 ([开始(Number), 结束(Number)?])
              [0, 5],
              [20],
            ],
            filters: [ // 条件过滤器
              {
                key: '单位', // 条件字段名称 (String)
                rawRanges: [
                  // 达成条件范围值 范围值是原始值 结束范围可空 ([开始(Number), 结束(Number)?])
                  [4, 4],
                ],
              },
            ],
            message: '压力异常',
          },
        ]
      }
      fireAlarm: { // 火警主动上报
        open: true,
        threshold: [
          {
            key: '火警',
            rawRanges: [
              [1],
            ],
            filters: [],
            message: '设备报告火警',
          },
        ]
      }
      operation: { // 操作主动上报
        open: true,
        threshold: [
          {
            key: '复位',
            rawRanges: [
              [1],
            ],
            filters: [],
            message: '设备报告复位操作'
          },
        ]
      }
    },
    protocol: {
      type: 'modbus', // 协议类型 ('modbus' | 'gb26875')
      gb26875Config: {
        name: 'default',
      }, // GB26875 的协议类型 仅 protocol - type 等于 gb26875 时有效 可选值为此设备支持信息中的可选值为此设备信息 (get-info) 中的 supportGB26875Names (String)
      modbusConfig: { // Modbus 的协议配置 仅 protocol - type 等于 modbus 时有效
        id: 1, // modbus 协议 ID
        name: '源诚消防水源水压监测设备', // modbus 协议名称
        version: 1, // modbus 协议版本
        keys: [ // 解析的键
          {
            key: '单位', // 字段名称 (String)
            position: [4, 5], // 解析时 此字段在 MODBUS 数据中对应下标范围 ([开始(Number), 结束?(Number)])
            high: true, // 是否高字节在前
            unit: '' // 单位 (String)
            switch: [
              // 转换器 为空数组时 直接输出原始值
              {
                range: [0, 0], // 用数组表示范围 ([开始(Number), 结束?(Number)])
                value: 'Mpa', // 转换的值 (String || Number)
              },
            ],
          },
          {
            key: '小数点',
            position: [6, 7],
            high: true,
            unit: ''
            switch: [
              {
                range: [1, 1],
                value: 0.1,
              },
            ],
          },
          {
            key: '压力',
            position: [8, 9],
            high: true,
            unit: 'Mpa'
            switch: [],
          },
        ],
      }
    },
  }
}

设置配置

1
2
3
4
5
6
{
  command: 'set-config',
  data: {
    // 传入设备配置 参考 get-config
  },
}
1
2
3
4
5
{
  statusCode: 200,
  message: '操作成功!',
  data: {}
}

主动获取实时数据 (需要设备支持且开启实时数据主动上报)

1
2
3
4
{
  command: 'get-data',
  data: {},
}
1
2
3
4
5
6
7
8
9
10
11
12
13
{
  statusCode: 200,
  message: '操作成功!',
  data: {
    raw: [0, 1, 2, 3, 4, 5, 6], // 原始数据 (Number[])
    parsed: { // 解析后的数据对象
      key: { // 参数名称 key
        value: 0, // 数据 (Number)
        unit: '单位' // 单位 (String)
      }
    },
  }
}

发送数据到设备串口

1
2
3
4
5
6
{
  command: 'send-uart',
  data: {
    sendData: [1, 2, 3, 4, 5, 6, 7] // 需要发送的数据 (Number[])
  },
}
1
2
3
4
5
{
  statusCode: 200,
  message: '操作成功!',
  data: {}
}

重启设备

1
2
3
4
{
  command: 'reboot',
  data: {},
}
1
2
3
4
5
{
  statusCode: 200,
  message: '操作成功!',
  data: {}
}

获取/上报类指令

获取配置 (请求/响应)

1
2
3
4
5
{
  serialNumber: 1, // 流水号
  cmd: '获取配置', // 指令 (String)
  data: {}, // 数据
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
{
  requestNumber: 1, // 请求流水号
  cmd: '获取配置', // 指令 (String)
  data: {
    id: '1aa169628add4c1e965f5bc69e2e9dbb', // 设备唯一ID (String)
    version: 1, // 固件版本 (Number)
    server: [
      {
        host: 'localhost', // 服务器域名或IP
        port: 23333, // 服务器端口
      }
    ],
    interval: {
      heartbeatInterval: 5000, // 心跳上报间隔 (Number)
      dataInterval: 10000, // 数据上报间隔 (Number)
      uartInterval: 1000, // 串口发送指令间隔 (Number) 子协议类型中的 getDataCommand 为空字符串时此项无效
      alarmInterval: 0, // 告警/火警上报间隔 (Number)
    },
    protocol: {
      type: 'modbus', // 协议类型 ('modbus' || 'gb26875')
      subtype: '源诚消防水源水压监测设备', // 协议子类型 (String)
    },
    alarmValues: [
      // 告警阈值, 为空数组时代表不会产生告警 ({}[])
      {
        key: '压力', // 字段名称 (String)
        alarmType: 'alarm', // 告警类型 ('fireAlarm' | 'alarm' | 'operate')
        alarmRawRanges: [
          // 触发告警范围值, 范围值是原始值, 结束范围可空 ([开始, 结束?])
          [0, 5],
          [20],
        ],
        filters: [
          // 条件过滤器 ({}[])
          {
            key: '单位', // 条件字段名称 (String)
            rawRanges: [
              // 达成条件范围值, 范围值是原始值, 结束范围可空 ([开始, 结束?])
              [4, 4],
            ],
          },
        ],
      },
    ],
    modbusSubtypes: [
      // modbus 协议的子类型列表 ({}[])
      {
        name: '源诚消防水源水压监测设备', // 子协议名称
        version: 1, // 子协议版本
      },
    ],
    gb26875Subtypes: [
      // gb26875 协议的子类型列表 ({}[])
      {
        name: '默认', // 子协议名称
        version: 1, // 子协议版本
      },
    ],
  },
}

获取 modbus 协议子类型 (请求/响应)

1
2
3
4
5
6
7
{
  serialNumber: 1,
  cmd: '获取modbus协议子类型',
  data: {
    name: '源诚消防水源水压监测设备', // 子协议名称
  },
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
{
  requestNumber: 1,
  cmd: '获取modbus协议子类型',
  data: {
    name: '源诚消防水源水压监测设备', // 子协议名称
    version: 1, // 子协议版本
    commands: [
      // 子协议指令
      {
        name: '获取数据', // 指令名称 (String)
        data: [1, 3, 0, 0, 0, 5, 133, 201], // 指令内容 (Number[])
      },
    ],
    getDataCommand: '获取数据', // 用于获取数据的指令, 空字符串则不主动发送指令 (String)
    keys: [
      // 解析 ({}[])
      {
        key: '单位', // 字段名称 (String)
        position: [4, 5], // 解析时, 此字段在 MODBUS 数据中的下标, 从0开始 (Number)
        high: true, // 是否高字节在前
        switch: [
          // 转换器 ({}[])
          {
            range: [0, 0], // 用数组表示范围 [开始, 结束] ([Number, Number])
            value: 'Mpa', // 转换的值 (String || Number)
          },
        ],
      },
      {
        key: '小数点',
        position: [6, 7],
        high: true,
        switch: [
          {
            range: [1, 1],
            value: 0.1,
          },
        ],
      },
      {
        key: '压力',
        position: [8, 9],
        high: true,
        switch: [],
      },
    ],
  },
}

获取 gb26875 协议子类型 (请求/响应)

1
2
3
4
5
6
7
{
  serialNumber: 1,
  cmd: '获取gb26875协议子类型',
  data: {
    name: '默认', // 子协议名称
  },
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{
  requestNumber: 1,
  cmd: '获取gb26875协议子类型',
  data: {
    // GB26875协议的子类型, 此协议解析较为复杂, 只能通过更新固件的方式添加新子类型 (String[])
    name: '默认', // 子协议名称
    version: 1, // 子协议版本
    commands: [
      // 子协议指令
      {
        name: '获取数据', // 指令名称 (String)
        data: [233, 332], // 指令内容 (Number[])
      },
    ],
    getDataCommand: '获取数据', // 用于获取数据的指令, 空字符串则不主动发送指令 (String)
  },
}

获取数据 (请求/响应)

1
2
3
4
5
{
  serialNumber: 1,
  cmd: '获取数据',
  data: {},
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{
  requestNumber: 1,
  cmd: '获取数据',
  data: {
    raw: [0, 1, 2, 3], // 原始数据 (Number[])
    parsed: {
      // 解析数据 ({})
      数据单元类型: '上传建筑消防设施系统配置情况',
      系统类型: '火灾报警系统',
      系统地址: 0,
      系统说明长度: 0,
      系统配置说明: '系统配置说明',
      时间: '2021-10-12 15:43:00',
    }
  },
}

上报数据 (响应)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
  cmd: '上报数据',
  data: {
    raw: [0, 1, 2, 3], // 原始数据 (Number[])
    parsed: {
      // 解析数据 ({})
      数据单元类型: '上传建筑消防设施系统配置情况',
      系统类型: '火灾报警系统',
      系统地址: 0,
      系统说明长度: 0,
      系统配置说明: '系统配置说明',
      时间: '2021-10-12 15:43:00',
    }
  },
}

上报告警/火警数据 (响应)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
{
  cmd: '上报告警/火警数据',
  data: {
    raw: [0, 1, 2, 3], // 原始数据
    parsed: {
      // 解析数据 ({})
      数据单元类型: '上传建筑消防设施系统配置情况',
      系统类型: '火灾报警系统',
      系统地址: 0,
      系统说明长度: 0,
      系统配置说明: '系统配置说明',
      时间: '2021-10-12 15:43:00',
    },
    alarms: [
      // 告警数组 ({}[])
      {
        key: '压力', // 字段名称 (String)
        alarmType: 'alarm', // 告警类型 ('fireAlarm' | 'alarm' | 'operate')
        alarmRawRanges: [
          // 触发告警范围值, 范围值是原始值, 结束范围可空 ([开始, 结束?])
          [0, 5],
          [20],
        ],
        filters: [
          // 条件过滤器 ({}[])
          {
            key: '单位', // 条件字段名称 (String)
            rawRanges: [
              // 达成条件范围值, 范围值是原始值, 结束范围可空 ([开始, 结束?])
              [4, 4],
            ],
          },
        ],
      },
    ]
  },
}

写入/删除类指令

写入服务器地址 (请求/响应)

1
2
3
4
5
6
7
8
{
  serialNumber: 1,
  cmd: '写入服务器地址', // 指令 (String)
  data: {
    host: 'localhost', // 服务器域名或IP
    port: 23333, // 服务器端口
  },
}
1
2
3
4
5
6
7
{
  requestNumber: 1,
  cmd: '写入服务器地址', // 指令 (String)
  data: {
    result: 1, // 指令执行结果 (1 = 成功 || 0 = 失败 || 其他)
  },
}

写入上报间隔 (请求/响应)

1
2
3
4
5
6
7
8
9
10
{
  serialNumber: 1,
  cmd: '写入上报间隔',
  data: {
    heartbeatInterval: 5000, // 心跳上报间隔 (Number)
    dataInterval: 10000, // 数据上报间隔 (Number)
    uartInterval: 1000, // 串口发送指令间隔 (Number)
    alarmInterval: 0, // 告警/火警上报间隔 (Number)
  },
}
1
2
3
4
5
6
7
{
  requestNumber: 1,
  cmd: '写入上报间隔',
  data: {
    result: 1, // 指令执行结果 (1 = 成功 || 0 = 失败 || 其他)
  },
}

写入协议设置 (请求/响应)

1
2
3
4
5
6
7
8
{
  serialNumber: 1,
  cmd: '写入协议设置',
  data: {
    type: 'modbus', // 协议类型 ('modbus' || 'gb26875')
    subtype: '源诚消防水源水压监测设备', // 协议子类型 (String)
  },
}
1
2
3
4
5
6
7
{
  requestNumber: 1,
  cmd: '写入协议配置',
  data: {
    result: 1, // 指令执行结果 (1 = 成功 || 0 = 失败 || 其他)
  },
}

写入设备告警阈值 (请求/响应)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
{
  serialNumber: 1,
  cmd: '写入设备告警阈值',
  data: {
    alarmValues: [
      // 告警阈值, 为空数组时代表不会产生告警 ({}[])
      {
        key: '压力', // 字段名称 (String)
        alarmType: 'alarm', // 告警类型 ('fireAlarm' | 'alarm' | 'operate')
        alarmRawRanges: [
          // 触发告警范围值, 范围值是原始值, 结束范围可空 ([开始, 结束?])
          [0, 5],
          [20],
        ],
        filters: [
          // 条件过滤器 ({}[])
          {
            key: '单位', // 条件字段名称 (String)
            rawRanges: [
              // 达成条件范围值, 范围值是原始值, 结束范围可空 ([开始, 结束?])
              [4, 4],
            ],
          },
        ],
      },
    ],
  },
}
1
2
3
4
5
6
7
{
  requestNumber: 1,
  cmd: '写入设备告警阈值',
  data: {
    result: 1, // 指令执行结果 (1 = 成功 || 0 = 失败 || 其他)
  },
}

写入 modbus 协议子类型 (请求/响应)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
{
  serialNumber: 1,
  cmd: '写入modbus协议子类型',
  data: {
    subtypes: [
      // 需要写入的 modbus 协议子类型 ({}[])
      {
        name: '源诚消防水源水压监测设备', // 子协议名称
        version: 1, // 子协议版本
        commands: [
          // 子协议指令
          {
            name: '获取数据', // 指令名称 (String)
            data: [1, 3, 0, 0, 0, 5, 133, 201], // 指令内容 (Number[])
          },
        ],
        getDataCommand: '获取数据', // 用于获取数据的指令, 空字符串则不启用自动数据上报功能 (String)
        keys: [
          // 解析 ({}[])
          {
            key: '单位', // 字段名称 (String)
            position: [4, 5], // 解析时, 此字段在 MODBUS 数据中的下标, 从0开始 (Number)
            high: true,
            switch: [
              // 转换器 ({}[])
              {
                range: [0, 0], // 用数组表示范围 [开始, 结束] ([Number, Number])
                value: 'Mpa', // 转换的值 (String || Number)
              },
            ],
          },
          {
            key: '小数点',
            position: [6, 7],
            high: true,
            switch: [
              {
                range: [1, 1],
                value: 0.1,
              },
            ],
          },
          {
            key: '压力',
            position: [8, 9],
            high: true,
            switch: [],
          },
        ],
      }
    ]
  }
}
1
2
3
4
5
6
7
{
  requestNumber: 1,
  cmd: '写入modbus子类型',
  data: {
    result: 1, // 指令执行结果 (1 = 成功 || 0 = 失败 || 其他)
  },
}

写入监听设备数据日志状态 (请求/响应)

1
2
3
4
5
6
7
{
  serialNumber: 1,
  cmd: '写入监听设备数据日志状态',
  data: {
    listening: true, // 是否监听设备数据日志 (Boolean)
  },
}
1
2
3
4
5
6
7
{
  requestNumber: 1,
  cmd: '写入监听设备数据日志状态',
  data: {
    result: 1, // 指令执行结果 (1 = 成功 || 0 = 失败 || 其他)
  },
}

系统类指令

确认 (请求)

1
2
3
4
5
6
{
  cmd: '确认',
  data: {
    serialNumber: 0 // 流水编号 (Number)
  },
}

发送数据到串口 (请求/响应)

1
2
3
4
5
6
7
{
  serialNumber: 1,
  cmd: '发送数据到串口',
  data: {
    bytes: [1, 3, 0, 0, 0, 0, 0, 0], // 发送给设备串口的数据
  },
}
1
2
3
4
5
6
7
{
  requestNumber: 1,
  cmd: '发送数据到串口',
  data: {
    result: 1, // 指令执行结果 (1 = 成功 || 0 = 失败 || 其他)
  },
}

设备串口数据上报 (响应)

1
2
3
4
5
6
{
  cmd: '设备串口数据上报',
  data: {
    bytes: [1, 3, 0, 0, 0, 0, 0, 0], // 设备实时回传原始数据
  },
}

错误类指令

指令错误 (响应)

1
2
3
4
5
6
7
{
  requestNumber: 1,
  cmd: '指令错误',
  data: {
    message: '指令错误' // 错误消息
  },
}