[关闭]
@marsleung 2019-12-20T06:46:29.000000Z 字数 15404 阅读 7897

Neptune工业设备物联云平台教程（一） ① 使用Triton for Windows连接您的设备

triton desktop neptune windows

1. 概述

本文将介绍，如何通过 Triton Windows 把您的设备连接到 Neptune工业设备物联云平台，体验快速连接并传输数据的乐趣。

1.1 适用场景

Triton Windows 适用于您的控制程序或者您的逻辑程序运行于Windows(x86/x64)之上，通过您的程序和Triton交互，实现设备连接和数据传输的功能。

交互方式有以下三种，可根据您的实际情况选择使用：

  • 您的程序实现TCP Client与Triton进行通讯；
  • 您的程序实现Modbus协议(从站)，Triton作为Modbus主站向您的程序读取数据；
  • 您的程序集成Triton外部库（C/C++），您的程序直接与Triton进行通讯；

如果您使用的运行平台为Linux或者WinCE，请参考以下文档：

① 使用Triton for Linux连接您的设备
② 使用Triton for WinCE连接您的设备

1.2 连接流程

Untitled Diagram (6).png-31.8kB

1.3 注意事项

  1. 请确保您的程序能够与运行Triton的计算机通讯；
  2. 下载Triton Windows(x86/x64)，并确保您的电脑能够运行Triton Windows(x86/x64);
  3. 请确保你的网络连接能正确连接到英特网；
  4. 如果您通过Socket进行数据交换，请确认您的程序或者设备需要作为TCP Client；
  5. 如果您通过Modbus协议进行数据交换，请确认您的程序或设备需要作为Modbus从站，并且需要您确定好每个设备的从站ID(slave_id)；
  6. 如果您通过集成外部库进行数据交换，请确认您的程序能够调用调用C/C++动态链接库；

2. 使用Triton连接Neptune

2.1 注册Neptune账号

STEP#01
访问 https://www.neptune-iiot.net, 点击右上角注册;
2017-09-13_14-03-18.png-55.2kB

STEP#02
填写注册信息，注册分为三个步骤：
a) 填写账户信息（使用邮件或者手机号码注册）；
2017-09-13_14-18-24.png-52.9kB

b) 验证账户信息（使用邮件或者手机号码接收验收激活邮件或者验证码）；
2017-09-13_14-21-41.png-50.7kB
2017-09-13_14-22-47.png-82.2kB
2017-09-13_14-23-24.png-207.4kB
以邮箱注册为例子，将收到上述邮件。点击激活邮箱，跳转到团队创建界面。

c) 创建或者加入一个团队[说明1]， 完成注册；

说明1：团队
团队的含义是一个域，用来为用户划定一个空间。用户创建团队时，会自动成为该团队的管理员，别的用户可以申请加入您的团队，您也可以在团队中邀请用户加入。
说明2：申请加入
当申请加入一个团队时，需要对方团队的管理员通过您的请求。请在申请加入后，耐心等待通过。

STEP#03 注册完成
注册完成后，页面跳转到登录界面。您可以使用您的账号密码进行登录。
2017-09-13_15-01-46.png-108.5kB

本文档关注使用Triton将设备连接至Neptune，因此平台功能在本文档中不作过多介绍，平台功能的介绍将在其它文档中介绍。

2.2 在Neptune中创建设备

在Neptune账号注册完成后，我们需要在Neptune中“创建一个设备”，这个“设备”将获得一个全平台唯一的序列号，并且和实体设备一一对应起来。

STEP#01
点击左侧菜单栏分组设备列表，选中菜单设备，右侧出现设备列表，此时设备列表显示为空。
2017-09-13_15-17-57.png-62.6kB

点击列表上方创建按钮，出现以下对话框：
2017-09-13_15-28-04.png-52.9kB

STEP#02
为您的设备输入一个名称和描述，其它的栏位将会在平台使用教程中说明，例如：
2017-09-13_15-31-47.png-58.1kB

STEP#03
点击确认后，Neptune为该设备生成设备序列号以及团队令牌。上述信息是设备通过Triton能正确连接到Neptune的重要信息，后续仍可以在平台中查询得到。
2017-09-13_15-32-33.png-57.9kB

STEP#04
再次返回到设备列表，就可以看到您的设备已经添加到Neptune中了。
2017-09-13_15-44-04.png-53.2kB

2.3 下载Triton

Triton Windows
x86 https://www.neptune-iiot.net/triton-release/triton-windows-386.exe
x64 https://www.neptune-iiot.net/triton-release/triton-windows-amd64.exe

Triton目前支持以下版本：
Windows(x86/x64)、WinCE(x86)、Linux(x86/x64/ARMv5以上/AArch64)，请按实际情况选择适配版本。其它版本请从以下地址下载：

Triton WinCE
x86 https://www.neptune-iiot.net/triton-release/triton-wince-386.zip

Triton Linux
x86 https://www.neptune-iiot.net/triton-release/triton-linux-386
x64 https://www.neptune-iiot.net/triton-release/triton-linux-amd64
AArch64 https://www.neptune-iiot.net/triton-release/triton-linux-arm64
ARMv5 https://www.neptune-iiot.net/triton-release/triton-linux-armv5
ARMv6 https://www.neptune-iiot.net/triton-release/triton-linux-armv6
ARMv7 https://www.neptune-iiot.net/triton-release/triton-linux-armv7

2.4 运行Triton

STEP#01
在运行Triton前，需要生成Triton的配置文件。请在Windows命令提示符（可通过 Win键+R 弹出运行并输入cmd调用）中，定位到下载的Triton的所在目录。

STEP#02
输入以下命令：

  1. triton-windows-amd64.exe -g triton.toml

2017-09-13_16-38-26.png-25.9kB

命令执行后，在triton所在目录下，生成配置文件 triton.toml
2017-09-13_16-39-24.png-19.5kB

STEP#03
使用文本编辑器打开triton.toml，推荐使用Notepad++, EditPlus等文本编辑工具进行操作，使用Windows自带的记事本打开，可能会丢失格式，但不影响使用。以下截图使用Visual Studio Code打开：
2017-09-13_17-12-07.png-107.9kB

STEP#04
修改配置文件中的第四行、第二十二行内容：
第四行需要填写设备的序列号，序列号可以在设备列表中查找得到：
2017-09-13_16-49-41.png-44.9kB

  1. Serial = "6ed92f55a083f1038b005eb28ef0c760"

第二十二行需要填写团队令牌，团队令牌可以在团队设置中查找得到：
2017-09-13_16-52-04.png-105.6kB

  1. Token = "05712fb7cf95547d3e0f2ad076c3db75"

如果您需要使用证书加密连接，请将UseSSL改为true，连接端口改为8883，并修改相关配置项：

  1. [MessageQueue]
  2. #服务器地址保持不变
  3. Address = "www.neptune-iiot.net"
  4. Token = "05712fb7cf95547d3e0f2ad076c3db75"
  5. #修改端口为8883
  6. Port = "8883"
  7. #启用加密
  8. UseSSL = true
  9. #加密连接属于公测阶段，InsecureSSL需要设置为`true`才能正常连接
  10. InsecureSSL = true
  11. #CA证书路径
  12. CAPath = "/path/to/ca.crt"
  13. #客户证书路径
  14. CertPath = "/path/to/client.crt"
  15. #客户私钥路径
  16. KeyPath = "/path/to/client.key"
  17. #客户私钥密码
  18. KeyPassphrase = "hunter2"

修改配置文件中最后的LogLevel配置，让程序在日志中显示更多的内容：

  1. LogLevel = 5

修改完成后，保存triton.toml, 双击运行triton-windows-amd64.exe(Windows可能会提示拦截该程序，点击仍要运行即可），输出如下内容：
2017-09-13_17-15-11.png-13.8kB

2.5 测试连接是否成功

打开Neptune，设备列表，查看列表中的设备是否已经显示在线，在线表示Triton与Neptune已经成功通讯。如果依然显示为离线，请检查：

  • Triton所在的计算机网络是否正常；
  • triton.toml中需要修改的两项内容是否正确填写；

2017-09-13_17-13-09.png-34.5kB

3. 使用Triton与Neptune进行数据交互

3.1 概述

Triton目前提供了三种数据交互的方式，分别为：

请根据您的实际情况，选择适配的方法。

3.2 定义您需要传输的数据

所有需要传输的数据都需要先在Neptune中先定义，Neptune中称为数据定义，每一个设备需要维护一份数据定义。如果数据不事先定义好，在数据传输时，平台会把无定义的数据丢弃。

3.2.1 添加数据定义

STEP#01
从设备列表中找到您需要添加数据定义的设置，点击设备名称进入设备表单；
2017-09-13_18-52-06.png-93.9kB

STEP#02
采用key/value模式（即编号/值）规划好您需要传输的数据，您需要为每个需要传输的变量定义一个在本设备中唯一的编号,建议编写具有阅读性、便于理解的编号；比如我们要传输以下内容，编号规划如下：

  • 温度：temp，数字
  • 湿度：humidity， 数字
  • 照度：illuminance， 数字
  • 是否工作：is_running， 布尔
  • 工作状态：status， 文本

STEP#03
将上述内容输入到数据定义表格中；
a) 点击添加，在对话框中逐项输入第2点中的范例数据[说明1]：
2017-09-14_10-01-26.png-161kB

说明1
1. 数据ID由数字和字母组成，不能包含特殊字符： + - * / > < = % . \ & $ # @， 但可以包含 _ (下划线)。
2. 数据ID、名称以及数据类型为必填项，其中数据类型可选值为：数字(不区分整形和浮点型)、字符、布尔类型；

b) 如果您的数据存在枚举型（即用数值代表一个选项，例如：1->男，2->女），可以使用数据转义，数据转义会将得到的数据值，直接翻译为转义值
2017-09-14_10-20-07.png-124.2kB

c) 全部添加完成后，效果如下：
2017-09-14_10-20-56.png-27.6kB

STEP#04
每个设备都需要有这样一份数据定义，首个设备需要按照上述步骤手动创建，创建后可以将其保存为模板或者导出Excel方便下次直接引用或者使用Excel文件导入，以减少重复的操作次数；

3.3 使用TCP与Triton进行Socket通讯

说明
与3.4 使用Modbus协议读取您的数据 二选其一即可。

3.3.1 运行Triton

按照2.4 运行Triton中的描述正确运行Triton程序。

3.3.2 您的程序作为TCP Client与Triton通讯

Triton正常运行后，它会建立一个Socket Server，Server信息如下：

  1. Address = 127.0.0.1 (或本机局域网IP)
  2. Port = 8864

请您在您的工程中，通过代码使用Socket通讯连接到上述地址；

3.3.2.1 发送数据到Neptune

当您有数据发送需求时，您需要将需要传输的数据按照特定的格式构造字符串，并将字符串发送到Triton建立的Socket Server中。字符串的格式为：

  1. s|key1,value1|key2,value2|……|keyN,valueN

其中s|为固定的字符前缀，所有数据以编号和值作为一组，编号与值的分隔符为,(英文)，每组编号值之间分隔符为|。

以3.2 数据定义中的数据为例，构造的字符串为：

  1. s|temp,25.8|illuminance,600|humidity,70|is_running,1|status,2

将上述字符串以Socket的方式发送到127.0.0.1:8864即可。

特别说明
1. 数据发送的时机及频率由用户的程序决定；
2. 每次发送时，仅需要发生当前需要发送的key/value即可，不必将所有的key/value都构造在发送字符串中。

3.3.2.2 从Neptune接收数据

除了3.3.2.1 发送数据到Neptune中介绍的将数据从您的设备发送到Neptune以外，还支持接收来自Neptune的数据；从Neptune下发到设备的数据分为两类：

  • 系统用数据
  • 用户自定义数据

只有用户自定义数据用户才能接收得到，系统用数据会由Triton接收后进行特定处理，不会转交给用户。用户可以通过自行编写下发的数据，并在用户程序接收后做特定的处理。

当用户设备有数据接收需求时，可以向Triton建立的Socket Server中发送以下消息：

  1. r

Socket Server将Neptune的数据返回给到TCP Client，Neptune的数据以队列的方式存在，每次向Socket Server发送r时，取出一条数据，直到所有数据取完后，Socket Server返回NODATA,表示队列中已无数据。

3.4 使用Modbus协议读取您的数据

说明
与 3.3 使用TCP与Triton进行Socket通讯 二选其一即可。

3.4.1 设备实现Modbus协议

在开始使用Modbus协议作为数据交互方式时，需确认以下内容：

  • 您的设备程序需要实现Modbus协议，并作为从站(Slave)将数据写入Modbus指定的存储区中；
  • 您的设备程序如果与设备是分离的，那么设备与运行程序的计算机之间需要用网线或者串口线相连，网络连接实现Modbus-TCP，串口线连接实现Modbus-RTU；建议使用网线连接并实现Modbus-TCP协议；
  • 您的程序已正确运行，并正确调用Triton动态库；
  • 建议在开始本章节的测试前，您已经使用Modbus工具成功地从设备中读取到数据，以减少影响后续操作的因素；

3.4.2 在Neptune上安装Modbus Connector应用套件

该工具目前处于内测阶段，平台注册用户默认已开始此功能，因此不需要额外的安装工作，请直接查看3.5.2 结果测试-Modbus。

3.5 集成Triton外部库到您的程序

3.5.1 下载Triton动态库

Triton动态库包含一个库文件和一个头文件，请根据您使用的开发语言及平台下载对应的动态库：

Triton for Windows Library
x86 https://www.neptune-iiot.net/triton-release/libs/triton-windows-386.zip

3.5.2 动态库说明

libtriton.h内容如下：

  1. #pragma once
  3. #ifdef libtriton_EXPORTS
  4. #define LIBTRITON_API __declspec(dllexport)
  5. #else
  6. #define LIBTRITON_API __declspec(dllimport)
  7. #endif
  9. #ifndef NELEMS
  10. #define NELEMS(x)  (sizeof(x) / sizeof((x)[0]))
  11. #endif
  13. #define RECV_BUFSIZE 16384
  15. typedef struct KeyValue {
  16.     char* Key;
  17.     char* Value;
  18. }KeyValue;
  20. typedef struct Payload {
  21.     int size;
  22.     KeyValue *keyValue;
  23. }Payload;
  25. #ifdef __cplusplus
  26. extern "C" {
  27. #endif
  29.     // Send data
  30.     // Parameters:
  31.     // kvs - array of key value pairs (KeyValue structs) to be sent
  32.     // size - length of array (kvs)
  33.     // Return values:
  34.     // 0 - success
  35.     // -1 - error connecting to server
  36.     // -2 - error writing to server
  37.     // -3 - error reading response from server
  38.     // -4 - data error
  39.     LIBTRITON_API int Send(KeyValue kvs[], int size);
  41.     LIBTRITON_API int Send_T(KeyValue kvs[], int size);
  43.     LIBTRITON_API int Send_Compat(KeyValue kvs[], int size);
  45.     LIBTRITON_API int Send_Compat_T(KeyValue kvs[], int size);
  47.     // Receive data
  48.     // Parameters:
  49.     // buffer - pointer to buffer for writing received message
  50.     // Returns received data length by default, otherwise:
  51.     // -1 - error connecting to server
  52.     // -2 - error writing to server
  53.     // -3 - error reading response from server
  54.     // -4 - data error
  55.     LIBTRITON_API Payload* Receive();
  57.     LIBTRITON_API Payload* Receive_T();
  59.     LIBTRITON_API Payload* Receive_Compat();
  61.     LIBTRITON_API Payload* Receive_Compat_T();
  63.     // MQTT status
  64.     // Returns MQTT connection status, true if connected, false otherwise
  65.     LIBTRITON_API bool Status();
  67.     LIBTRITON_API bool Status_T();
  69.     LIBTRITON_API bool Status_Compat();
  71.     LIBTRITON_API bool Status_Compat_T();
  73.     LIBTRITON_API void freePayload(Payload *payload);
  75. #ifdef __cplusplus
  76. }
  77. #endif
  • 需要发送的数据按结构体KeyValue构造，将KeyValue数组传入发送函数Send()中；
  • 带有_T后缀的函数为包含执行时间输出的函数，以便于测试
  • 带有_Compat后缀的函数为兼容模式函数，一般情况下不需使用
  • Receive函数必须由调用者定期调用以获取消息

3.5.3 将动态库引入您的工程

编写程序，在适当的时机以适当的频率调用发送和接收方法即可。可参考教程中的示例程序。

3.5.4 示例程序

  2. #include "stdafx.h"
  3. #include <windows.h>
  4. #include <iostream>
  5. #include <string>
  6. using namespace std;
  7. // Import the header
  8. #include "libtriton.h"
  10. enum
  11. {
  12.     eLedBlink = 1,
  13.     eLedOn,
  14.     eLedOff
  15. };
  17. const unsigned int iMaxSize = 256;
  18. static bool isExit = false;
  19. static int  iLedStatus = eLedBlink;
  21. DWORD WINAPI MyReceiveThread(LPVOID lpParam);
  22. int SendDataToServer(string led1_state,string led2_state);
  24. void LedOn();
  25. void LedOff();
  26. void LedBlink();
  28. int main()
  29. {
  30.     DWORD   dwThreadId;
  31.     HANDLE  ThreadHandle;
  33.     ThreadHandle = CreateThread(NULL,0,MyReceiveThread,NULL,0,&dwThreadId);
  34.     if (ThreadHandle == NULL)
  35.     {
  36.         printf("Create thread error\n");
  37.         return -1;
  38.     }
  40.     //Get UUID 
  41.     char uuid[32] = { 0 };
  42.     GetUUID(uuid);
  43.     printf("uuid %s\n", uuid);
  45.     // Get MQTT connection status
  46.     bool online = Status();
  48.     if (online)
  49.     {
  50.         printf("Network is connected\n");
  51.     }
  52.     else
  53.     {
  54.         printf("Network is disconnect\n");
  55.     }
  57.     while (!isExit)
  58.     {
  59.         if (iLedStatus == eLedOn)
  60.         {
  61.             LedOn();
  62.         }
  63.         else if (iLedStatus == eLedOff)
  64.         {
  65.             LedOff();
  66.         }
  67.         else if (iLedStatus == eLedBlink)
  68.         {
  69.             LedBlink();
  70.         }
  71.         Sleep(500);
  72.         // Send the LED status to server
  73.     }
  75.     system("pause");
  76.     WaitForMultipleObjects(1, &ThreadHandle, TRUE, INFINITE);
  77.     return 0;
  78. }
  80. DWORD WINAPI MyReceiveThread(LPVOID lpParam)
  81. {
  82.     while (!isExit)
  83.     {
  84.         // Receive data from Neptune
  85.         Payload *payload = Receive();
  86.         // Check if data size is not zero
  87.         if (payload->size > 0)
  88.         {
  89.             for (int i = 0; i < payload->size; ++i) 
  90.             {
  91.                 string strKey = payload->keyValue[i].key;
  92.                 string strValue = payload->keyValue[i].value;
  93.                 if (strcmp(strKey.c_str(),"switch") == 0)
  94.                 {
  95.                     if (strcmp(strValue.c_str(),"ALL_ON") == 0)
  96.                     {
  97.                         iLedStatus = eLedOn;
  98.                     }
  99.                     else if (strcmp(strValue.c_str(), "ALL_OFF") == 0)
  100.                     {
  101.                         iLedStatus = eLedOff;
  102.                     }
  103.                     else if (strcmp(strValue.c_str(), "NORMAL") == 0)
  104.                     {
  105.                         iLedStatus = eLedBlink;
  106.                     }
  107.                 }
  108.                 //printf("%d. key: %s, value: %s", i, payload->keyValue[i].key, payload->keyValue[i].value);
  109.             }
  110.         }
  111.         // Use `freePayload` helper function to free the payload
  112.         freePayload(payload);
  113.         Sleep(1000);
  114.     }
  115.     return 0;
  116. }
  118. void LedOn()
  119. {
  120.     printf("Led1 ●,Led2 ●\n");
  121.     SendDataToServer("On", "On");
  122. }
  124. void LedOff()
  125. {
  126.     printf("Led1 ○,Led2 ○\n");
  127.     SendDataToServer("Off", "Off");
  128. }
  130. void LedBlink()
  131. {
  132.     printf("Led1 ○,Led2 ●\n");
  133.     SendDataToServer("Off", "On");
  134.     Sleep(500);
  135.     printf("Led1 ●,Led2 ○\n");
  136.     SendDataToServer("On", "Off");
  137. }
  139. int SendDataToServer(string led1_state, string led2_state)
  140. {
  141.     // Let's say we have 5 pairs of key-values that we need to send
  142.     KeyValue kv[2];
  143.     //new space what you need
  144.     for (int i = 0; i < 2; i++)
  145.     {
  146.         kv[i].key = new char[iMaxSize];
  147.         kv[i].value = new char[iMaxSize];
  148.     }
  150.     // Write keys/values to the structs
  152.     sprintf_s(kv[0].key, iMaxSize, "led1");
  153.     sprintf_s(kv[0].value, iMaxSize, "%s",led1_state.c_str());
  154.     sprintf_s(kv[1].key, iMaxSize, "led2");
  155.     sprintf_s(kv[1].value, iMaxSize, "%s", led2_state.c_str());
  157.     // Send the key values to server and get its return value
  158.     int ret = Send(kv, 2);
  160.     for (int k = 0; k < 2; k++)
  161.     {
  162.         delete kv[k].key;
  163.         delete kv[k].value;
  164.     }
  166.     return ret;
  167. }

3.6 测试数据交互结果

结果测试将使用Neptune上的开发者面板进行，开发者面板的作用是查看平台数据的交互结果是否正确，以便提高调试效率，并非最终的数据应用方式。

3.6.1 结果测试-使用Socket通讯

3.6.1.1 上传数据到Neptune

STEP#01
在Neptune中打开需要调试的对象设备，同时请注意设备的状态需要是“在线”，如果设备不在线，请检查：

  • Triton是否正确运行；
  • 网络连接是否正确；

2017-09-14_11-18-04.png-119.5kB

STEP#02
打开开发者面板;
2017-09-14_11-18-57.png-184.3kB

STEP#03
选择密令项[说明1] start_data，并点击按钮推送密令到设备，点击后Triton会接收到该密令，并将数据打印在开发者面板之上。
2017-09-14_11-35-45.png-117.6kB

说明1
密令项指Neptune和Triton之间的内部沟通指令，用户也可以向设备推送自定义的沟通指令，以实现用户自定义的功能；

STEP#04
观察开发面板的数据输出窗口是否已经打印出您上传的数据，数据格式为json,您上发的数据位于data标签中，其它的键值为Neptune内部使用，用户不必关注。
2017-09-14_11-54-17.png-150.2kB

STEP#05
数据上传测试完成。

3.5.1.2 下发数据到设备

STEP#01
打开开发者面板;
2017-09-14_11-18-57.png-184.3kB

STEP#02
编写向下推送的密令，向下发送的密令只需要符合json格式（即key/value格式）即可，内容没有特定的要求，只需要您的程序能够使用即可。比如，用户期望推送"300秒后关机"到设备上，让其执行关机，那么我们可以编写以下内容：

  1. {
  2.     "action":"shutdown",
  3.     "delay":"300"
  4. }

STEP#03
将上述密令粘贴到密令输入框入，然后点击推送。消息正确推送时，界面不会有任何的错误提示，如果有出现错误提示，按提示的内容检查即可。
2017-09-22_14-02-37.png-63.8kB

STEP#04
数据推送下去后，需要使用r命令进行数据读取，如果不读取数据，将一直留存在列队中。每次通过r命令读取后，服务器中的消息就会减少一条，直到全部取完。以下我们使用SocketTool作为测试的工具：
2017-09-22_14-08-19.png-30.7kB

这里看到，推送的数据都收到了，但数据里多了一项uuid，这一项是系统默认会带上的，用于标记数据是发给哪一个设备。

  1. {
  2.     "action":"shutdown",
  3.     "delay":"300",
  4.     "uuid":"6ed92f55a083f1038b005eb28ef0c760"
  5. }

此时我们再向Triton发送r命令，可以看到，所有数据取完后，Triton回复NODATA:
2017-09-22_14-12-50.png-30.9kB

STEP#05
数据下发测试完成。

3.6.2 结果测试-使用Modbus协议

  • 由于Modbus协议本身的设计规范，无法实现下发数据的功能，即不能够实现从Neptune向您的设备推送数据；
  • 考虑到实际安全性的问题，Modbus协议暂不考虑实现修改存储区数值的功能，仅保留数据读取的功能。

3.6.2.1 上传数据到Neptune

工作流程：推送配置 -> 读取数据

3.6.2.1.1 Modbus-TCP

STEP#01
在Neptune中打开需要调试的对象设备，同时请注意设备的状态需要是“在线”，如果设备不在线，请检查：

  • Triton是否正确运行；
  • 网络连接是否正确；

2017-09-14_11-18-04.png-119.5kB

STEP#02
打开开发者面板;
2017-09-14_11-18-57.png-184.3kB

STEP#03
选择密令项[说明1]modbus_setting_tcp
2017-09-14_13-35-00.png-118.2kB

说明1
密令项指Neptune和Triton之间的内部沟通指令，用户也可以向设备推送自定义的沟通指令，以实现用户自定义的功能；

右侧出现密令的详细内容,我们需要修改密令的内容，建议将密令内容复制到文本处理工具中编辑后再粘贴到此窗口：

  1. {
  2.   "action": "modbus",
  3.   "type": "settings",
  4.   "uuid": "IdeaBoxPro-Left",
  5.   "details": {
  6.     "protocol": "tcp",
  7.     "address": "192.168.1.1",
  8.     "slave_id": 1,
  9.     "dataset": [
  10.       {
  11.         "key": "switches 1",
  12.         "region": "coilro",
  13.         "address": 0,
  14.         "length": 8
  15.       },
  16.       {
  17.         "key": "switches 2",
  18.         "region": "coilrw",
  19.         "address": 0,
  20.         "length": 16
  21.       }
  22.     ]
  23.   }
  24. }

您需要修改的部分为 address, slave_id以及dataset

a. address：即Modbus设备的IP地址;

  1. "address": "192.168.1.1"

b. slave_id：即Modbus设备的从站ID;

  1. "slave_id": 1

c. dataset：即通过Modbus协议读取的数据组，dataset为列表，dataset中的每一个元素为需要读取的数据，每个数据由数据编号、读取区域、起始地址和读取长度构成，其中数据编号与3.2.1 添加数据定义中所述的数据定义一一对应;

  1. "dataset": [
  2.       {
  3.         "key": "temp",
  4.         "region": "coilro",
  5.         "address": 0,
  6.         "length": 8
  7.       },
  8.       {
  9.         "key": "humidity",
  10.         "region": "coilrw",
  11.         "address": 0,
  12.         "length": 16
  13.       }
  14.     ]

以上配置表示通过Modbus协议读取两组数据：

  • 第一组：从coilro(Coil)中起始地址为0的位置读取长度为8的数据，数据对应数据定义中的temp;
  • 第二组：从coilrw(Discret Input)中起始地址为0的位置读取长度为16的数据，数据对应数据定义中的humidity;

STEP#04
当配置内容确定后，将全部的密令内容粘贴到密令窗口中，点击推送密令到设备
2017-09-14_14-04-53.png-93.7kB

STEP#05
选择密令modbus_read，将按第4点中的配置内容向设备请求数据，并将结果返回到输出面板中。
2017-09-14_14-23-46.png-140.5kB

3.6.2.1.2 Modbus-RTU

STEP#01
在Neptune中打开需要调试的对象设备，同时请注意设备的状态需要是“在线”，如果设备不在线，请检查：

  • Triton是否正确运行；
  • 网络连接是否正确；

2017-09-14_11-18-04.png-119.5kB

STEP#02
打开开发者面板;
2017-09-14_11-18-57.png-184.3kB

STEP#03
选择密令项[说明1]modbus_ports，该密令能够将计算机上的串口列表返回供用户选择，如果您已经清楚您设备的连接串口，可以跳过此步骤。
2017-09-14_14-32-53.png-115.7kB

该计算机共有三个串口，本示例中的设备连接在串口/dev/ttyS0上。

说明1
密令项指Neptune和Triton之间的内部沟通指令，用户也可以向设备推送自定义的沟通指令，以实现用户自定义的功能；

STEP#04
选择密令项modbus_setting_rtu;
2017-09-14_13-35-00.png-118.2kB

右侧出现密令的详细内容,我们需要修改密令的内容，建议将密令内容复制到文本处理工具中编辑后再粘贴到此窗口：

  1. {
  2.   "action": "modbus",
  3.   "type": "settings",
  4.   "details": {
  5.     "protocol": "rtu",
  6.     "serial_port": "/dev/ttyS0",
  7.     "baudrate": 9600,
  8.     "databits": 8,
  9.     "parity": "none",
  10.     "stopbits": 1,
  11.     "slave_id": 1,
  12.     "uuid": "IdeaBoxPro-Right",
  13.     "dataset": [
  14.       {
  15.         "key": "temp",
  16.         "region": "coilro",
  17.         "address": 0,
  18.         "length": 8
  19.       },
  20.       {
  21.         "key": "humidity",
  22.         "region": "coilrw",
  23.         "address": 0,
  24.         "length": 16
  25.       }
  26.     ]
  27.   }
  28. }

您需要修改的部分为 serial_port、baudrate、databits、parity、stopbits、slave_id、dataset

a. serial_port：计算机与设备相连的串口;

  1. "serial_port": "/dev/ttyS0";

b. baudrate：波特率;

  1. "baudrate": 9600

c. databits：数据位;

  1. "databits": 8

d. parity：奇偶校验;

  1. "parity": "none"

d. stopbits：停止位;

  1. "stopbits": 1

e. slave_id：从站ID;

  1. "slave_id": 1

f. dataset：即通过Modbus协议读取的数据组，dataset为列表，dataset中的每一个元素为需要读取的数据，每个数据由数据编号、读取区域、起始地址和读取长度构成，其中数据编号与3.2.1 添加数据定义中所述的数据定义一一对应。

  1. "dataset": [
  2.       {
  3.         "key": "temp",
  4.         "region": "coilro",
  5.         "address": 0,
  6.         "length": 8
  7.       },
  8.       {
  9.         "key": "humidity",
  10.         "region": "coilrw",
  11.         "address": 0,
  12.         "length": 16
  13.       }
  14.     ]

以上配置表示通过Modbus协议读取两组数据：

  • 第一组：从coilro(Coil)中起始地址为0的位置读取长度为8的数据，数据对应数据定义中的temp;
  • 第二组：从coilrw(Discret Input)中起始地址为0的位置读取长度为16的数据，数据对应数据定义中的humidity;

STEP#05
当配置内容确定后，将全部的密令内容粘贴到密令窗口中，点击推送密令到设备
2017-09-14_14-04-53.png-93.7kB

STEP#06
选择密令modbus_read，将按第4点中的配置内容向设备请求数据，并将结果返回到输出面板中。
2017-09-14_14-23-46.png-140.5kB

3.6.3 结果测试-集成Triton外部库

结果测试将使用Neptune上的开发者面板进行，开发者面板的作用是查看平台数据的交互结果是否正确，以便提高调试效率，并非最终的数据应用方式。

3.6.3.1 上传数据到Neptune

STEP#01
在Neptune中打开需要调试的对象设备，同时请注意设备的状态需要是“在线”，如果设备不在线，请检查：

  • Triton是否正确运行；
  • 网络连接是否正确；

2017-09-14_11-18-04.png-119.5kB

STEP#02
打开开发者面板;
2017-09-14_11-18-57.png-184.3kB

STEP#03
选择密令项[说明1] start_data，并点击按钮推送密令到设备，点击后Triton会接收到该密令，并将数据打印在开发者面板之上。
2017-09-14_11-35-45.png-117.6kB

说明1
密令项指Neptune和Triton之间的内部沟通指令，用户也可以向设备推送自定义的沟通指令，以实现用户自定义的功能；

STEP#04
观察开发面板的数据输出窗口是否已经打印出您上传的数据，数据格式为json,您上发的数据位于data标签中，其它的键值为Neptune内部使用，用户不必关注。
2017-09-14_11-54-17.png-150.2kB

STEP#05
数据上传测试完成。

3.6.1.2 下发数据到设备

STEP#01
打开开发者面板;
2017-09-14_11-18-57.png-184.3kB

STEP#02
编写向下推送的密令，向下发送的密令只需要符合json格式（即key/value格式）即可，内容没有特定的要求，只需要您的程序能够使用即可。比如，用户期望推送"300秒后关机"到设备上，让其执行关机，那么我们可以编写以下内容：

  1. {
  2.     "action":"shutdown",
  3.     "delay":"300"
  4. }

STEP#03
将上述密令粘贴到密令输入框入，然后点击推送。消息正确推送时，界面不会有任何的错误提示，如果有出现错误提示，按提示的内容检查即可。
2017-09-22_14-02-37.png-63.8kB

STEP#04
数据推送下去后，按上述说明使用triton_recv()进行读取，以下为程序输出结果：
2017-09-22_18-01-24.png-3.6kB

这里看到，推送的数据都收到了，但数据里多了一项uuid，这一项是系统默认会带上的，用于标记数据是发给哪一个设备。

  1. {
  2.     "action":"shutdown",
  3.     "delay":"300",
  4.     "uuid":"6ed92f55a083f1038b005eb28ef0c760"
  5. }

此时我们再调用triton_recv()方法，可以看到，所有数据取完后，Triton回复NODATA:
2017-09-22_18-07-02.png-4.8kB

STEP#05
数据下发测试完成。

4. 在Neptune上对数据进行应用

请参考《Neptune工业设备物联云平台教程（二） 使用Neptune管理和监控您的设备》。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注